October 2017 - Sound-open-firmware - mailman.alsa-project.org

Re: [Sound-open-firmware] Support for Tangier SoC
by Liam Girdwood 06 Nov '17

06 Nov '17

Hi Sven, Btw, best to subscribe as non member posts are blocked and delayed. On Tue, 2017-10-17 at 20:49 +0200, Sven Schwermer wrote: > Hi guys, > > Thanks for your replies. I had tried a running a vanilla kernel on the > Edison. There, the sst_pci driver is probed, but the platform data is > not set and that’s basically where I got stuck because I couldn’t > figure out where that’s supposed to be set. Is that usually ACPI’s > job? > I dont think ACPI is used by the ADSP on Edison, I think it's purely a PCI device. Vanilla kernel wont work either atm, you will need my topic/sof-v4.13 branch from here :- git://git.kernel.org/pub/scm/linux/kernel/git/lrg/asoc.git Note that this branch only works on the SOF 1.0-dev branches (that are not stable) and not the stable master branch. The stable SOF master firmware branch has a different IPC ABI and only works with the topic/reef kernels (that unfortunately dont support PCI mode on Edison) :( > What exactly should happen once the mrfld_sst SFI IPC is enumerated? I > am lacking the big picture and the order of events here. Is there an > overview document somewhere available online? > There is also more than one driver upstream. The sst driver is for Intel's closed source FW. The open source FW uses different ABIs and APIs to the closed source version, currently you need to blacklist the old SST modules in order to load the SOF FW and driver (this is being fixed in upstream atm) > I guess, the nocodec mode would be fine as a start. > Yes. Liam > Thanks, Sven > > > On 16 Oct 2017, at 17:59, Pierre-Louis Bossart <pierre-louis.bossart(a)linux.intel.com> wrote: > > > > On 10/16/17 10:19 AM, Liam Girdwood wrote: > >> On Sun, 2017-10-15 at 19:51 +0200, Sven Schwermer wrote: > >>> Hi. > >>> > >>> I was wondering if the Tangier SoC (Merrifield platform) is or will be > >>> supported by SOF? I have the Intel Edison compute module in mind. > >>> > >> Yes, it _should_ work on Merrifield, but I don't have Edison HW so some > >> things on the driver side might need some work. > >> The 1.0-dev branch and sof-v4.13 kernel will probably be better for > >> Edison than the stable 0.95 branch atm (mainly due to driver updates), > >> but 1.0-dev is still has a few issues prior to doing an rc1 tag. > > > > The main difference with Baytrail is pci/acpi enumeration, and sfi/acpi for the firmware. I've been wanting to enable Tangier for some time but could never figure out how to add a reference to an audio codec, so it'd likely work in 'nocodec' mode, with just the I2S signals on the connector. >

4 10

[Sound-open-firmware] [PATCH] Volume, FIR EQ, IIR EQ, tone: Fix SOF_CTRL_CMD_SWITCH polarity
by Seppo Ingalsuo 30 Oct '17

30 Oct '17

This patch inverts the use of switch value. A non-zero value unmutes the audio path. Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo(a)linux.intel.com> --- src/audio/eq_fir.c | 11 +++++++---- src/audio/eq_iir.c | 9 +++++---- src/audio/tone.c | 9 +++++---- src/audio/volume.c | 6 +++--- 4 files changed, 20 insertions(+), 15 deletions(-) diff --git a/src/audio/eq_fir.c b/src/audio/eq_fir.c index 9056808..8babed3 100644 --- a/src/audio/eq_fir.c +++ b/src/audio/eq_fir.c @@ -33,6 +33,7 @@ #include <stdint.h> #include <stddef.h> #include <errno.h> +#include <stdbool.h> #include <reef/reef.h> #include <reef/lock.h> #include <reef/list.h> @@ -330,21 +331,23 @@ static int fir_cmd_set_value(struct comp_dev *dev, struct sof_ipc_ctrl_data *cda struct comp_data *cd = comp_get_drvdata(dev); int j; uint32_t ch; + bool val; if (cdata->cmd == SOF_CTRL_CMD_SWITCH) { trace_eq("mst"); for (j = 0; j < cdata->num_elems; j++) { ch = cdata->chanv[j].channel; + val = cdata->chanv[j].value; tracev_value(ch); - tracev_value(cdata->chanv[j].value); + tracev_value(val); if (ch >= PLATFORM_MAX_CHANNELS) { trace_eq_error("che"); return -EINVAL; } - if (cdata->chanv[j].value > 0) - fir_mute(&cd->fir[ch]); - else + if (val) fir_unmute(&cd->fir[ch]); + else + fir_mute(&cd->fir[ch]); } } else { trace_eq_error("ste"); diff --git a/src/audio/eq_iir.c b/src/audio/eq_iir.c index d3a8fa3..88382fe 100644 --- a/src/audio/eq_iir.c +++ b/src/audio/eq_iir.c @@ -33,6 +33,7 @@ #include <stdint.h> #include <stddef.h> #include <errno.h> +#include <stdbool.h> #include <reef/reef.h> #include <reef/lock.h> #include <reef/list.h> @@ -331,7 +332,7 @@ static int iir_cmd_set_value(struct comp_dev *dev, struct sof_ipc_ctrl_data *cda struct comp_data *cd = comp_get_drvdata(dev); int j; uint32_t ch; - uint32_t val; + bool val; if (cdata->cmd == SOF_CTRL_CMD_SWITCH) { trace_eq_iir("mst"); @@ -344,10 +345,10 @@ static int iir_cmd_set_value(struct comp_dev *dev, struct sof_ipc_ctrl_data *cda trace_eq_iir_error("che"); return -EINVAL; } - if (val > 0) - iir_mute_df2t(&cd->iir[ch]); - else + if (val) iir_unmute_df2t(&cd->iir[ch]); + else + iir_mute_df2t(&cd->iir[ch]); } } else { trace_eq_iir_error("ste"); diff --git a/src/audio/tone.c b/src/audio/tone.c index d565c17..3eb08e9 100644 --- a/src/audio/tone.c +++ b/src/audio/tone.c @@ -33,6 +33,7 @@ #include <stdint.h> #include <stddef.h> #include <errno.h> +#include <stdbool.h> #include <reef/reef.h> #include <reef/lock.h> #include <reef/list.h> @@ -466,7 +467,7 @@ static int tone_cmd_set_value(struct comp_dev *dev, struct sof_ipc_ctrl_data *cd struct comp_data *cd = comp_get_drvdata(dev); int j; uint32_t ch; - uint32_t val; + bool val; if (cdata->cmd == SOF_CTRL_CMD_SWITCH) { trace_tone("mst"); @@ -479,10 +480,10 @@ static int tone_cmd_set_value(struct comp_dev *dev, struct sof_ipc_ctrl_data *cd trace_tone_error("che"); return -EINVAL; } - if (val > 0) - tonegen_mute(&cd->sg[ch]); - else + if (val) tonegen_unmute(&cd->sg[ch]); + else + tonegen_mute(&cd->sg[ch]); } } else { diff --git a/src/audio/volume.c b/src/audio/volume.c index 28d3225..f52ab46 100644 --- a/src/audio/volume.c +++ b/src/audio/volume.c @@ -468,10 +468,10 @@ static int volume_ctrl_set_cmd(struct comp_dev *dev, struct sof_ipc_ctrl_data *c tracev_value(cdata->chanv[j].channel); tracev_value(cdata->chanv[j].value); if (cdata->chanv[j].channel == cd->chan[i]) { - if (cdata->chanv[j].value > 0) - volume_set_chan_mute(dev, i); - else + if (cdata->chanv[j].value) volume_set_chan_unmute(dev, i); + else + volume_set_chan_mute(dev, i); } } } -- 2.11.0

2 1

[Sound-open-firmware] [PATCH 1/5] IPC: Add new enum commands and an index into control data struct
by Seppo Ingalsuo 24 Oct '17

24 Oct '17

This patch adds to struct sof_ipc_ctrl_data three new commands SOF_CTRL_CMD_ENUM, SOF_CTRL_CMD_SWITCH, and SOF_CTRL_CMD_BINARY. In addition an index parameter is added to address various features or registers. Commands SOF_CTRL_CMD_ROUTE, SOF_CTRL_CMD_SRC, SOF_CTRL_CMD_LOOPBACK, SOF_CTRL_CMD_EQ_SWITCH, SOF_CTRL_CMD_EQ_CONFIG, SOF_CTRL_CMD_MUTE, and SOF_CTRL_CMD_UNMUTE are removed. Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo(a)linux.intel.com> --- src/include/uapi/ipc.h | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/include/uapi/ipc.h b/src/include/uapi/ipc.h index 281e77a..5658b9a 100644 --- a/src/include/uapi/ipc.h +++ b/src/include/uapi/ipc.h @@ -437,25 +437,23 @@ struct sof_ipc_stream_posn { /* control data type and direction */ enum sof_ipc_ctrl_type { + /* per channel data - uses struct sof_ipc_ctrl_value_chan */ SOF_CTRL_TYPE_VALUE_CHAN_GET = 0, SOF_CTRL_TYPE_VALUE_CHAN_SET, + /* per component data - uses struct sof_ipc_ctrl_value_comp */ SOF_CTRL_TYPE_VALUE_COMP_GET, SOF_CTRL_TYPE_VALUE_COMP_SET, + /* bespoke data - struct struct sof_abi_hdr */ SOF_CTRL_TYPE_DATA_GET, SOF_CTRL_TYPE_DATA_SET, }; /* control command type */ enum sof_ipc_ctrl_cmd { - SOF_CTRL_CMD_VOLUME = 0, - SOF_CTRL_CMD_ROUTE, - SOF_CTRL_CMD_SRC, - SOF_CTRL_CMD_LOOPBACK, - SOF_CTRL_CMD_EQ_SWITCH, - SOF_CTRL_CMD_EQ_CONFIG, - /* Mute is similar to volume, but maps better onto ALSA switch controls */ - SOF_CTRL_CMD_MUTE, - SOF_CTRL_CMD_UNMUTE, + SOF_CTRL_CMD_VOLUME = 0, /* maps to ALSA volume style controls */ + SOF_CTRL_CMD_ENUM, /* maps to ALSA enum style controls */ + SOF_CTRL_CMD_SWITCH, /* maps to ALSA switch style controls */ + SOF_CTRL_CMD_BINARY, /* maps to ALSA binary style controls */ }; /* generic channel mapped value data */ @@ -481,6 +479,7 @@ struct sof_ipc_ctrl_data { /* control access and data type */ enum sof_ipc_ctrl_type type; enum sof_ipc_ctrl_cmd cmd; + uint32_t index; /* control index for comps > 1 control */ /* control data - can either be appended or DMAed from host */ struct sof_ipc_host_buffer buffer; @@ -497,7 +496,6 @@ struct sof_ipc_ctrl_data { }; } __attribute__((packed)); - /* * Component */ -- 2.11.0

2 10

[Sound-open-firmware] [PATCH V2] SRC: Use a multi-channel FIR core to optimize speed plus other cleanup
by Seppo Ingalsuo 20 Oct '17

20 Oct '17

This patch changes the sample rate conversion processing to use a single multi-channel filter instead of per channel called mono filter instances. The filter output is now rounded with 1/2 LSB add. The polyphase filter input input block sizes are multiplied in SRC initialization to reach near to or exacly the period length to reduce polyphase filter call overhead. The polyphase filter is now called via function pointer for more flexibility with audio data formats. Currently S32_LE and S24_4LE are supported. Code cleanup includes removal of redundant variables and some debug print code. Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo(a)linux.intel.com> --- src/audio/src.c | 200 +++++++++++------------ src/audio/src_core.c | 448 +++++++++++++++++++++++++++------------------------ src/audio/src_core.h | 42 +---- 3 files changed, 329 insertions(+), 361 deletions(-) diff --git a/src/audio/src.c b/src/audio/src.c index 4c4bc6e..9fe81d3 100644 --- a/src/audio/src.c +++ b/src/audio/src.c @@ -55,7 +55,7 @@ /* src component private data */ struct comp_data { - struct polyphase_src src[PLATFORM_MAX_CHANNELS]; + struct polyphase_src src; struct src_param param; int32_t *delay_lines; uint32_t sink_rate; @@ -63,16 +63,16 @@ struct comp_data { int32_t *sbuf_w_ptr; int32_t *sbuf_r_ptr; int sbuf_avail; - int sign_extend_s24; /* Set if need to copy sign bit to b24..b31 */ void (* src_func)(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *consumed, size_t *produced); + void (* polyphase_func)(struct src_stage_prm *s); }; /* Fallback function */ -static void fallback_s32(struct comp_dev *dev, struct comp_buffer *source, +static void src_fallback(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { *bytes_read = 0; @@ -84,101 +84,110 @@ static void src_2s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { - struct polyphase_src *s; struct src_stage_prm s1; struct src_stage_prm s2; - int j; + int s1_blk_in; + int s1_blk_out; + int s2_blk_in; + int s2_blk_out; struct comp_data *cd = comp_get_drvdata(dev); int32_t *dest = (int32_t *) sink->w_ptr; int32_t *src = (int32_t *) source->r_ptr; - int32_t *sbuf_addr = cd->delay_lines; int32_t *sbuf_end_addr = &cd->delay_lines[cd->param.sbuf_length]; int32_t sbuf_size = cd->param.sbuf_length * sizeof(int32_t); - const int nch = dev->params.channels; - const int s1_blk_in = cd->src[0].stage1->blk_in * nch; - const int s1_blk_out = cd->src[0].stage1->blk_out * nch; - const int s2_blk_in = cd->src[0].stage2->blk_in * nch; - const int s2_blk_out = cd->src[0].stage2->blk_out * nch; + int nch = dev->params.channels; int sbuf_free = cd->param.sbuf_length - cd->sbuf_avail; - int source_check = (source->avail >> 2) - s1_blk_in; /* for int32_t */ - int sink_check = (sink->free >> 2) - s2_blk_out; /* For int32_t */ int n_read = 0; int n_written = 0; int n1 = 0; int n2 = 0; + int avail_b = source->avail; + int free_b = sink->free; + int sz = sizeof(int32_t); - s1.times = 1; s1.x_end_addr = source->end_addr; s1.x_size = source->size; - s1.x_inc = nch; s1.y_end_addr = sbuf_end_addr; s1.y_size = sbuf_size; - s1.y_inc = nch; + s1.state = &cd->src.state1; + s1.stage = cd->src.stage1; + s1.x_rptr = src; + s1.y_wptr = cd->sbuf_w_ptr; + s1.nch = nch; - s2.times = 1; s2.x_end_addr = sbuf_end_addr; s2.x_size = sbuf_size; - s2.x_inc = nch; s2.y_end_addr = sink->end_addr; s2.y_size = sink->size; - s2.y_inc = nch; + s2.state = &cd->src.state2; + s2.stage = cd->src.stage2; + s2.x_rptr = cd->sbuf_r_ptr; + s2.y_wptr = dest; + s2.nch = nch; + - /* 1st stage runs once a long multiplied length block. - * The stage buffer much be large enough to fit one s1 output block - * plus one s2 input block plus jitter in s2 consumption. + /* Test if 1st stage can be run with default block length to reach + * the period length or just under it. */ - while ((n1 < cd->param.stage1_times_max) - && (n_read <= source_check) - && (sbuf_free >= s1_blk_out)) { - for (j = 0; j < nch; j++) { - s = &cd->src[j]; /* Point to src[] for this channel */ - s1.x_rptr = src++; - s1.y_wptr = cd->sbuf_w_ptr++; - src_circ_inc_wrap(&src, source->end_addr, source->size); - src_circ_inc_wrap(&cd->sbuf_w_ptr, sbuf_end_addr, sbuf_size); - s1.state = &s->state1; - s1.stage = s->stage1; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s1); - else - src_polyphase_stage_cir(&s1); - - } + s1.times = cd->param.stage1_times; + s1_blk_in = s1.times * cd->src.stage1->blk_in * nch; + s1_blk_out = s1.times * cd->src.stage1->blk_out * nch; + if ((avail_b >= s1_blk_in * sz) && (sbuf_free >= s1_blk_out)) { + cd->polyphase_func(&s1); + + cd->sbuf_w_ptr = s1.y_wptr; + cd->sbuf_avail += s1_blk_out; n_read += s1_blk_in; + avail_b -= s1_blk_in * sz; + sbuf_free -= s1_blk_out; + n1 = s1.times; + } + + /* Run one block at time the remaining data for 1st stage. */ + s1.times = 1; + s1_blk_in = cd->src.stage1->blk_in * nch; + s1_blk_out = cd->src.stage1->blk_out * nch; + while ((n1 < cd->param.stage1_times_max) && (avail_b >= s1_blk_in * sz) + && (sbuf_free >= s1_blk_out)) { + cd->polyphase_func(&s1); + + cd->sbuf_w_ptr = s1.y_wptr; cd->sbuf_avail += s1_blk_out; + n_read += s1_blk_in; + avail_b -= s1_blk_in * sz; sbuf_free -= s1_blk_out; - src = s1.x_rptr - nch + 1; - cd->sbuf_w_ptr = s1.y_wptr - nch + 1; - src_circ_dec_wrap(&src, source->addr, source->size); - src_circ_dec_wrap(&cd->sbuf_w_ptr, sbuf_addr, sbuf_size); - n1++; + n1 += s1.times; + } + + /* Test if 2nd stage can be run with default block length. */ + s2.times = cd->param.stage2_times; + s2_blk_in = s2.times * cd->src.stage2->blk_in * nch; + s2_blk_out = s2.times * cd->src.stage2->blk_out * nch; + if ((cd->sbuf_avail >= s2_blk_in) && (free_b >= s2_blk_out * sz)) { + cd->polyphase_func(&s2); + + cd->sbuf_r_ptr = s2.x_rptr; + cd->sbuf_avail -= s2_blk_in; + free_b -= s2_blk_out * sz; + n_written += s2_blk_out; + n2 = s2.times; } - /* 2nd stage runs as many min size blocks as buffers allow */ + + /* Run one block at time the remaining 2nd stage output */ + s2.times = 1; + s2_blk_in = cd->src.stage2->blk_in * nch; + s2_blk_out = cd->src.stage2->blk_out * nch; while ((n2 < cd->param.stage2_times_max) && (cd->sbuf_avail >= s2_blk_in) - && (n_written <= sink_check)) { - for (j = 0; j < nch; j++) { - s2.x_rptr = cd->sbuf_r_ptr++; - s2.y_wptr = dest++; - src_circ_inc_wrap(&cd->sbuf_r_ptr, sbuf_end_addr, sbuf_size); - src_circ_inc_wrap(&dest, sink->end_addr, sink->size); - s = &cd->src[j]; /* Point to src[] for this channel */ - s2.state = &s->state2; - s2.stage = s->stage2; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s2); - else - src_polyphase_stage_cir(&s2); - - } - cd->sbuf_r_ptr = s2.x_rptr - nch + 1; - dest = s2.y_wptr - nch + 1; - src_circ_dec_wrap(&cd->sbuf_r_ptr, sbuf_addr, sbuf_size); - src_circ_dec_wrap(&dest, sink->addr, sink->size); - n_written += s2_blk_out; + && (free_b >= s2_blk_out * sz)) { + cd->polyphase_func(&s2); + + cd->sbuf_r_ptr = s2.x_rptr; cd->sbuf_avail -= s2_blk_in; - n2++; + free_b -= s2_blk_out * sz; + n_written += s2_blk_out; + n2 += s2.times; } *bytes_read = sizeof(int32_t) * n_read; *bytes_written = sizeof(int32_t) * n_written; @@ -189,42 +198,27 @@ static void src_1s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { - struct polyphase_src *s; struct src_stage_prm s1; - int j; struct comp_data *cd = comp_get_drvdata(dev); - int32_t *dest = (int32_t *) sink->w_ptr; - int32_t *src = (int32_t *) source->r_ptr; int nch = dev->params.channels; int n_read = 0; int n_written = 0; s1.times = cd->param.stage1_times; + s1.x_rptr = (int32_t *) source->r_ptr; s1.x_end_addr = source->end_addr; s1.x_size = source->size; - s1.x_inc = nch; + s1.y_wptr = (int32_t *) sink->w_ptr; s1.y_end_addr = sink->end_addr; s1.y_size = sink->size; - s1.y_inc = nch; - s1.x_rptr = src + nch - 1; - s1.y_wptr = dest + nch - 1; - - for (j = 0; j < nch; j++) { - s = &cd->src[j]; /* Point to src for this channel */ - s1.x_rptr = src++; - s1.y_wptr = dest++; - src_circ_inc_wrap(&src, source->end_addr, source->size); - src_circ_inc_wrap(&dest, sink->end_addr, sink->size); - s1.state = &s->state1; - s1.stage = s->stage1; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s1); - else - src_polyphase_stage_cir(&s1); - - n_read += cd->param.blk_in; - n_written += cd->param.blk_out; - } + s1.state = &cd->src.state1; + s1.stage = cd->src.stage1; + s1.nch = dev->params.channels; + + cd->polyphase_func(&s1); + + n_read += nch * cd->param.blk_in; + n_written += nch * cd->param.blk_out; *bytes_read = n_read * sizeof(int32_t); *bytes_written = n_written * sizeof(int32_t); } @@ -271,7 +265,6 @@ static struct comp_dev *src_new(struct sof_ipc_comp *comp) struct sof_ipc_comp_src *src; struct sof_ipc_comp_src *ipc_src = (struct sof_ipc_comp_src *) comp; struct comp_data *cd; - int i; trace_src("new"); @@ -299,8 +292,8 @@ static struct comp_dev *src_new(struct sof_ipc_comp *comp) cd->delay_lines = NULL; cd->src_func = src_2s_s32_default; - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_reset(&cd->src[i]); + cd->polyphase_func = src_polyphase_stage_cir; + src_polyphase_reset(&cd->src); dev->state = COMP_STATE_READY; return dev; @@ -334,10 +327,8 @@ static int src_params(struct comp_dev *dev) uint32_t sink_rate; int32_t *buffer_start; int n = 0; - int i; int err; int frames_is_for_source; - int nch; int q; trace_src("par"); @@ -345,10 +336,10 @@ static int src_params(struct comp_dev *dev) /* SRC supports S24_4LE and S32_LE formats */ switch (config->frame_fmt) { case SOF_IPC_FRAME_S24_4LE: - cd->sign_extend_s24 = 1; + cd->polyphase_func = src_polyphase_stage_cir_s24; break; case SOF_IPC_FRAME_S32_LE: - cd->sign_extend_s24 = 0; + cd->polyphase_func = src_polyphase_stage_cir; break; default: trace_src_error("sr0"); @@ -407,11 +398,7 @@ static int src_params(struct comp_dev *dev) buffer_start = cd->delay_lines + cd->param.sbuf_length; /* Initize SRC for actual sample rate */ - nch = MIN(params->channels, PLATFORM_MAX_CHANNELS); - for (i = 0; i < nch; i++) { - n = src_polyphase_init(&cd->src[i], &cd->param, buffer_start); - buffer_start += cd->param.single_src; - } + n = src_polyphase_init(&cd->src, &cd->param, buffer_start); /* Reset stage buffer */ cd->sbuf_r_ptr = cd->delay_lines; @@ -434,7 +421,7 @@ static int src_params(struct comp_dev *dev) * muted if copy() is run. */ trace_src("SFa"); - cd->src_func = fallback_s32; + cd->src_func = src_fallback; return -EINVAL; break; } @@ -532,7 +519,6 @@ static int src_copy(struct comp_dev *dev) /* Run SRC function if buffers avail and free allow */ if (((int) source->avail >= need_source) && ((int) sink->free >= need_sink)) { - /* Run src */ cd->src_func(dev, source, sink, &consumed, &produced); /* Calc new free and available if data was processed. These @@ -561,14 +547,12 @@ static int src_preload(struct comp_dev *dev) static int src_reset(struct comp_dev *dev) { - int i; struct comp_data *cd = comp_get_drvdata(dev); trace_src("SRe"); cd->src_func = src_2s_s32_default; - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_reset(&cd->src[i]); + src_polyphase_reset(&cd->src); comp_set_state(dev, COMP_CMD_RESET); return 0; diff --git a/src/audio/src_core.c b/src/audio/src_core.c index 4ee2efd..080256c 100644 --- a/src/audio/src_core.c +++ b/src/audio/src_core.c @@ -45,12 +45,20 @@ #include "src_core.h" #include "src_config.h" +#define trace_src(__e) trace_event(TRACE_CLASS_SRC, __e) +#define tracev_src(__e) tracev_event(TRACE_CLASS_SRC, __e) +#define trace_src_error(__e) trace_error(TRACE_CLASS_SRC, __e) + /* TODO: These should be defined somewhere else. */ #define SOF_RATES_LENGTH 15 int sof_rates[SOF_RATES_LENGTH] = {8000, 11025, 12000, 16000, 18900, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000}; +/* The FIR maximum lenghts are per channel so need to multiply them */ +#define MAX_FIR_DELAY_SIZE_XNCH (PLATFORM_MAX_CHANNELS * MAX_FIR_DELAY_SIZE) +#define MAX_OUT_DELAY_SIZE_XNCH (PLATFORM_MAX_CHANNELS * MAX_OUT_DELAY_SIZE) + /* Calculate ceil() for integer division */ int src_ceil_divide(int a, int b) { @@ -131,6 +139,13 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, int num; int frames2; + if (nch > PLATFORM_MAX_CHANNELS) { + trace_src_error("che"); + tracev_value(nch); + return -EINVAL; + } + + a->nch = nch; a->idx_in = src_find_fs(src_in_fs, NUM_IN_FS, fs_in); a->idx_out = src_find_fs(src_out_fs, NUM_OUT_FS, fs_out); @@ -146,8 +161,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, stage1 = src_table1[a->idx_out][a->idx_in]; stage2 = src_table2[a->idx_out][a->idx_in]; - a->fir_s1 = src_fir_delay_length(stage1); - a->out_s1 = src_out_delay_length(stage1); + a->fir_s1 = nch * src_fir_delay_length(stage1); + a->out_s1 = nch * src_out_delay_length(stage1); /* Find out how many additional times the SRC can be executed while having block size less or equal to max_frames. @@ -191,8 +206,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, a->stage2_times_max = 0; a->sbuf_length = 0; } else { - a->fir_s2 = src_fir_delay_length(stage2); - a->out_s2 = src_out_delay_length(stage2); + a->fir_s2 = nch * src_fir_delay_length(stage2); + a->out_s2 = nch * src_out_delay_length(stage2); /* 2x is an empirically tested length. Since the sink buffer * capability to receive samples varies a shorter stage 2 output * block will create a peak in internal buffer usage. @@ -200,8 +215,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, a->sbuf_length = 2 * nch * stage1->blk_out * a->stage1_times_max; } - a->single_src = a->fir_s1 + a->fir_s2 + a->out_s1 + a->out_s2; - a->total = a->sbuf_length + nch * a->single_src; + a->src_multich = a->fir_s1 + a->fir_s2 + a->out_s1 + a->out_s2; + a->total = a->sbuf_length + a->src_multich; return 0; } @@ -212,8 +227,6 @@ static void src_state_reset(struct src_state *state) state->fir_delay_size = 0; state->out_delay_size = 0; state->fir_wi = 0; - state->fir_ri = 0; - state->out_wi = 0; state->out_ri = 0; } @@ -229,17 +242,8 @@ static int init_stages( src->number_of_stages = n; src->stage1 = stage1; src->stage2 = stage2; - src->blk_in = p->blk_in; - src->blk_out = p->blk_out; - if (n == 1) { - src->stage1_times = p->stage1_times; - src->stage2_times = 0; - if (stage1->blk_out == 0) - return -EINVAL; - } else { - src->stage1_times = p->stage1_times; - src->stage2_times = p->stage2_times; - } + if ((n == 1) && (stage1->blk_out == 0)) + return -EINVAL; /* Delay line sizes */ src->state1.fir_delay_size = p->fir_s1; @@ -262,10 +266,10 @@ static int init_stages( } /* Check the sizes are less than MAX */ - if ((src->state1.fir_delay_size > MAX_FIR_DELAY_SIZE) - || (src->state1.out_delay_size > MAX_OUT_DELAY_SIZE) - || (src->state2.fir_delay_size > MAX_FIR_DELAY_SIZE) - || (src->state2.out_delay_size > MAX_OUT_DELAY_SIZE)) { + if ((src->state1.fir_delay_size > MAX_FIR_DELAY_SIZE_XNCH) + || (src->state1.out_delay_size > MAX_OUT_DELAY_SIZE_XNCH) + || (src->state2.fir_delay_size > MAX_FIR_DELAY_SIZE_XNCH) + || (src->state2.out_delay_size > MAX_OUT_DELAY_SIZE_XNCH)) { src->state1.fir_delay = NULL; src->state1.out_delay = NULL; src->state2.fir_delay = NULL; @@ -279,12 +283,7 @@ static int init_stages( void src_polyphase_reset(struct polyphase_src *src) { - src->mute = 0; src->number_of_stages = 0; - src->blk_in = 0; - src->blk_out = 0; - src->stage1_times = 0; - src->stage2_times = 0; src->stage1 = NULL; src->stage2 = NULL; src_state_reset(&src->state1); @@ -294,14 +293,12 @@ void src_polyphase_reset(struct polyphase_src *src) int src_polyphase_init(struct polyphase_src *src, struct src_param *p, int32_t *delay_lines_start) { - int n_stages; - int ret; struct src_stage *stage1; struct src_stage *stage2; + int n_stages; + int ret; if ((p->idx_in < 0) || (p->idx_out < 0)) { - src->blk_in = p->blk_in; - src->blk_out = p->blk_out; return -EINVAL; } @@ -335,109 +332,157 @@ int src_polyphase_init(struct polyphase_src *src, struct src_param *p, #if SRC_SHORT == 1 /* Calculate a FIR filter part that does not need circular modification */ -static inline void fir_part(int64_t *y, int ntaps, const int16_t c[], int *ic, - int32_t d[], int *id) + +static inline void fir_part(int64_t y[], int *id, int *ic, + const int32_t data[], const int16_t coef[], int nch_x_taps, int nch) { + int64_t tap0; + int64_t tap1; int n; int64_t a = 0; + int64_t b = 0; + int c = *ic; + int d = *id; + int d_end = d - nch_x_taps; /* Data is Q1.31, coef is Q1.15, product is Q2.46 */ - for (n = 0; n < (ntaps >> 1); n++) { - a += (int64_t) c[*ic] * d[*id] - + (int64_t) c[*ic + 1] * d[*id - 1]; - *ic += 2; - *id -= 2; + if (nch == 2) { + for (n = 0; n < (nch_x_taps >> 2); n++) { + tap0 = coef[c++]; + tap1 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + b += data[d--] * tap1; + a += data[d--] * tap1; + } + if (d > d_end) { + tap0 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + } + y[1] += b; + y[0] += a; + } else { + while (d > d_end) { + tap0 = coef[c++]; + for (n = nch - 1; n >= 0; n--) + y[n] += data[d--] * tap0; + } } - if (ntaps & 1) - a += (int64_t) c[(*ic)++] * d[(*id)--]; - - *y += a; + *ic = c; + *id = d; } + #else -/* Calculate a FIR filter part that does not need circular modification */ -static inline void fir_part(int64_t *y, int ntaps, const int32_t c[], int *ic, - int32_t d[], int *id) +static inline void fir_part(int64_t y[], int *id, int *ic, + const int32_t data[], const int32_t coef[], int nch_x_taps, int nch) { + int64_t tap0; + int64_t tap1; int n; int64_t a = 0; - - /* Data is Q8.24, coef is Q1.23, product is Q9.47 */ - for (n = 0; n < (ntaps >> 1); n++) { - a += (int64_t) c[*ic] * d[*id] - + (int64_t) c[*ic + 1] * d[*id - 1]; - *ic += 2; - *id -= 2; + int64_t b = 0; + int c = *ic; + int d = *id; + int d_end = d - nch_x_taps; + + /* Data is Q1.31, coef is Q1.23, product is Q2.54 */ + if (nch == 2) { + for (n = 0; n < (nch_x_taps >> 2); n++) { + tap0 = coef[c++]; + tap1 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + b += data[d--] * tap1; + a += data[d--] * tap1; + } + if (d > d_end) { + tap0 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + } + y[1] += b; + y[0] += a; + } else { + while (d > d_end) { + tap0 = coef[c++]; + for (n = nch - 1; n >= 0; n--) + y[n] += data[d--] * tap0; + } } - if (ntaps & 1) - a += (int64_t) c[(*ic)++] * d[(*id)--]; - - *y += a; + *ic = c; + *id = d; } + #endif #if SRC_SHORT == 1 -static inline int32_t fir_filter( - struct src_state *fir, const int16_t coefs[], - int *coefi, int filter_length, int shift) +static void fir_filter(int ri0, int *ci, int wi0, int32_t in_delay[], + int32_t out_delay[], const int16_t coefs[], int dsm1, int taps, + int shift, int nch) { - int64_t y = 0; - int n1; int n2; - - n1 = fir->fir_ri + 1; - if (n1 > filter_length) { - /* No need to un-wrap fir read index, make sure fir_fi - * is ge 0 after FIR computation. - */ - fir_part(&y, filter_length, coefs, coefi, fir->fir_delay, - &fir->fir_ri); + int i; + int64_t y[PLATFORM_MAX_CHANNELS]; + int ri = ri0; + int wi = wi0; + int n1 = ri0 + 1; /* Convert to number of sequential frames */ + int qshift = 15 + shift; /* Q2.46 -> Q2.31 */ + int32_t rnd = 1 << (qshift - 1); /* Half LSB */ + int nch_x_taps = nch * taps; + + /* Initialize to half LSB for rounding */ + for (i = 0; i < nch; i++) + y[i] = rnd; + + if (n1 >= nch_x_taps) { + fir_part(y, &ri, ci, in_delay, coefs, nch_x_taps, nch); } else { - n2 = filter_length - n1; - /* Part 1, loop n1 times, fir_ri becomes -1 */ - fir_part(&y, n1, coefs, coefi, fir->fir_delay, &fir->fir_ri); - - /* Part 2, unwrap fir_ri, continue rest of filter */ - fir->fir_ri = fir->fir_delay_size - 1; - fir_part(&y, n2, coefs, coefi, fir->fir_delay, &fir->fir_ri); + n2 = nch_x_taps - n1; + fir_part(y, &ri, ci, in_delay, coefs, n1, nch); + ri = dsm1; + fir_part(y, &ri, ci, in_delay, coefs, n2, nch); } - /* Q2.46 -> Q2.31, saturate to Q1.31 */ - y = y >> (15 + shift); - return(int32_t) sat_int32(y); + for (i = 0; i < nch; i++) + out_delay[wi++] = sat_int32(y[i] >> qshift); } #else -static inline int32_t fir_filter( - struct src_state *fir, const int32_t coefs[], - int *coefi, int filter_length, int shift) +static void fir_filter(int ri0, int *ci, int wi0, int32_t in_delay[], + int32_t out_delay[], const int32_t coefs[], int dsm1, int taps, + int shift, int nch) { - int64_t y = 0; - int n1; int n2; - - n1 = fir->fir_ri + 1; - if (n1 > filter_length) { - /* No need to un-wrap fir read index, make sure fir_fi - * is ge 0 after FIR computation. - */ - fir_part(&y, filter_length, coefs, coefi, fir->fir_delay, - &fir->fir_ri); + int i; + int64_t y[PLATFORM_MAX_CHANNELS]; + int ri = ri0; + int wi = wi0; + int n1 = ri0 + 1; /* Convert to number of sequential frames */ + int qshift = 23 + shift; /* Q2.54 -> Q2.31 */ + int32_t rnd = 1 << (qshift - 1); /* Half LSB */ + int nch_x_taps = nch * taps; + + /* Initialize to half LSB for rounding */ + for (i = 0; i < nch; i++) + y[i] = rnd; + + if (n1 >= nch_x_taps) { + fir_part(y, &ri, ci, in_delay, coefs, nch_x_taps, nch); } else { - n2 = filter_length - n1; - /* Part 1, loop n1 times, fir_ri becomes -1 */ - fir_part(&y, n1, coefs, coefi, fir->fir_delay, &fir->fir_ri); - - /* Part 2, unwrap fir_ri, continue rest of filter */ - fir->fir_ri = fir->fir_delay_size - 1; - fir_part(&y, n2, coefs, coefi, fir->fir_delay, &fir->fir_ri); + n2 = nch_x_taps - n1; + fir_part(y, &ri, ci, in_delay, coefs, n1, nch); + ri = dsm1; + fir_part(y, &ri, ci, in_delay, coefs, n2, nch); } - /* Q9.47 -> Q9.24, saturate to Q8.24 */ - y = y >> (23 + shift); - return(int32_t) sat_int32(y); + for (i = 0; i < nch; i++) + out_delay[wi++] = sat_int32(y[i] >> qshift); + } + #endif void src_polyphase_stage_cir(struct src_stage_prm * s) @@ -447,29 +492,42 @@ void src_polyphase_stage_cir(struct src_stage_prm * s) int n; int m; int f; - int c; - int r; + int ci; + int ri; int n_wrap_fir; int n_wrap_buf; int n_wrap_min; int n_min; - int32_t z; + int wi; + const void *coef = cfg->coefs; + int32_t *in_delay = fir->fir_delay; + int32_t *out_delay = fir->out_delay; + int dsm1 = fir->fir_delay_size - 1; + int shift = cfg->shift; + int nch = s->nch; + int rewind = -nch * (cfg->blk_in + + (cfg->num_of_subfilters - 1) * cfg->idm) + nch - 1; + int nch_x_idm = cfg->idm * nch; + int nch_x_odm = cfg->odm * nch; + size_t sz = sizeof(int32_t); + int blk_in_bytes = nch * cfg->blk_in * sz; + int blk_out_bytes = nch * cfg->num_of_subfilters * sz; + for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * cfg->blk_in; + m = blk_in_bytes; while (m > 0) { - n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) - * s->x_inc; + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * sz; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { fir->fir_delay[fir->fir_wi++] = *s->x_rptr; - s->x_rptr += s->x_inc; - n_min -= s->x_inc; - m -= s->x_inc; + s->x_rptr++; + n_min -= sz; + m -= sz; } /* Check for wrap */ src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); @@ -478,41 +536,38 @@ void src_polyphase_stage_cir(struct src_stage_prm * s) } /* Filter */ - c = 0; - r = fir->fir_wi - cfg->blk_in - - (cfg->num_of_subfilters - 1) * cfg->idm; - if (r < 0) - r += fir->fir_delay_size; + ci = 0; /* Reset to 1st coefficient */ + ri = fir->fir_wi + rewind; /* Newest data for last subfilter */ + if (ri < 0) + ri += fir->fir_delay_size; - fir->out_wi = fir->out_ri; + wi = fir->out_ri; for (f = 0; f < cfg->num_of_subfilters; f++) { - fir->fir_ri = r; - z = fir_filter(fir, cfg->coefs, &c, - cfg->subfilter_length, cfg->shift); - r += cfg->idm; - if (r >= fir->fir_delay_size) - r -= fir->fir_delay_size; - - fir->out_delay[fir->out_wi] = z; - fir->out_wi += cfg->odm; - if (fir->out_wi >= fir->out_delay_size) - fir->out_wi -= fir->out_delay_size; + fir_filter(ri, &ci, wi, in_delay, out_delay, coef, + dsm1, cfg->subfilter_length, shift, nch); + + wi += nch_x_odm; + if (wi >= fir->out_delay_size) + wi -= fir->out_delay_size; + + ri += nch_x_idm; /* Next sub-filter start */ + if (ri >= fir->fir_delay_size) + ri -= fir->fir_delay_size; } /* Output */ - m = s->y_inc * cfg->num_of_subfilters; + m = blk_out_bytes; while (m > 0) { - n_wrap_fir = (fir->out_delay_size - fir->out_ri) - * s->y_inc; + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * sz; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { *s->y_wptr = fir->out_delay[fir->out_ri++]; - s->y_wptr += s->y_inc; - n_min -= s->y_inc; - m -= s->y_inc; + s->y_wptr++; + n_min -= sz; + m -= sz; } /* Check wrap */ src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); @@ -522,38 +577,48 @@ void src_polyphase_stage_cir(struct src_stage_prm * s) } } -void src_polyphase_stage_cir_s24(struct src_stage_prm * s) +void src_polyphase_stage_cir_s24(struct src_stage_prm *s) { struct src_state *fir = s->state; struct src_stage *cfg = s->stage; int n; int m; int f; - int c; - int r; + int ci; + int ri; int n_wrap_fir; int n_wrap_buf; int n_wrap_min; int n_min; - int32_t z; - int32_t se; + int wi; + const void *coef = cfg->coefs; + int32_t *in_delay = fir->fir_delay; + int32_t *out_delay = fir->out_delay; + int dsm1 = fir->fir_delay_size - 1; + int shift = cfg->shift; + int nch = s->nch; + int rewind = -nch * (cfg->blk_in + + (cfg->num_of_subfilters - 1) * cfg->idm) + nch - 1; + int nch_x_idm = cfg->idm * nch; + int nch_x_odm = cfg->odm * nch; + size_t sz = sizeof(int32_t); + int blk_in_bytes = nch * cfg->blk_in * sz; + int blk_out_bytes = nch * cfg->num_of_subfilters * sz; for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * cfg->blk_in; + m = blk_in_bytes; while (m > 0) { - n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) - * s->x_inc; + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * sz; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { - se = *s->x_rptr << 8; - fir->fir_delay[fir->fir_wi++] = se >> 8; - s->x_rptr += s->x_inc; - n_min -= s->x_inc; - m -= s->x_inc; + fir->fir_delay[fir->fir_wi++] = *s->x_rptr << 8; + s->x_rptr++; + n_min -= sz; + m -= sz; } /* Check for wrap */ src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); @@ -562,41 +627,38 @@ void src_polyphase_stage_cir_s24(struct src_stage_prm * s) } /* Filter */ - c = 0; - r = fir->fir_wi - cfg->blk_in - - (cfg->num_of_subfilters - 1) * cfg->idm; - if (r < 0) - r += fir->fir_delay_size; + ci = 0; /* Reset to 1st coefficient */ + ri = fir->fir_wi + rewind; /* Newest data for last subfilter */ + if (ri < 0) + ri += fir->fir_delay_size; - fir->out_wi = fir->out_ri; + wi = fir->out_ri; for (f = 0; f < cfg->num_of_subfilters; f++) { - fir->fir_ri = r; - z = fir_filter(fir, cfg->coefs, &c, - cfg->subfilter_length, cfg->shift); - r += cfg->idm; - if (r >= fir->fir_delay_size) - r -= fir->fir_delay_size; - - fir->out_delay[fir->out_wi] = z; - fir->out_wi += cfg->odm; - if (fir->out_wi >= fir->out_delay_size) - fir->out_wi -= fir->out_delay_size; + fir_filter(ri, &ci, wi, in_delay, out_delay, coef, + dsm1, cfg->subfilter_length, shift, nch); + + wi += nch_x_odm; + if (wi >= fir->out_delay_size) + wi -= fir->out_delay_size; + + ri += nch_x_idm; /* Next sub-filter start */ + if (ri >= fir->fir_delay_size) + ri -= fir->fir_delay_size; } /* Output */ - m = s->y_inc * cfg->num_of_subfilters; + m = blk_out_bytes; while (m > 0) { - n_wrap_fir = (fir->out_delay_size - fir->out_ri) - * s->y_inc; + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * sz; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { - *s->y_wptr = fir->out_delay[fir->out_ri++]; - s->y_wptr += s->y_inc; - n_min -= s->y_inc; - m -= s->y_inc; + *s->y_wptr = fir->out_delay[fir->out_ri++] >> 8; + s->y_wptr++; + n_min -= sz; + m -= sz; } /* Check wrap */ src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); @@ -604,47 +666,5 @@ void src_polyphase_stage_cir_s24(struct src_stage_prm * s) fir->out_ri = 0; } } -} - -#ifdef MODULE_TEST - -void src_print_info(struct polyphase_src * src) -{ - - int n1; - int n2; - - n1 = src->stage1->filter_length; - n2 = src->stage2->filter_length; - printf("SRC stages %d\n", src->number_of_stages); - printf("SRC input blk %d\n", src->blk_in); - printf("SRC output blk %d\n", src->blk_out); - printf("SRC stage1 %d times\n", src->stage1_times); - printf("SRC stage2 %d times\n", src->stage2_times); - - printf("SRC1 filter length %d\n", n1); - printf("SRC1 subfilter length %d\n", src->stage1->subfilter_length); - printf("SRC1 number of subfilters %d\n", - src->stage1->num_of_subfilters); - printf("SRC1 idm %d\n", src->stage1->idm); - printf("SRC1 odm %d\n", src->stage1->odm); - printf("SRC1 input blk %d\n", src->stage1->blk_in); - printf("SRC1 output blk %d\n", src->stage1->blk_out); - printf("SRC1 halfband %d\n", src->stage1->halfband); - printf("SRC1 FIR delay %d\n", src->state1.fir_delay_size); - printf("SRC1 out delay %d\n", src->state1.out_delay_size); - - printf("SRC2 filter length %d\n", n2); - printf("SRC2 subfilter length %d\n", src->stage2->subfilter_length); - printf("SRC2 number of subfilters %d\n", - src->stage2->num_of_subfilters); - printf("SRC2 idm %d\n", src->stage2->idm); - printf("SRC2 odm %d\n", src->stage2->odm); - printf("SRC2 input blk %d\n", src->stage2->blk_in); - printf("SRC2 output blk %d\n", src->stage2->blk_out); - printf("SRC2 halfband %d\n", src->stage2->halfband); - printf("SRC2 FIR delay %d\n", src->state2.fir_delay_size); - printf("SRC2 out delay %d\n", src->state2.out_delay_size); } -#endif diff --git a/src/audio/src_core.h b/src/audio/src_core.h index 3859e6f..3ea6028 100644 --- a/src/audio/src_core.h +++ b/src/audio/src_core.h @@ -41,7 +41,7 @@ struct src_param { int out_s1; int out_s2; int sbuf_length; - int single_src; + int src_multich; int total; int blk_in; int blk_out; @@ -51,6 +51,7 @@ struct src_param { int stage2_times_max; int idx_in; int idx_out; + int nch; }; struct src_stage { @@ -70,20 +71,13 @@ struct src_state { int fir_delay_size; int out_delay_size; int fir_wi; - int fir_ri; - int out_wi; int out_ri; int32_t *fir_delay; int32_t *out_delay; }; struct polyphase_src { - int mute; int number_of_stages; - int blk_in; - int blk_out; - int stage1_times; - int stage2_times; struct src_stage *stage1; struct src_stage *stage2; struct src_state state1; @@ -91,15 +85,14 @@ struct polyphase_src { }; struct src_stage_prm { + int nch; int times; int32_t *x_rptr; int32_t *x_end_addr; size_t x_size; - int x_inc; int32_t *y_wptr; int32_t *y_end_addr; size_t y_size; - int y_inc; struct src_state *state; struct src_stage *stage; }; @@ -116,31 +109,6 @@ static inline void src_circ_dec_wrap(int32_t **ptr, int32_t *addr, size_t size) *ptr = (int32_t *) ((size_t) * ptr + size); } -static inline void src_polyphase_mute(struct polyphase_src *src) -{ - src->mute = 1; -} - -static inline void src_polyphase_unmute(struct polyphase_src *src) -{ - src->mute = 0; -} - -static inline int src_polyphase_getmute(struct polyphase_src *src) -{ - return src->mute; -} - -static inline int src_polyphase_get_blk_in(struct polyphase_src *src) -{ - return src->blk_in; -} - -static inline int src_polyphase_get_blk_out(struct polyphase_src *src) -{ - return src->blk_out; -} - void src_polyphase_reset(struct polyphase_src *src); int src_polyphase_init(struct polyphase_src *src, struct src_param *p, @@ -162,8 +130,4 @@ int32_t src_output_rates(void); int src_ceil_divide(int a, int b); -#ifdef MODULE_TEST -void src_print_info(struct polyphase_src *src); -#endif - #endif -- 2.11.0

1 0

[Sound-open-firmware] [PATCH 2/2] Move DMA tracing intialization calling.
by yan.wang＠linux.intel.com 20 Oct '17

20 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> Move it from ipc handler into platform_init(). Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/ipc/intel-ipc.c | 7 ------- src/platform/baytrail/platform.c | 4 ++++ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/ipc/intel-ipc.c b/src/ipc/intel-ipc.c index f6d88ef..902e5a6 100644 --- a/src/ipc/intel-ipc.c +++ b/src/ipc/intel-ipc.c @@ -583,13 +583,6 @@ static int ipc_dma_trace_config(uint32_t header) trace_ipc_error("DA1"); - /* Initialize DMA for Trace*/ - err = dma_trace_init(&_ipc->dmat); - if (err < 0) { - trace_ipc_error("eIP"); - goto error; - } - /* use DMA to read in compressed page table ringbuffer from host */ err = get_page_descriptors(iipc, &params->buffer); if (err < 0) { diff --git a/src/platform/baytrail/platform.c b/src/platform/baytrail/platform.c index b701196..61596bb 100644 --- a/src/platform/baytrail/platform.c +++ b/src/platform/baytrail/platform.c @@ -46,6 +46,7 @@ #include <reef/clock.h> #include <reef/ipc.h> #include <reef/trace.h> +#include <reef/dma-trace.h> #include <reef/audio/component.h> #include <config.h> #include <string.h> @@ -296,6 +297,9 @@ int platform_init(struct reef *reef) trace_point(TRACE_BOOT_PLATFORM_IPC); ipc_init(reef); + /* Initialize DMA for Trace*/ + dma_trace_init(&reef->ipc->dmat); + /* init DMACs */ trace_point(TRACE_BOOT_PLATFORM_DMA); dmac0 = dma_get(DMA_ID_DMAC0); -- 2.7.4

1 0

[Sound-open-firmware] [PATCH 1/2] Move DMA tracing implementaion from src/audio to src/lib.
by yan.wang＠linux.intel.com 20 Oct '17

20 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Move source and header file. 2. Change src/lib/Makefile.am and src/audio/Makefile.am. 3. Chnage header file path. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/audio/Makefile.am | 1 - src/include/reef/{audio => }/dma-trace.h | 0 src/include/reef/ipc.h | 2 +- src/lib/Makefile.am | 1 + src/{audio => lib}/dma-trace.c | 3 +-- src/lib/trace.c | 2 +- 6 files changed, 4 insertions(+), 5 deletions(-) rename src/include/reef/{audio => }/dma-trace.h (100%) rename src/{audio => lib}/dma-trace.c (98%) diff --git a/src/audio/Makefile.am b/src/audio/Makefile.am index 7ffe01f..285422e 100644 --- a/src/audio/Makefile.am +++ b/src/audio/Makefile.am @@ -17,7 +17,6 @@ libaudio_a_SOURCES = \ pipeline.c \ pipeline_static.c \ component.c \ - dma-trace.c \ buffer.c libaudio_a_CFLAGS = \ diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/dma-trace.h similarity index 100% rename from src/include/reef/audio/dma-trace.h rename to src/include/reef/dma-trace.h diff --git a/src/include/reef/ipc.h b/src/include/reef/ipc.h index a552626..472aca8 100644 --- a/src/include/reef/ipc.h +++ b/src/include/reef/ipc.h @@ -40,7 +40,7 @@ #include <uapi/ipc.h> #include <reef/audio/pipeline.h> #include <reef/audio/component.h> -#include <reef/audio/dma-trace.h> +#include <reef/dma-trace.h> struct reef; struct dai_config; diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am index acdbd85..b4521df 100644 --- a/src/lib/Makefile.am +++ b/src/lib/Makefile.am @@ -6,6 +6,7 @@ libcore_a_SOURCES = \ work.c \ notifier.c \ trace.c \ + dma-trace.c \ schedule.c libcore_a_CFLAGS = \ diff --git a/src/audio/dma-trace.c b/src/lib/dma-trace.c similarity index 98% rename from src/audio/dma-trace.c rename to src/lib/dma-trace.c index b0267fa..5885037 100644 --- a/src/audio/dma-trace.c +++ b/src/lib/dma-trace.c @@ -29,7 +29,7 @@ */ #include <reef/trace.h> -#include <reef/audio/dma-trace.h> +#include <reef/dma-trace.h> #include <reef/ipc.h> #include <reef/reef.h> #include <reef/alloc.h> @@ -172,7 +172,6 @@ int dma_trace_enable(struct dma_trace_data *d) return -ENODEV; } - /* TODO: fix crash when enabled */ d->enabled = 1; work_schedule_default(&d->dmat_work, DMA_TRACE_US); return 0; diff --git a/src/lib/trace.c b/src/lib/trace.c index c0abf7c..eec93b5 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -34,7 +34,7 @@ #include <arch/cache.h> #include <platform/timer.h> #include <reef/lock.h> -#include <reef/audio/dma-trace.h> +#include <reef/dma-trace.h> #include <stdint.h> struct trace { -- 2.7.4

1 0

[Sound-open-firmware] [PATCH v5] volume: fix for DC offset and handling of sign extension for 24-bit samples
by Ranjani Sridharan 20 Oct '17

20 Oct '17

This patch fixes the DC offsets introduced in the volume component due to shifts and handles sign extension for 24-bit input samples Signed-off-by: Ranjani Sridharan <ranjani.sridharan(a)linux.intel.com> --- src/audio/tone.c | 19 +++++++---- src/audio/volume.c | 71 +++++++++++++++++++++++++++-------------- src/include/reef/audio/format.h | 50 ++++++++++++++++++++++------- src/math/trig.c | 3 +- 4 files changed, 99 insertions(+), 44 deletions(-) diff --git a/src/audio/tone.c b/src/audio/tone.c index 0baf247..1fde455 100644 --- a/src/audio/tone.c +++ b/src/audio/tone.c @@ -149,7 +149,9 @@ static int32_t tonegen(struct tone_state *sg) /* sg->w is angle in Q4.28 radians format, sin() returns Q1.31 */ /* sg->a is amplitude as Q1.31 */ - sine = q_mults_32x32(sin_fixed(sg->w), sg->a, 31, 31, 31); + sine = + q_mults_32x32(sin_fixed(sg->w), sg->a, + Q_SHIFT_BITS_64(31, 31, 31)); /* Next point */ w = (int64_t) sg->w + sg->w_step; @@ -208,15 +210,16 @@ static void tonegen_control(struct tone_state *sg) && (sg->repeat_count + 1 < sg->repeats)) { sg->block_count = 0; if (sg->ampl_coef > 0) { - sg->a_target = sat_int32(q_multsr_32x32( - sg->a_target, - sg->ampl_coef, 31, 30, 31)); + sg->a_target = + sat_int32(q_multsr_32x32(sg->a_target, + sg->ampl_coef, Q_SHIFT_BITS_64(31, 30, 31))); sg->a = (sg->ramp_step > sg->a_target) ? sg->a_target : sg->ramp_step; } if (sg->freq_coef > 0) { /* f is Q16.16, freq_coef is Q2.30 */ - p = q_multsr_32x32(sg->f, sg->freq_coef, 16, 30, 16); + p = q_multsr_32x32(sg->f, sg->freq_coef, + Q_SHIFT_BITS_64(16, 30, 16)); tonegen_update_f(sg, (int32_t) p); /* No saturation */ } sg->repeat_count++; @@ -297,7 +300,8 @@ static void tonegen_update_f(struct tone_state *sg, int32_t f) f_max = Q_SHIFT_LEFT((int64_t) sg->fs, 0, 16 - 1); f_max = (f_max > INT32_MAXVALUE) ? INT32_MAXVALUE : f_max; sg->f = (f > f_max) ? f_max : f; - w_tmp = q_multsr_32x32(sg->f, sg->c, 16, 31, 28); /* Q16 x Q31 -> Q28 */ + /* Q16 x Q31 -> Q28 */ + w_tmp = q_multsr_32x32(sg->f, sg->c, Q_SHIFT_BITS_64(16, 31, 28)); w_tmp = (w_tmp > PI_Q4_28) ? PI_Q4_28 : w_tmp; /* Limit to pi Q4.28 */ sg->w_step = (int32_t) w_tmp; @@ -362,7 +366,8 @@ static int tonegen_init(struct tone_state *sg, int32_t fs, int32_t f, int32_t a) tonegen_update_f(sg, f); /* 125us as Q1.31 is 268435, calculate fs * 125e-6 in Q31.0 */ - sg->samples_in_block = (int32_t) q_multsr_32x32(fs, 268435, 0, 31, 0); + sg->samples_in_block = + (int32_t) q_multsr_32x32(fs, 268435, Q_SHIFT_BITS_64(0, 31, 0)); return 0; } diff --git a/src/audio/volume.c b/src/audio/volume.c index 472aab9..137be3c 100644 --- a/src/audio/volume.c +++ b/src/audio/volume.c @@ -99,8 +99,8 @@ static void vol_s16_to_s32(struct comp_dev *dev, struct comp_buffer *sink, int32_t *dest = (int32_t *) sink->w_ptr; int32_t i; - /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.15 --> Q1.31 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { dest[i] = (int32_t)src[i] * cd->volume[0]; dest[i + 1] = (int32_t)src[i + 1] * cd->volume[1]; @@ -117,9 +117,12 @@ static void vol_s32_to_s16(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.31 --> Q1.15 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = (((int32_t)src[i] >> 16) * cd->volume[0]) >> 16; - dest[i + 1] = (((int32_t)src[i + 1] >> 16) * cd->volume[1]) >> 16; + dest[i] = (int16_t)q_multsr_sat_32x32( + src[i], cd->volume[0], Q_SHIFT_BITS_64(31, 16, 15)); + dest[i + 1] = (int16_t)q_multsr_sat_32x32( + src[i + 1], cd->volume[1], Q_SHIFT_BITS_64(31, 16, 15)); } } @@ -133,9 +136,12 @@ static void vol_s32_to_s32(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.31 --> Q1.31 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = ((int64_t)src[i] * cd->volume[0]) >> 16; - dest[i + 1] = ((int64_t)src[i + 1] * cd->volume[1]) >> 16; + dest[i] = q_multsr_sat_32x32( + src[i], cd->volume[0], Q_SHIFT_BITS_64(31, 16, 31)); + dest[i + 1] = q_multsr_sat_32x32( + src[i + 1], cd->volume[1], Q_SHIFT_BITS_64(31, 16, 31)); } } @@ -149,9 +155,12 @@ static void vol_s16_to_s16(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.15 --> Q1.15 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = ((int32_t)src[i] * cd->volume[0]) >> 16; - dest[i + 1] = ((int32_t)src[i + 1] * cd->volume[1]) >> 16; + dest[i] = q_multsr_sat_16x16( + src[i], cd->volume[0], Q_SHIFT_BITS_32(15, 16, 15)); + dest[i + 1] = q_multsr_sat_16x16( + src[i + 1], cd->volume[1], Q_SHIFT_BITS_32(15, 16, 15)); } } @@ -165,9 +174,12 @@ static void vol_s16_to_s24(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.15 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = ((int32_t)src[i] * cd->volume[0]) >> 8; - dest[i + 1] = ((int32_t)src[i + 1] * cd->volume[1]) >> 8; + dest[i] = q_multsr_sat_32x32( + src[i], cd->volume[0], Q_SHIFT_BITS_64(15, 16, 23)); + dest[i + 1] = q_multsr_sat_32x32( + src[i], cd->volume[0], Q_SHIFT_BITS_64(15, 16, 23)); } } @@ -181,11 +193,14 @@ static void vol_s24_to_s16(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.23 --> Q1.15 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = (int16_t)((((int32_t)src[i] >> 8) * - cd->volume[0]) >> 16); - dest[i + 1] = (int16_t)((((int32_t)src[i + 1] >> 8) * - cd->volume[1]) >> 16); + dest[i] = (int16_t)q_multsr_sat_32x32( + sign_extend_s24(src[i]), cd->volume[0], + Q_SHIFT_BITS_64(23, 16, 15)); + dest[i + 1] = (int16_t)q_multsr_sat_32x32( + sign_extend_s24(src[i + 1]), cd->volume[1], + Q_SHIFT_BITS_64(23, 16, 15)); } } @@ -199,9 +214,12 @@ static void vol_s32_to_s24(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.31 --> Q1.23 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = ((int64_t)src[i] * cd->volume[0]) >> 24; - dest[i + 1] = ((int64_t)src[i + 1] * cd->volume[1]) >> 24; + dest[i] = q_multsr_sat_32x32( + src[i], cd->volume[0], Q_SHIFT_BITS_64(31, 16, 23)); + dest[i + 1] = q_multsr_sat_32x32( + src[i + 1], cd->volume[1], Q_SHIFT_BITS_64(31, 16, 23)); } } @@ -215,11 +233,14 @@ static void vol_s24_to_s32(struct comp_dev *dev, struct comp_buffer *sink, int32_t i; /* buffer sizes are always divisible by period frames */ + /* Samples are Q1.23 --> Q1.31 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = (int32_t)(((int64_t)src[i] * - cd->volume[0]) >> 8); - dest[i + 1] = (int32_t)(((int64_t)src[i + 1] * - cd->volume[1]) >> 8); + dest[i] = q_multsr_sat_32x32( + sign_extend_s24(src[i]), cd->volume[0], + Q_SHIFT_BITS_64(23, 16, 31)); + dest[i + 1] = q_multsr_sat_32x32( + sign_extend_s24(src[i + 1]), cd->volume[1], + Q_SHIFT_BITS_64(23, 16, 31)); } } @@ -234,12 +255,14 @@ static void vol_s24_to_s24(struct comp_dev *dev, struct comp_buffer *sink, int32_t *dest = (int32_t*) sink->w_ptr; /* buffer sizes are always divisible by period frames */ - /* Samples are Q1.23 and volume is Q1.16 */ + /* Samples are Q1.23 --> Q1.23 and volume is Q1.16 */ for (i = 0; i < frames * 2; i += 2) { - dest[i] = (int32_t)(Q_MULTS_32X32( - (int64_t)src[i], cd->volume[0], 23, 16, 23)); - dest[i + 1] = (int32_t)(Q_MULTS_32X32( - (int64_t)src[i+1], cd->volume[1], 23, 16, 23)); + dest[i] = q_multsr_sat_32x32( + sign_extend_s24(src[i]), cd->volume[0], + Q_SHIFT_BITS_64(23, 16, 23)); + dest[i + 1] = q_multsr_sat_32x32( + sign_extend_s24(src[i + 1]), cd->volume[1], + Q_SHIFT_BITS_64(23, 16, 23)); } } diff --git a/src/include/reef/audio/format.h b/src/include/reef/audio/format.h index 945a968..b9263f1 100644 --- a/src/include/reef/audio/format.h +++ b/src/include/reef/audio/format.h @@ -56,6 +56,18 @@ #define MINUS_80DB_Q1_31 214748 /* 10^(-80/20) */ #define MINUS_90DB_Q1_31 67909 /* 10^(-90/20) */ +/* Compute the number of shifts + * This will result in a compiler overflow error if shift bits are out of + * range as INT64_MAX/MIN is greater than 32 bit Q shift parameter + */ +#define Q_SHIFT_BITS_64(qx, qy, qz) \ + ((qx + qy - qz) <= 63 ? (((qx + qy - qz) >= 0) ? \ + (qx + qy - qz) : INT64_MIN) : INT64_MAX) + +#define Q_SHIFT_BITS_32(qx, qy, qz) \ + ((qx + qy - qz) <= 31 ? (((qx + qy - qz) >= 0) ? \ + (qx + qy - qz) : INT32_MIN) : INT32_MAX) + /* Convert a float number to fractional Qnx.ny format. Note that there is no * check for nx+ny number of bits to fit the word length of int. */ @@ -82,28 +94,24 @@ #define SATP_INT32(x) (((x) > INT32_MAXVALUE) ? INT32_MAXVALUE : (x)) #define SATM_INT32(x) (((x) < INT32_MINVALUE) ? INT32_MINVALUE : (x)) -static inline int64_t q_mults_32x32(int32_t x, int32_t y, - const int qx, const int qy, const int qp) +static inline int64_t q_mults_32x32(int32_t x, int32_t y, const int shift_bits) { - return ((int64_t)x * y) >> (qx+qy-qp); + return ((int64_t)x * y) >> shift_bits; } -static inline int64_t q_multsr_32x32(int32_t x, int32_t y, - const int qx, const int qy, const int qp) +static inline int64_t q_multsr_32x32(int32_t x, int32_t y, const int shift_bits) { - return ((((int64_t)x * y) >> (qx+qy-qp-1)) + 1) >> 1; + return ((((int64_t)x * y) >> (shift_bits - 1)) + 1) >> 1; } -static inline int32_t q_mults_16x16(int16_t x, int16_t y, - const int qx, const int qy, const int qp) +static inline int32_t q_mults_16x16(int16_t x, int32_t y, const int shift_bits) { - return ((int32_t)x * y) >> (qx+qy-qp); + return ((int32_t)x * y) >> shift_bits; } -static inline int16_t q_multsr_16x16(int16_t x, int16_t y, - const int qx, const int qy, const int qp) +static inline int16_t q_multsr_16x16(int16_t x, int32_t y, const int shift_bits) { - return ((((int32_t)x * y) >> (qx+qy-qp-1)) + 1) >> 1; + return ((((int32_t)x * y) >> (shift_bits - 1)) + 1) >> 1; } /* Saturation inline functions */ @@ -147,4 +155,22 @@ static inline int16_t sat_int16(int32_t x) return (int16_t)x; } +/* Fractional multiplication with shift and saturation */ +static inline int32_t q_multsr_sat_32x32(int32_t x, int32_t y, + const int shift_bits) +{ + return sat_int32(((((int64_t)x * y) >> (shift_bits - 1)) + 1) >> 1); +} + +static inline int16_t q_multsr_sat_16x16(int16_t x, int32_t y, + const int shift_bits) +{ + return sat_int16(((((int32_t)x * y) >> (shift_bits - 1)) + 1) >> 1); +} + +static inline int32_t sign_extend_s24(int32_t x) +{ + return (x << 8) >> 8; +} + #endif diff --git a/src/math/trig.c b/src/math/trig.c index 79eb480..70593e4 100644 --- a/src/math/trig.c +++ b/src/math/trig.c @@ -594,6 +594,7 @@ int32_t sin_fixed(int32_t w) { delta = s1 - s0; /* Q1.31 */ //sine = (int64_t) frac*delta; /* Q1.31 x Q1.31 -> Q2.62 */ //sine = (sine >> 31) + s0; /* Q2.31 */ - sine = s0 + q_mults_32x32(frac, delta, 31, 31, 31); /* All Q1.31 */ + /* All Q1.31 */ + sine = s0 + q_mults_32x32(frac, delta, Q_SHIFT_BITS_64(31, 31, 31)); return (int32_t) sine; } -- 2.11.0

2 1

[Sound-open-firmware] [PATCH 1/2] comp: remove unused list in struct component.
by Liam Girdwood 20 Oct '17

20 Oct '17

Not used so remove. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/include/reef/audio/component.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/include/reef/audio/component.h b/src/include/reef/audio/component.h index db5f35b..8f5a508 100644 --- a/src/include/reef/audio/component.h +++ b/src/include/reef/audio/component.h @@ -186,7 +186,6 @@ struct comp_dev { struct comp_driver *drv; /* lists */ - struct list_item list; /* list in components */ struct list_item bsource_list; /* list of source buffers */ struct list_item bsink_list; /* list of sink buffers */ -- 2.11.0

1 0

[Sound-open-firmware] [PATCH] rmbox: use 64bit trace data
by Liam Girdwood 19 Oct '17

19 Oct '17

Update trace to align with FW and use 64bit data size. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- rmbox/rmbox.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index 9313f4b..b872694 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -129,16 +129,28 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, double /* 64-bit timestamp */ us = to_usecs(val, clk); - printf("[%6.6f]\tdelta [%6.6f]\t", + /* empty data ? */ + if (val == 0) { + *timestamp = 0; + return; + } + + /* detect wrap around */ + if (fdelta < 1000.0 * 1000.0 * 1000.0) + printf("0x%lx [%6.6f]\tdelta [%6.6f]\t", addr, us / 1000000.0 , fdelta / 1000000.0); + else + printf("0x%lx [%6.6f]\tdelta [********]\t", addr, + us / 1000000.0); *timestamp = val; return; - } + } else if (*timestamp == 0) + return; /* check for printable values - otherwise it's a value */ if (!isprint((char)(val >> 16)) || !isprint((char)(val >> 8)) || !isprint((char)val)) { - printf("value 0x%8.8x\n", (uint32_t)val); + printf("value 0x%16.16lx\n", val); return; } @@ -237,9 +249,6 @@ trace: tmp[TRACE_BLOCK_SIZE - i - 1] = c; } - if (val == 0) - break; - show_trace(val, addr, &timestamp, clk); if (out_fd) { -- 1.9.1

1 0

[Sound-open-firmware] [PATCH] SRC: Use a multi-channel FIR core to optimize speed plus other cleanup
by Seppo Ingalsuo 19 Oct '17

19 Oct '17

This patch changes the sample rate conversion processing to use a single multi-channel filter instead of per channel called mono filter instances. The filter output is now rounded with 1/2 LSB add. The polyphase filter input input block sizes are multiplied in SRC initialization to reach near to or exacly the period length to reduce polyphase filter call overhead. The polyphase filter is now called via function pointer for more flexibility with audio data formats. Currently S32_LE and S24_4LE are supported. Code cleanup includes removal of redundant variables and some debug print code. Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo(a)linux.intel.com> --- src/audio/src.c | 198 ++++++++++------------- src/audio/src_core.c | 447 ++++++++++++++++++++++++++------------------------- src/audio/src_core.h | 42 +---- 3 files changed, 323 insertions(+), 364 deletions(-) diff --git a/src/audio/src.c b/src/audio/src.c index 4c4bc6e..854cb82 100644 --- a/src/audio/src.c +++ b/src/audio/src.c @@ -55,7 +55,7 @@ /* src component private data */ struct comp_data { - struct polyphase_src src[PLATFORM_MAX_CHANNELS]; + struct polyphase_src src; struct src_param param; int32_t *delay_lines; uint32_t sink_rate; @@ -63,16 +63,16 @@ struct comp_data { int32_t *sbuf_w_ptr; int32_t *sbuf_r_ptr; int sbuf_avail; - int sign_extend_s24; /* Set if need to copy sign bit to b24..b31 */ void (* src_func)(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *consumed, size_t *produced); + void (* polyphase_func)(struct src_stage_prm *s); }; /* Fallback function */ -static void fallback_s32(struct comp_dev *dev, struct comp_buffer *source, +static void src_fallback(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { *bytes_read = 0; @@ -84,101 +84,105 @@ static void src_2s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { - struct polyphase_src *s; struct src_stage_prm s1; struct src_stage_prm s2; - int j; + int s1_blk_in; + int s1_blk_out; + int s2_blk_in; + int s2_blk_out; struct comp_data *cd = comp_get_drvdata(dev); int32_t *dest = (int32_t *) sink->w_ptr; int32_t *src = (int32_t *) source->r_ptr; - int32_t *sbuf_addr = cd->delay_lines; int32_t *sbuf_end_addr = &cd->delay_lines[cd->param.sbuf_length]; int32_t sbuf_size = cd->param.sbuf_length * sizeof(int32_t); - const int nch = dev->params.channels; - const int s1_blk_in = cd->src[0].stage1->blk_in * nch; - const int s1_blk_out = cd->src[0].stage1->blk_out * nch; - const int s2_blk_in = cd->src[0].stage2->blk_in * nch; - const int s2_blk_out = cd->src[0].stage2->blk_out * nch; + int nch = dev->params.channels; int sbuf_free = cd->param.sbuf_length - cd->sbuf_avail; - int source_check = (source->avail >> 2) - s1_blk_in; /* for int32_t */ - int sink_check = (sink->free >> 2) - s2_blk_out; /* For int32_t */ int n_read = 0; int n_written = 0; int n1 = 0; int n2 = 0; + int avail = source->avail >> 2; /* For int32_t */ + int free = sink->free >> 2; /* For int32_t */ - s1.times = 1; s1.x_end_addr = source->end_addr; s1.x_size = source->size; - s1.x_inc = nch; s1.y_end_addr = sbuf_end_addr; s1.y_size = sbuf_size; - s1.y_inc = nch; + s1.state = &cd->src.state1; + s1.stage = cd->src.stage1; + s1.x_rptr = src; + s1.y_wptr = cd->sbuf_w_ptr; + s1.nch = nch; - s2.times = 1; s2.x_end_addr = sbuf_end_addr; s2.x_size = sbuf_size; - s2.x_inc = nch; s2.y_end_addr = sink->end_addr; s2.y_size = sink->size; - s2.y_inc = nch; + s2.state = &cd->src.state2; + s2.stage = cd->src.stage2; + s2.x_rptr = cd->sbuf_r_ptr; + s2.y_wptr = dest; + s2.nch = nch; + - /* 1st stage runs once a long multiplied length block. - * The stage buffer much be large enough to fit one s1 output block - * plus one s2 input block plus jitter in s2 consumption. + /* Test if 1st stage can be run with default block length to reach + * the period length or just under it. */ - while ((n1 < cd->param.stage1_times_max) - && (n_read <= source_check) - && (sbuf_free >= s1_blk_out)) { - for (j = 0; j < nch; j++) { - s = &cd->src[j]; /* Point to src[] for this channel */ - s1.x_rptr = src++; - s1.y_wptr = cd->sbuf_w_ptr++; - src_circ_inc_wrap(&src, source->end_addr, source->size); - src_circ_inc_wrap(&cd->sbuf_w_ptr, sbuf_end_addr, sbuf_size); - s1.state = &s->state1; - s1.stage = s->stage1; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s1); - else - src_polyphase_stage_cir(&s1); - - } + s1.times = cd->param.stage1_times; + s1_blk_in = s1.times * cd->src.stage1->blk_in * nch; + s1_blk_out = s1.times * cd->src.stage1->blk_out * nch; + if ((avail >= s1_blk_in) && (sbuf_free >= s1_blk_out)) { + cd->polyphase_func(&s1); + cd->sbuf_w_ptr = s1.y_wptr; + cd->sbuf_avail += s1_blk_out; n_read += s1_blk_in; + avail -= s1_blk_in; + sbuf_free -= s1_blk_out; + n1 = s1.times; + } + + /* Run one block at time the remaining data for 1st stage. */ + s1.times = 1; + s1_blk_in = cd->src.stage1->blk_in * nch; + s1_blk_out = cd->src.stage1->blk_out * nch; + while ((n1 < cd->param.stage1_times_max) && (avail >= s1_blk_in) + && (sbuf_free >= s1_blk_out)) { + cd->polyphase_func(&s1); + cd->sbuf_w_ptr = s1.y_wptr; cd->sbuf_avail += s1_blk_out; + n_read += s1_blk_in; + avail -= s1_blk_in; sbuf_free -= s1_blk_out; - src = s1.x_rptr - nch + 1; - cd->sbuf_w_ptr = s1.y_wptr - nch + 1; - src_circ_dec_wrap(&src, source->addr, source->size); - src_circ_dec_wrap(&cd->sbuf_w_ptr, sbuf_addr, sbuf_size); - n1++; + n1 += s1.times; + } + + /* Test if 2nd stage can be run with default block length. */ + s2.times = cd->param.stage2_times; + s2_blk_in = s2.times * cd->src.stage2->blk_in * nch; + s2_blk_out = s2.times * cd->src.stage2->blk_out * nch; + if ((cd->sbuf_avail >= s2_blk_in) && (free >= s2_blk_out)) { + cd->polyphase_func(&s2); + cd->sbuf_r_ptr = s2.x_rptr; + cd->sbuf_avail -= s2_blk_in; + free -= s2_blk_out; + n_written += s2_blk_out; + n2 = s2.times; } - /* 2nd stage runs as many min size blocks as buffers allow */ + + /* Run one block at time the remaining 2nd stage output */ + s2.times = 1; + s2_blk_in = cd->src.stage2->blk_in * nch; + s2_blk_out = cd->src.stage2->blk_out * nch; while ((n2 < cd->param.stage2_times_max) && (cd->sbuf_avail >= s2_blk_in) - && (n_written <= sink_check)) { - for (j = 0; j < nch; j++) { - s2.x_rptr = cd->sbuf_r_ptr++; - s2.y_wptr = dest++; - src_circ_inc_wrap(&cd->sbuf_r_ptr, sbuf_end_addr, sbuf_size); - src_circ_inc_wrap(&dest, sink->end_addr, sink->size); - s = &cd->src[j]; /* Point to src[] for this channel */ - s2.state = &s->state2; - s2.stage = s->stage2; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s2); - else - src_polyphase_stage_cir(&s2); - - } - cd->sbuf_r_ptr = s2.x_rptr - nch + 1; - dest = s2.y_wptr - nch + 1; - src_circ_dec_wrap(&cd->sbuf_r_ptr, sbuf_addr, sbuf_size); - src_circ_dec_wrap(&dest, sink->addr, sink->size); - n_written += s2_blk_out; + && (free >= s2_blk_out)) { + cd->polyphase_func(&s2); + cd->sbuf_r_ptr = s2.x_rptr; cd->sbuf_avail -= s2_blk_in; - n2++; + free -= s2_blk_out; + n_written += s2_blk_out; + n2 += s2.times; } *bytes_read = sizeof(int32_t) * n_read; *bytes_written = sizeof(int32_t) * n_written; @@ -189,42 +193,27 @@ static void src_1s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { - struct polyphase_src *s; struct src_stage_prm s1; - int j; struct comp_data *cd = comp_get_drvdata(dev); - int32_t *dest = (int32_t *) sink->w_ptr; - int32_t *src = (int32_t *) source->r_ptr; int nch = dev->params.channels; int n_read = 0; int n_written = 0; s1.times = cd->param.stage1_times; + s1.x_rptr = (int32_t *) source->r_ptr; s1.x_end_addr = source->end_addr; s1.x_size = source->size; - s1.x_inc = nch; + s1.y_wptr = (int32_t *) sink->w_ptr; s1.y_end_addr = sink->end_addr; s1.y_size = sink->size; - s1.y_inc = nch; - s1.x_rptr = src + nch - 1; - s1.y_wptr = dest + nch - 1; - - for (j = 0; j < nch; j++) { - s = &cd->src[j]; /* Point to src for this channel */ - s1.x_rptr = src++; - s1.y_wptr = dest++; - src_circ_inc_wrap(&src, source->end_addr, source->size); - src_circ_inc_wrap(&dest, sink->end_addr, sink->size); - s1.state = &s->state1; - s1.stage = s->stage1; - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s1); - else - src_polyphase_stage_cir(&s1); - - n_read += cd->param.blk_in; - n_written += cd->param.blk_out; - } + s1.state = &cd->src.state1; + s1.stage = cd->src.stage1; + s1.nch = dev->params.channels; + + cd->polyphase_func(&s1); + + n_read += nch * cd->param.blk_in; + n_written += nch * cd->param.blk_out; *bytes_read = n_read * sizeof(int32_t); *bytes_written = n_written * sizeof(int32_t); } @@ -271,7 +260,6 @@ static struct comp_dev *src_new(struct sof_ipc_comp *comp) struct sof_ipc_comp_src *src; struct sof_ipc_comp_src *ipc_src = (struct sof_ipc_comp_src *) comp; struct comp_data *cd; - int i; trace_src("new"); @@ -299,8 +287,8 @@ static struct comp_dev *src_new(struct sof_ipc_comp *comp) cd->delay_lines = NULL; cd->src_func = src_2s_s32_default; - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_reset(&cd->src[i]); + cd->polyphase_func = src_polyphase_stage_cir; + src_polyphase_reset(&cd->src); dev->state = COMP_STATE_READY; return dev; @@ -334,10 +322,8 @@ static int src_params(struct comp_dev *dev) uint32_t sink_rate; int32_t *buffer_start; int n = 0; - int i; int err; int frames_is_for_source; - int nch; int q; trace_src("par"); @@ -345,10 +331,10 @@ static int src_params(struct comp_dev *dev) /* SRC supports S24_4LE and S32_LE formats */ switch (config->frame_fmt) { case SOF_IPC_FRAME_S24_4LE: - cd->sign_extend_s24 = 1; + cd->polyphase_func = src_polyphase_stage_cir_s24; break; case SOF_IPC_FRAME_S32_LE: - cd->sign_extend_s24 = 0; + cd->polyphase_func = src_polyphase_stage_cir; break; default: trace_src_error("sr0"); @@ -407,11 +393,7 @@ static int src_params(struct comp_dev *dev) buffer_start = cd->delay_lines + cd->param.sbuf_length; /* Initize SRC for actual sample rate */ - nch = MIN(params->channels, PLATFORM_MAX_CHANNELS); - for (i = 0; i < nch; i++) { - n = src_polyphase_init(&cd->src[i], &cd->param, buffer_start); - buffer_start += cd->param.single_src; - } + n = src_polyphase_init(&cd->src, &cd->param, buffer_start); /* Reset stage buffer */ cd->sbuf_r_ptr = cd->delay_lines; @@ -434,7 +416,7 @@ static int src_params(struct comp_dev *dev) * muted if copy() is run. */ trace_src("SFa"); - cd->src_func = fallback_s32; + cd->src_func = src_fallback; return -EINVAL; break; } @@ -532,7 +514,6 @@ static int src_copy(struct comp_dev *dev) /* Run SRC function if buffers avail and free allow */ if (((int) source->avail >= need_source) && ((int) sink->free >= need_sink)) { - /* Run src */ cd->src_func(dev, source, sink, &consumed, &produced); /* Calc new free and available if data was processed. These @@ -561,14 +542,12 @@ static int src_preload(struct comp_dev *dev) static int src_reset(struct comp_dev *dev) { - int i; struct comp_data *cd = comp_get_drvdata(dev); trace_src("SRe"); cd->src_func = src_2s_s32_default; - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_reset(&cd->src[i]); + src_polyphase_reset(&cd->src); comp_set_state(dev, COMP_CMD_RESET); return 0; @@ -576,7 +555,8 @@ static int src_reset(struct comp_dev *dev) struct comp_driver comp_src = { .type = SOF_COMP_SRC, - .ops = { + .ops = + { .new = src_new, .free = src_free, .params = src_params, diff --git a/src/audio/src_core.c b/src/audio/src_core.c index 4ee2efd..0d8cc17 100644 --- a/src/audio/src_core.c +++ b/src/audio/src_core.c @@ -51,6 +51,10 @@ int sof_rates[SOF_RATES_LENGTH] = {8000, 11025, 12000, 16000, 18900, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000}; +/* The FIR maximum lenghts are per channel so need to multiply them */ +#define MAX_FIR_DELAY_SIZE_XNCH (PLATFORM_MAX_CHANNELS * MAX_FIR_DELAY_SIZE) +#define MAX_OUT_DELAY_SIZE_XNCH (PLATFORM_MAX_CHANNELS * MAX_OUT_DELAY_SIZE) + /* Calculate ceil() for integer division */ int src_ceil_divide(int a, int b) { @@ -131,6 +135,10 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, int num; int frames2; + if (nch > PLATFORM_MAX_CHANNELS) + return -EINVAL; + + a->nch = nch; a->idx_in = src_find_fs(src_in_fs, NUM_IN_FS, fs_in); a->idx_out = src_find_fs(src_out_fs, NUM_OUT_FS, fs_out); @@ -146,8 +154,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, stage1 = src_table1[a->idx_out][a->idx_in]; stage2 = src_table2[a->idx_out][a->idx_in]; - a->fir_s1 = src_fir_delay_length(stage1); - a->out_s1 = src_out_delay_length(stage1); + a->fir_s1 = nch * src_fir_delay_length(stage1); + a->out_s1 = nch * src_out_delay_length(stage1); /* Find out how many additional times the SRC can be executed while having block size less or equal to max_frames. @@ -191,8 +199,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, a->stage2_times_max = 0; a->sbuf_length = 0; } else { - a->fir_s2 = src_fir_delay_length(stage2); - a->out_s2 = src_out_delay_length(stage2); + a->fir_s2 = nch * src_fir_delay_length(stage2); + a->out_s2 = nch * src_out_delay_length(stage2); /* 2x is an empirically tested length. Since the sink buffer * capability to receive samples varies a shorter stage 2 output * block will create a peak in internal buffer usage. @@ -200,8 +208,8 @@ int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, a->sbuf_length = 2 * nch * stage1->blk_out * a->stage1_times_max; } - a->single_src = a->fir_s1 + a->fir_s2 + a->out_s1 + a->out_s2; - a->total = a->sbuf_length + nch * a->single_src; + a->src_multich = a->fir_s1 + a->fir_s2 + a->out_s1 + a->out_s2; + a->total = a->sbuf_length + a->src_multich; return 0; } @@ -212,8 +220,6 @@ static void src_state_reset(struct src_state *state) state->fir_delay_size = 0; state->out_delay_size = 0; state->fir_wi = 0; - state->fir_ri = 0; - state->out_wi = 0; state->out_ri = 0; } @@ -229,17 +235,8 @@ static int init_stages( src->number_of_stages = n; src->stage1 = stage1; src->stage2 = stage2; - src->blk_in = p->blk_in; - src->blk_out = p->blk_out; - if (n == 1) { - src->stage1_times = p->stage1_times; - src->stage2_times = 0; - if (stage1->blk_out == 0) - return -EINVAL; - } else { - src->stage1_times = p->stage1_times; - src->stage2_times = p->stage2_times; - } + if ((n == 1) && (stage1->blk_out == 0)) + return -EINVAL; /* Delay line sizes */ src->state1.fir_delay_size = p->fir_s1; @@ -262,10 +259,10 @@ static int init_stages( } /* Check the sizes are less than MAX */ - if ((src->state1.fir_delay_size > MAX_FIR_DELAY_SIZE) - || (src->state1.out_delay_size > MAX_OUT_DELAY_SIZE) - || (src->state2.fir_delay_size > MAX_FIR_DELAY_SIZE) - || (src->state2.out_delay_size > MAX_OUT_DELAY_SIZE)) { + if ((src->state1.fir_delay_size > MAX_FIR_DELAY_SIZE_XNCH) + || (src->state1.out_delay_size > MAX_OUT_DELAY_SIZE_XNCH) + || (src->state2.fir_delay_size > MAX_FIR_DELAY_SIZE_XNCH) + || (src->state2.out_delay_size > MAX_OUT_DELAY_SIZE_XNCH)) { src->state1.fir_delay = NULL; src->state1.out_delay = NULL; src->state2.fir_delay = NULL; @@ -279,12 +276,7 @@ static int init_stages( void src_polyphase_reset(struct polyphase_src *src) { - src->mute = 0; src->number_of_stages = 0; - src->blk_in = 0; - src->blk_out = 0; - src->stage1_times = 0; - src->stage2_times = 0; src->stage1 = NULL; src->stage2 = NULL; src_state_reset(&src->state1); @@ -300,8 +292,6 @@ int src_polyphase_init(struct polyphase_src *src, struct src_param *p, struct src_stage *stage2; if ((p->idx_in < 0) || (p->idx_out < 0)) { - src->blk_in = p->blk_in; - src->blk_out = p->blk_out; return -EINVAL; } @@ -335,141 +325,203 @@ int src_polyphase_init(struct polyphase_src *src, struct src_param *p, #if SRC_SHORT == 1 /* Calculate a FIR filter part that does not need circular modification */ -static inline void fir_part(int64_t *y, int ntaps, const int16_t c[], int *ic, - int32_t d[], int *id) + +static inline void fir_part(int64_t y[], int *id, int *ic, + const int32_t data[], const int16_t coef[], int nch_x_taps, int nch) { + int64_t tap0; + int64_t tap1; int n; int64_t a = 0; + int64_t b = 0; + int c = *ic; + int d = *id; + int d_end = d - nch_x_taps; /* Data is Q1.31, coef is Q1.15, product is Q2.46 */ - for (n = 0; n < (ntaps >> 1); n++) { - a += (int64_t) c[*ic] * d[*id] - + (int64_t) c[*ic + 1] * d[*id - 1]; - *ic += 2; - *id -= 2; + if (nch == 2) { + for (n = 0; n < (nch_x_taps >> 2); n++) { + tap0 = coef[c++]; + tap1 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + b += data[d--] * tap1; + a += data[d--] * tap1; + } + if (d > d_end) { + tap0 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + } + y[1] += b; + y[0] += a; + } else { + while (d > d_end) { + tap0 = coef[c++]; + for (n = nch - 1; n >= 0; n--) + y[n] += data[d--] * tap0; + } } - if (ntaps & 1) - a += (int64_t) c[(*ic)++] * d[(*id)--]; - - *y += a; + *ic = c; + *id = d; } + #else -/* Calculate a FIR filter part that does not need circular modification */ -static inline void fir_part(int64_t *y, int ntaps, const int32_t c[], int *ic, - int32_t d[], int *id) +static inline void fir_part(int64_t y[], int *id, int *ic, + const int32_t data[], const int32_t coef[], int nch_x_taps, int nch) { + int64_t tap0; + int64_t tap1; int n; int64_t a = 0; - - /* Data is Q8.24, coef is Q1.23, product is Q9.47 */ - for (n = 0; n < (ntaps >> 1); n++) { - a += (int64_t) c[*ic] * d[*id] - + (int64_t) c[*ic + 1] * d[*id - 1]; - *ic += 2; - *id -= 2; + int64_t b = 0; + int c = *ic; + int d = *id; + int d_end = d - nch_x_taps; + + /* Data is Q1.31, coef is Q1.23, product is Q2.54 */ + if (nch == 2) { + for (n = 0; n < (nch_x_taps >> 2); n++) { + tap0 = coef[c++]; + tap1 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + b += data[d--] * tap1; + a += data[d--] * tap1; + } + if (d > d_end) { + tap0 = coef[c++]; + b += data[d--] * tap0; + a += data[d--] * tap0; + } + y[1] += b; + y[0] += a; + } else { + while (d > d_end) { + tap0 = coef[c++]; + for (n = nch - 1; n >= 0; n--) + y[n] += data[d--] * tap0; + } } - if (ntaps & 1) - a += (int64_t) c[(*ic)++] * d[(*id)--]; - - *y += a; + *ic = c; + *id = d; } + #endif #if SRC_SHORT == 1 -static inline int32_t fir_filter( - struct src_state *fir, const int16_t coefs[], - int *coefi, int filter_length, int shift) +static void fir_filter(int ri0, int *ci, int wi0, int32_t in_delay[], + int32_t out_delay[], const int16_t coefs[], int dsm1, int taps, + int shift, int nch) { - int64_t y = 0; - int n1; int n2; - - n1 = fir->fir_ri + 1; - if (n1 > filter_length) { - /* No need to un-wrap fir read index, make sure fir_fi - * is ge 0 after FIR computation. - */ - fir_part(&y, filter_length, coefs, coefi, fir->fir_delay, - &fir->fir_ri); + int i; + int64_t y[PLATFORM_MAX_CHANNELS]; + int ri = ri0; + int wi = wi0; + int n1 = ri0 + 1; /* Convert to number of sequential frames */ + int qshift = 15 + shift; /* Q2.46 -> Q2.31 */ + int32_t rnd = 1 << (qshift - 1); /* Half LSB */ + int nch_x_taps = nch * taps; + + /* Initialize to half LSB for rounding */ + for (i = 0; i < nch; i++) + y[i] = rnd; + + if (n1 >= nch_x_taps) { + fir_part(y, &ri, ci, in_delay, coefs, nch_x_taps, nch); } else { - n2 = filter_length - n1; - /* Part 1, loop n1 times, fir_ri becomes -1 */ - fir_part(&y, n1, coefs, coefi, fir->fir_delay, &fir->fir_ri); - - /* Part 2, unwrap fir_ri, continue rest of filter */ - fir->fir_ri = fir->fir_delay_size - 1; - fir_part(&y, n2, coefs, coefi, fir->fir_delay, &fir->fir_ri); + n2 = nch_x_taps - n1; + fir_part(y, &ri, ci, in_delay, coefs, n1, nch); + ri = dsm1; + fir_part(y, &ri, ci, in_delay, coefs, n2, nch); } - /* Q2.46 -> Q2.31, saturate to Q1.31 */ - y = y >> (15 + shift); - return(int32_t) sat_int32(y); + for (i = 0; i < nch; i++) + out_delay[wi++] = sat_int32(y[i] >> qshift); } #else -static inline int32_t fir_filter( - struct src_state *fir, const int32_t coefs[], - int *coefi, int filter_length, int shift) +static void fir_filter(int ri0, int *ci, int wi0, int32_t in_delay[], + int32_t out_delay[], const int32_t coefs[], int dsm1, int taps, + int shift, int nch) { - int64_t y = 0; - int n1; int n2; - - n1 = fir->fir_ri + 1; - if (n1 > filter_length) { - /* No need to un-wrap fir read index, make sure fir_fi - * is ge 0 after FIR computation. - */ - fir_part(&y, filter_length, coefs, coefi, fir->fir_delay, - &fir->fir_ri); + int i; + int64_t y[PLATFORM_MAX_CHANNELS]; + int ri = ri0; + int wi = wi0; + int n1 = ri0 + 1; /* Convert to number of sequential frames */ + int qshift = 23 + shift; /* Q2.54 -> Q2.31 */ + int32_t rnd = 1 << (qshift - 1); /* Half LSB */ + int nch_x_taps = nch * taps; + + /* Initialize to half LSB for rounding */ + for (i = 0; i < nch; i++) + y[i] = rnd; + + if (n1 >= nch_x_taps) { + fir_part(y, &ri, ci, in_delay, coefs, nch_x_taps, nch); } else { - n2 = filter_length - n1; - /* Part 1, loop n1 times, fir_ri becomes -1 */ - fir_part(&y, n1, coefs, coefi, fir->fir_delay, &fir->fir_ri); - - /* Part 2, unwrap fir_ri, continue rest of filter */ - fir->fir_ri = fir->fir_delay_size - 1; - fir_part(&y, n2, coefs, coefi, fir->fir_delay, &fir->fir_ri); + n2 = nch_x_taps - n1; + fir_part(y, &ri, ci, in_delay, coefs, n1, nch); + ri = dsm1; + fir_part(y, &ri, ci, in_delay, coefs, n2, nch); } - /* Q9.47 -> Q9.24, saturate to Q8.24 */ - y = y >> (23 + shift); - return(int32_t) sat_int32(y); + for (i = 0; i < nch; i++) + out_delay[wi++] = sat_int32(y[i] >> qshift); + } + #endif void src_polyphase_stage_cir(struct src_stage_prm * s) { - struct src_state *fir = s->state; - struct src_stage *cfg = s->stage; int n; int m; int f; - int c; - int r; + int ci; + int ri; int n_wrap_fir; int n_wrap_buf; int n_wrap_min; int n_min; - int32_t z; + int wi; + + struct src_state *fir = s->state; + struct src_stage *cfg = s->stage; + const void *coef = cfg->coefs; + int32_t *in_delay = fir->fir_delay; + int32_t *out_delay = fir->out_delay; + int dsm1 = fir->fir_delay_size - 1; + int shift = cfg->shift; + int nch = s->nch; + int rewind = -nch * (cfg->blk_in + + (cfg->num_of_subfilters - 1) * cfg->idm) + nch - 1; + int nch_x_idm = cfg->idm * nch; + int nch_x_odm = cfg->odm * nch; + size_t sz = sizeof(int32_t); + int blk_in_bytes = nch * cfg->blk_in * sz; + int blk_out_bytes = nch * cfg->num_of_subfilters * sz; + for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * cfg->blk_in; + m = blk_in_bytes; while (m > 0) { - n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) - * s->x_inc; + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * sz; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { fir->fir_delay[fir->fir_wi++] = *s->x_rptr; - s->x_rptr += s->x_inc; - n_min -= s->x_inc; - m -= s->x_inc; + s->x_rptr++; + n_min -= sz; + m -= sz; } /* Check for wrap */ src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); @@ -478,41 +530,38 @@ void src_polyphase_stage_cir(struct src_stage_prm * s) } /* Filter */ - c = 0; - r = fir->fir_wi - cfg->blk_in - - (cfg->num_of_subfilters - 1) * cfg->idm; - if (r < 0) - r += fir->fir_delay_size; + ci = 0; /* Reset to 1st coefficient */ + ri = fir->fir_wi + rewind; /* Newest data for last subfilter */ + if (ri < 0) + ri += fir->fir_delay_size; - fir->out_wi = fir->out_ri; + wi = fir->out_ri; for (f = 0; f < cfg->num_of_subfilters; f++) { - fir->fir_ri = r; - z = fir_filter(fir, cfg->coefs, &c, - cfg->subfilter_length, cfg->shift); - r += cfg->idm; - if (r >= fir->fir_delay_size) - r -= fir->fir_delay_size; - - fir->out_delay[fir->out_wi] = z; - fir->out_wi += cfg->odm; - if (fir->out_wi >= fir->out_delay_size) - fir->out_wi -= fir->out_delay_size; + fir_filter(ri, &ci, wi, in_delay, out_delay, coef, + dsm1, cfg->subfilter_length, shift, nch); + + wi += nch_x_odm; + if (wi >= fir->out_delay_size) + wi -= fir->out_delay_size; + + ri += nch_x_idm; /* Next sub-filter start */ + if (ri >= fir->fir_delay_size) + ri -= fir->fir_delay_size; } /* Output */ - m = s->y_inc * cfg->num_of_subfilters; + m = blk_out_bytes; while (m > 0) { - n_wrap_fir = (fir->out_delay_size - fir->out_ri) - * s->y_inc; + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * sz; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { *s->y_wptr = fir->out_delay[fir->out_ri++]; - s->y_wptr += s->y_inc; - n_min -= s->y_inc; - m -= s->y_inc; + s->y_wptr++; + n_min -= sz; + m -= sz; } /* Check wrap */ src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); @@ -522,38 +571,49 @@ void src_polyphase_stage_cir(struct src_stage_prm * s) } } -void src_polyphase_stage_cir_s24(struct src_stage_prm * s) +void src_polyphase_stage_cir_s24(struct src_stage_prm *s) { - struct src_state *fir = s->state; - struct src_stage *cfg = s->stage; int n; int m; int f; - int c; - int r; + int ci; + int ri; int n_wrap_fir; int n_wrap_buf; int n_wrap_min; int n_min; - int32_t z; - int32_t se; + int wi; + + struct src_state *fir = s->state; + struct src_stage *cfg = s->stage; + const void *coef = cfg->coefs; + int32_t *in_delay = fir->fir_delay; + int32_t *out_delay = fir->out_delay; + int dsm1 = fir->fir_delay_size - 1; + int shift = cfg->shift; + int nch = s->nch; + int rewind = -nch * (cfg->blk_in + + (cfg->num_of_subfilters - 1) * cfg->idm) + nch - 1; + int nch_x_idm = cfg->idm * nch; + int nch_x_odm = cfg->odm * nch; + size_t sz = sizeof(int32_t); + int blk_in_bytes = nch * cfg->blk_in * sz; + int blk_out_bytes = nch * cfg->num_of_subfilters * sz; for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * cfg->blk_in; + m = blk_in_bytes; while (m > 0) { - n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) - * s->x_inc; + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * sz; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { - se = *s->x_rptr << 8; - fir->fir_delay[fir->fir_wi++] = se >> 8; - s->x_rptr += s->x_inc; - n_min -= s->x_inc; - m -= s->x_inc; + fir->fir_delay[fir->fir_wi++] = *s->x_rptr << 8; + s->x_rptr++; + n_min -= sz; + m -= sz; } /* Check for wrap */ src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); @@ -562,41 +622,38 @@ void src_polyphase_stage_cir_s24(struct src_stage_prm * s) } /* Filter */ - c = 0; - r = fir->fir_wi - cfg->blk_in - - (cfg->num_of_subfilters - 1) * cfg->idm; - if (r < 0) - r += fir->fir_delay_size; + ci = 0; /* Reset to 1st coefficient */ + ri = fir->fir_wi + rewind; /* Newest data for last subfilter */ + if (ri < 0) + ri += fir->fir_delay_size; - fir->out_wi = fir->out_ri; + wi = fir->out_ri; for (f = 0; f < cfg->num_of_subfilters; f++) { - fir->fir_ri = r; - z = fir_filter(fir, cfg->coefs, &c, - cfg->subfilter_length, cfg->shift); - r += cfg->idm; - if (r >= fir->fir_delay_size) - r -= fir->fir_delay_size; - - fir->out_delay[fir->out_wi] = z; - fir->out_wi += cfg->odm; - if (fir->out_wi >= fir->out_delay_size) - fir->out_wi -= fir->out_delay_size; + fir_filter(ri, &ci, wi, in_delay, out_delay, coef, + dsm1, cfg->subfilter_length, shift, nch); + + wi += nch_x_odm; + if (wi >= fir->out_delay_size) + wi -= fir->out_delay_size; + + ri += nch_x_idm; /* Next sub-filter start */ + if (ri >= fir->fir_delay_size) + ri -= fir->fir_delay_size; } /* Output */ - m = s->y_inc * cfg->num_of_subfilters; + m = blk_out_bytes; while (m > 0) { - n_wrap_fir = (fir->out_delay_size - fir->out_ri) - * s->y_inc; + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * sz; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; n_min = (m < n_wrap_min) ? m : n_wrap_min; while (n_min > 0) { - *s->y_wptr = fir->out_delay[fir->out_ri++]; - s->y_wptr += s->y_inc; - n_min -= s->y_inc; - m -= s->y_inc; + *s->y_wptr = fir->out_delay[fir->out_ri++] >> 8; + s->y_wptr++; + n_min -= sz; + m -= sz; } /* Check wrap */ src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); @@ -604,47 +661,5 @@ void src_polyphase_stage_cir_s24(struct src_stage_prm * s) fir->out_ri = 0; } } -} - -#ifdef MODULE_TEST - -void src_print_info(struct polyphase_src * src) -{ - - int n1; - int n2; - - n1 = src->stage1->filter_length; - n2 = src->stage2->filter_length; - printf("SRC stages %d\n", src->number_of_stages); - printf("SRC input blk %d\n", src->blk_in); - printf("SRC output blk %d\n", src->blk_out); - printf("SRC stage1 %d times\n", src->stage1_times); - printf("SRC stage2 %d times\n", src->stage2_times); - - printf("SRC1 filter length %d\n", n1); - printf("SRC1 subfilter length %d\n", src->stage1->subfilter_length); - printf("SRC1 number of subfilters %d\n", - src->stage1->num_of_subfilters); - printf("SRC1 idm %d\n", src->stage1->idm); - printf("SRC1 odm %d\n", src->stage1->odm); - printf("SRC1 input blk %d\n", src->stage1->blk_in); - printf("SRC1 output blk %d\n", src->stage1->blk_out); - printf("SRC1 halfband %d\n", src->stage1->halfband); - printf("SRC1 FIR delay %d\n", src->state1.fir_delay_size); - printf("SRC1 out delay %d\n", src->state1.out_delay_size); - - printf("SRC2 filter length %d\n", n2); - printf("SRC2 subfilter length %d\n", src->stage2->subfilter_length); - printf("SRC2 number of subfilters %d\n", - src->stage2->num_of_subfilters); - printf("SRC2 idm %d\n", src->stage2->idm); - printf("SRC2 odm %d\n", src->stage2->odm); - printf("SRC2 input blk %d\n", src->stage2->blk_in); - printf("SRC2 output blk %d\n", src->stage2->blk_out); - printf("SRC2 halfband %d\n", src->stage2->halfband); - printf("SRC2 FIR delay %d\n", src->state2.fir_delay_size); - printf("SRC2 out delay %d\n", src->state2.out_delay_size); } -#endif diff --git a/src/audio/src_core.h b/src/audio/src_core.h index 3859e6f..3ea6028 100644 --- a/src/audio/src_core.h +++ b/src/audio/src_core.h @@ -41,7 +41,7 @@ struct src_param { int out_s1; int out_s2; int sbuf_length; - int single_src; + int src_multich; int total; int blk_in; int blk_out; @@ -51,6 +51,7 @@ struct src_param { int stage2_times_max; int idx_in; int idx_out; + int nch; }; struct src_stage { @@ -70,20 +71,13 @@ struct src_state { int fir_delay_size; int out_delay_size; int fir_wi; - int fir_ri; - int out_wi; int out_ri; int32_t *fir_delay; int32_t *out_delay; }; struct polyphase_src { - int mute; int number_of_stages; - int blk_in; - int blk_out; - int stage1_times; - int stage2_times; struct src_stage *stage1; struct src_stage *stage2; struct src_state state1; @@ -91,15 +85,14 @@ struct polyphase_src { }; struct src_stage_prm { + int nch; int times; int32_t *x_rptr; int32_t *x_end_addr; size_t x_size; - int x_inc; int32_t *y_wptr; int32_t *y_end_addr; size_t y_size; - int y_inc; struct src_state *state; struct src_stage *stage; }; @@ -116,31 +109,6 @@ static inline void src_circ_dec_wrap(int32_t **ptr, int32_t *addr, size_t size) *ptr = (int32_t *) ((size_t) * ptr + size); } -static inline void src_polyphase_mute(struct polyphase_src *src) -{ - src->mute = 1; -} - -static inline void src_polyphase_unmute(struct polyphase_src *src) -{ - src->mute = 0; -} - -static inline int src_polyphase_getmute(struct polyphase_src *src) -{ - return src->mute; -} - -static inline int src_polyphase_get_blk_in(struct polyphase_src *src) -{ - return src->blk_in; -} - -static inline int src_polyphase_get_blk_out(struct polyphase_src *src) -{ - return src->blk_out; -} - void src_polyphase_reset(struct polyphase_src *src); int src_polyphase_init(struct polyphase_src *src, struct src_param *p, @@ -162,8 +130,4 @@ int32_t src_output_rates(void); int src_ceil_divide(int a, int b); -#ifdef MODULE_TEST -void src_print_info(struct polyphase_src *src); -#endif - #endif -- 2.11.0

2 1

[Sound-open-firmware] [PATCH] trace: dma: Add atomic and nowait DMA tracing support.
by Liam Girdwood 19 Oct '17

19 Oct '17

Add support for DMA trace to run in atomic and IRQ contexts. Currently DMA trace would sleep between DMA copies and enter atomic state when inserting new tarce data into the trace buffer. This patch adds new DMA _nowait() APIs that dont sleep and _atomic() APIs for trace logging that can be safely called in atomic context. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/audio/dma-trace.c | 144 ++++++++++++++++++++-------------- src/include/reef/audio/dma-trace.h | 1 + src/include/reef/dma.h | 4 + src/include/reef/trace.h | 12 +++ src/ipc/dma-copy.c | 157 ++++++++++++++++++++++++++++++++++--- src/lib/trace.c | 56 ++++++++++++- 6 files changed, 301 insertions(+), 73 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index 9704733..b0267fa 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -47,9 +47,7 @@ static uint64_t trace_work(void *data, uint64_t delay) struct dma_trace_buf *buffer = &d->dmatb; struct dma_sg_config *config = &d->config; unsigned long flags; - int32_t offset = 0; uint32_t avail = buffer->avail; - uint32_t bytes_copied = 0; uint32_t size; uint32_t hsize; uint32_t lsize; @@ -58,53 +56,51 @@ static uint64_t trace_work(void *data, uint64_t delay) if (avail == 0) return DMA_TRACE_US; + /* make sure we dont write more than buffer */ + if (avail > DMA_TRACE_LOCAL_SIZE) + avail = DMA_TRACE_LOCAL_SIZE; + /* copy to host in sections if we wrap */ - while (avail > 0) { - - lsize = hsize = avail; - - /* host buffer wrap ? */ - if (d->host_offset + buffer->avail > d->host_size) - hsize = d->host_offset + buffer->avail - d->host_size; - - /* local buffer wrap ? */ - if (buffer->r_ptr > buffer->w_ptr) - lsize = buffer->end_addr - buffer->r_ptr; - - /* get smallest size */ - if (hsize < lsize) - size = hsize; - else - size = lsize; - - /* writeback trace data */ - dcache_writeback_region((void*)buffer->r_ptr, size); - - /* copy this section to host */ - offset = dma_copy_to_host(&d->dc, config, d->host_offset, - buffer->r_ptr, size); - if (offset < 0) { - trace_buffer_error("ebb"); - goto out; - } - - /* update host pointer and check for wrap */ - d->host_offset += size; - if (d->host_offset + size >= d->host_size) - d->host_offset = 0; - - /* update local pointer and check for wrap */ - buffer->r_ptr += size; - if (buffer->r_ptr >= buffer->end_addr) - buffer->r_ptr = buffer->addr; - - avail -= size; - bytes_copied += size; + lsize = hsize = avail; + + /* host buffer wrap ? */ + if (d->host_offset + avail > d->host_size) + hsize = d->host_size - d->host_offset; + + /* local buffer wrap ? */ + if (buffer->r_ptr + avail > buffer->end_addr) + lsize = buffer->end_addr - buffer->r_ptr; + + /* get smallest size */ + if (hsize < lsize) + size = hsize; + else + size = lsize; + + /* writeback trace data */ + dcache_writeback_region((void*)buffer->r_ptr, size); + + /* copy this section to host */ + size = dma_copy_to_host_nowait(&d->dc, config, d->host_offset, + buffer->r_ptr, size); + if (size < 0) { + trace_buffer_error("ebb"); + goto out; } + /* update host pointer and check for wrap */ + d->host_offset += size; + if (d->host_offset + size >= d->host_size) + d->host_offset = 0; + + /* update local pointer and check for wrap */ + buffer->r_ptr += size; + if (buffer->r_ptr >= buffer->end_addr) + buffer->r_ptr = buffer->addr; + out: spin_lock_irq(&d->lock, flags); - buffer->avail -= bytes_copied; + buffer->avail -= size; spin_unlock_irq(&d->lock, flags); /* reschedule the trace copying work */ @@ -172,32 +168,28 @@ int dma_trace_enable(struct dma_trace_data *d) { /* validate DMA context */ if (d->dc.dmac == NULL || d->dc.chan < 0) { - trace_buffer_error("eem"); + trace_error_atomic(TRACE_CLASS_BUFFER, "eem"); return -ENODEV; } /* TODO: fix crash when enabled */ - //d->enabled = 1; + d->enabled = 1; work_schedule_default(&d->dmat_work, DMA_TRACE_US); return 0; } -void dtrace_event(const char *e, uint32_t length) +static void dtrace_add_event(const char *e, uint32_t length) { - struct dma_trace_buf *buffer = NULL; - int margin = 0; - unsigned long flags; + struct dma_trace_buf *buffer = &trace_data->dmatb; + int margin; - if (trace_data == NULL || length == 0) - return; + margin = buffer->end_addr - buffer->w_ptr; - buffer = &trace_data->dmatb; - if (buffer == NULL) + /* validate */ + if (margin <= 0) { + trace_buffer_error("emm"); return; - - spin_lock_irq(&trace_data->lock, flags); - - margin = buffer->end_addr - buffer->w_ptr; + } /* check for buffer wrap */ if (margin > length) { @@ -216,9 +208,45 @@ void dtrace_event(const char *e, uint32_t length) } buffer->avail += length; +} + +void dtrace_event(const char *e, uint32_t length) +{ + struct dma_trace_buf *buffer = NULL; + unsigned long flags; + + if (trace_data == NULL || length == 0) + return; + + if (!trace_data->enabled) + return; + + buffer = &trace_data->dmatb; + if (buffer == NULL) + return; + + spin_lock_irq(&trace_data->lock, flags); + dtrace_add_event(e, length); spin_unlock_irq(&trace_data->lock, flags); /* schedule copy now if buffer > 50% full */ if (trace_data->enabled && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) work_reschedule_default(&trace_data->dmat_work, 100); } + +void dtrace_event_atomic(const char *e, uint32_t length) +{ + struct dma_trace_buf *buffer = NULL; + + if (trace_data == NULL || length == 0) + return; + + if (!trace_data->enabled) + return; + + buffer = &trace_data->dmatb; + if (buffer == NULL) + return; + + dtrace_add_event(e, length); +} diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 83db484..12d0956 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -69,5 +69,6 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, int dma_trace_enable(struct dma_trace_data *d); void dtrace_event(const char *e, uint32_t size); +void dtrace_event_atomic(const char *e, uint32_t length); #endif diff --git a/src/include/reef/dma.h b/src/include/reef/dma.h index 33d1c9a..8dd4adf 100644 --- a/src/include/reef/dma.h +++ b/src/include/reef/dma.h @@ -249,9 +249,13 @@ static inline void dma_copy_free(struct dma_copy *dc) /* DMA copy data from host to DSP */ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); +int dma_copy_from_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size); /* DMA copy data from DSP to host */ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); +int dma_copy_to_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size); #endif diff --git a/src/include/reef/trace.h b/src/include/reef/trace.h index cdd8158..17dff5c 100644 --- a/src/include/reef/trace.h +++ b/src/include/reef/trace.h @@ -95,6 +95,8 @@ void _trace_event(uint32_t event); void _trace_error(uint32_t event); +void _trace_event_atomic(uint32_t event); +void _trace_error_atomic(uint32_t event); void trace_off(void); void trace_init(struct reef * reef); @@ -102,8 +104,11 @@ void trace_init(struct reef * reef); #define trace_event(__c, __e) \ _trace_event(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) +#define trace_event_atomic(__c, __e) \ + _trace_event_atomic(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #define trace_value(x) _trace_event(x) +#define trace_value_atomic(x) _trace_event_atomic(x) #define trace_point(x) platform_trace_point(x) @@ -111,17 +116,24 @@ void trace_init(struct reef * reef); #if TRACEV #define tracev_event(__c, __e) trace_event(__c, __e) #define tracev_value(x) _trace_event(x) +#define tracev_event_atomic(__c, __e) trace_event_atomic(__c, __e) +#define tracev_value_atomic(x) _trace_event_atomic(x) #else #define tracev_event(__c, __e) #define tracev_value(x) +#define tracev_event_atomic(__c, __e) +#define tracev_value_atomic(x) #endif /* error tracing */ #if TRACEE #define trace_error(__c, __e) \ _trace_error(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) +#define trace_error_atomic(__c, __e) \ + _trace_error_atomic(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #else #define trace_error(__c, __e) +#define trace_error_atomic(__c, __e) #endif #else diff --git a/src/ipc/dma-copy.c b/src/ipc/dma-copy.c index 75dd3bd..5c9ff97 100644 --- a/src/ipc/dma-copy.c +++ b/src/ipc/dma-copy.c @@ -75,8 +75,14 @@ static void dma_complete(void *data, uint32_t type, struct dma_sg_elem *next) if (type == DMA_IRQ_TYPE_LLIST) wait_completed(comp); + + next->size = DMA_RELOAD_END; } +/* Copy DSP memory to host memory. + * copies DSP memory to host in PAGE_SIZE or smaller blocks and waits/sleeps + * between blocks. Cant be used in IRQ context. + */ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size) { @@ -85,6 +91,7 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, struct dma_sg_elem local_sg_elem; int32_t err; int32_t offset = host_offset; + int32_t bytes_copied = 0; if (size <= 0) return 0; @@ -104,7 +111,11 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* configure local DMA elem */ local_sg_elem.dest = host_sg_elem->dest + offset; local_sg_elem.src = (uint32_t)local_ptr; - local_sg_elem.size = HOST_PAGE_SIZE - offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + list_item_prepend(&local_sg_elem.list, &config.elem_list); /* transfer max PAGE size at a time to SG buffer */ @@ -112,8 +123,13 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* start the DMA */ wait_init(&dc->complete); - dma_set_config(dc->dmac, dc->chan, &config); - dma_start(dc->dmac, dc->chan); + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; /* wait for DMA to complete */ err = wait_for_completion_timeout(&dc->complete); @@ -127,12 +143,15 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, host_offset += local_sg_elem.size; /* next dest host address is in next host elem */ + host_sg_elem = list_next_item(host_sg_elem, list); local_sg_elem.dest = host_sg_elem->dest; /* local address is continuous */ local_sg_elem.src = (uint32_t)local_ptr + local_sg_elem.size; + bytes_copied += local_sg_elem.size; + /* do we have less than 1 PAGE to copy ? */ if (size >= HOST_PAGE_SIZE) local_sg_elem.size = HOST_PAGE_SIZE; @@ -140,10 +159,65 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, local_sg_elem.size = size; } - /* new host offset in SG buffer */ - return host_offset; + /* bytes copied */ + return bytes_copied; +} + +/* Copy DSP memory to host memory. + * Copies DSP memory to host in a single PAGE_SIZE or smaller block. Does not + * waits/sleeps and can be used in IRQ context. + */ +int dma_copy_to_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) +{ + struct dma_sg_config config; + struct dma_sg_elem *host_sg_elem; + struct dma_sg_elem local_sg_elem; + int32_t err; + int32_t offset = host_offset; + + if (size <= 0) + return 0; + + /* find host element with host_offset */ + host_sg_elem = sg_get_elem_at(host_sg, &offset); + if (host_sg_elem == NULL) + return -EINVAL; + + /* set up DMA configuration */ + config.direction = DMA_DIR_LMEM_TO_HMEM; + config.src_width = sizeof(uint32_t); + config.dest_width = sizeof(uint32_t); + config.cyclic = 0; + list_init(&config.elem_list); + + /* configure local DMA elem */ + local_sg_elem.dest = host_sg_elem->dest + offset; + local_sg_elem.src = (uint32_t)local_ptr; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + + list_item_prepend(&local_sg_elem.list, &config.elem_list); + + /* start the DMA */ + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + + /* bytes copied */ + return local_sg_elem.size; } +/* Copy host memory to DSP memory. + * Copies host memory to host in PAGE_SIZE or smaller blocks and waits/sleeps + * between blocks. Cant be used in IRQ context. + */ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size) { @@ -152,6 +226,7 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, struct dma_sg_elem local_sg_elem; int32_t err; int32_t offset = host_offset; + int32_t bytes_copied = 0; if (size <= 0) return 0; @@ -171,7 +246,10 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* configure local DMA elem */ local_sg_elem.dest = (uint32_t)local_ptr; local_sg_elem.src = host_sg_elem->src + offset; - local_sg_elem.size = HOST_PAGE_SIZE - offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; list_item_prepend(&local_sg_elem.list, &config.elem_list); /* transfer max PAGE size at a time to SG buffer */ @@ -179,9 +257,14 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* start the DMA */ wait_init(&dc->complete); - dma_set_config(dc->dmac, dc->chan, &config); - dma_start(dc->dmac, dc->chan); - + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + /* wait for DMA to complete */ err = wait_for_completion_timeout(&dc->complete); if (err < 0) { @@ -200,6 +283,8 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* local address is continuous */ local_sg_elem.dest = (uint32_t)local_ptr + local_sg_elem.size; + bytes_copied += local_sg_elem.size; + /* do we have less than 1 PAGE to copy ? */ if (size >= HOST_PAGE_SIZE) local_sg_elem.size = HOST_PAGE_SIZE; @@ -207,8 +292,58 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, local_sg_elem.size = size; } - /* new host offset in SG buffer */ - return host_offset; + /* bytes copied */ + return bytes_copied; +} + +/* Copy host memory to DSP memory. + * Copies host memory to DSP in a single PAGE_SIZE or smaller block. Does not + * waits/sleeps and can be used in IRQ context. + */ +int dma_copy_from_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) +{ + struct dma_sg_config config; + struct dma_sg_elem *host_sg_elem; + struct dma_sg_elem local_sg_elem; + int32_t err; + int32_t offset = host_offset; + + if (size <= 0) + return 0; + + /* find host element with host_offset */ + host_sg_elem = sg_get_elem_at(host_sg, &offset); + if (host_sg_elem == NULL) + return -EINVAL; + + /* set up DMA configuration */ + config.direction = DMA_DIR_HMEM_TO_LMEM; + config.src_width = sizeof(uint32_t); + config.dest_width = sizeof(uint32_t); + config.cyclic = 0; + list_init(&config.elem_list); + + /* configure local DMA elem */ + local_sg_elem.dest = (uint32_t)local_ptr; + local_sg_elem.src = host_sg_elem->src + offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + list_item_prepend(&local_sg_elem.list, &config.elem_list); + + /* start the DMA */ + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + + /* bytes copied */ + return local_sg_elem.size; } int dma_copy_new(struct dma_copy *dc, int dmac) diff --git a/src/lib/trace.c b/src/lib/trace.c index 6f707c3..c0abf7c 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -49,30 +49,66 @@ void _trace_error(uint32_t event) { unsigned long flags; volatile uint64_t *t; + uint64_t dt[2]; + uint64_t time; if (!trace.enable) return; + time = platform_timer_get(platform_timer); + /* save event to DMA tracing buffer */ - _trace_event(event); + dt[0] = time; + dt[1] = event; + dtrace_event((const char*)dt, sizeof(uint64_t) * 2); /* send event by mail box too. */ spin_lock_irq(&trace.lock, flags); /* write timestamp and event to trace buffer */ t = (volatile uint64_t*)(MAILBOX_TRACE_BASE + trace.pos); - t[0] = platform_timer_get(platform_timer); + trace.pos += (sizeof(uint64_t) << 1); + + if (trace.pos > MAILBOX_TRACE_SIZE - sizeof(uint64_t) * 2) + trace.pos = 0; + + spin_unlock_irq(&trace.lock, flags); + + t[0] = time; t[1] = event; /* writeback trace data */ dcache_writeback_region((void*)t, sizeof(uint64_t) * 2); +} + +void _trace_error_atomic(uint32_t event) +{ + volatile uint64_t *t; + uint64_t dt[2]; + uint64_t time; + + if (!trace.enable) + return; + + time = platform_timer_get(platform_timer); + + /* save event to DMA tracing buffer */ + dt[0] = time; + dt[1] = event; + dtrace_event_atomic((const char*)dt, sizeof(uint64_t) * 2); + /* write timestamp and event to trace buffer */ + t = (volatile uint64_t*)(MAILBOX_TRACE_BASE + trace.pos); trace.pos += (sizeof(uint64_t) << 1); if (trace.pos > MAILBOX_TRACE_SIZE - sizeof(uint64_t) * 2) trace.pos = 0; - spin_unlock_irq(&trace.lock, flags); + t[0] = time; + t[1] = event; + + /* writeback trace data */ + dcache_writeback_region((void*)t, sizeof(uint64_t) * 2); } void _trace_event(uint32_t event) @@ -87,10 +123,22 @@ void _trace_event(uint32_t event) dtrace_event((const char*)dt, sizeof(uint64_t) * 2); } +void _trace_event_atomic(uint32_t event) +{ + uint64_t dt[2]; + + if (!trace.enable) + return; + + dt[0] = platform_timer_get(platform_timer); + dt[1] = event; + dtrace_event_atomic((const char*)dt, sizeof(uint64_t) * 2); +} + void trace_off(void) { trace.enable = 0; -}; +} void trace_init(struct reef *reef) { -- 2.11.0

1 5

Re: [Sound-open-firmware] Support for Tangier SoC
by Liam Girdwood 16 Oct '17

16 Oct '17

On Sun, 2017-10-15 at 19:51 +0200, Sven Schwermer wrote: > Hi. > > I was wondering if the Tangier SoC (Merrifield platform) is or will be > supported by SOF? I have the Intel Edison compute module in mind. > Yes, it _should_ work on Merrifield, but I don't have Edison HW so some things on the driver side might need some work. The 1.0-dev branch and sof-v4.13 kernel will probably be better for Edison than the stable 0.95 branch atm (mainly due to driver updates), but 1.0-dev is still has a few issues prior to doing an rc1 tag. Liam --------------------------------------------------------------------- Intel Corporation (UK) Limited Registered No. 1134945 (England) Registered Office: Pipers Way, Swindon SN3 1RJ VAT No: 860 2173 47 This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.

2 1

[Sound-open-firmware] [PATCH] dma copy: trace: Fix locking with DMA trace and refactor API usage.
by Liam Girdwood 16 Oct '17

16 Oct '17

Fix locking in DMA trace. Also run the DMA trace as delayed work so we dont block callers. Refactor API so that DMAC and channel are pre-allocated. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/audio/dma-trace.c | 101 ++++++++++------------ src/include/reef/alloc.h | 4 +- src/include/reef/audio/dma-trace.h | 5 +- src/include/reef/dma.h | 22 ++++- src/ipc/dma-copy.c | 95 ++++++++++---------- src/ipc/intel-ipc.c | 4 +- src/ipc/ipc.c | 1 - src/lib/alloc.c | 12 +-- src/lib/trace.c | 6 +- src/platform/baytrail/include/platform/platform.h | 3 + 10 files changed, 131 insertions(+), 122 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index 00a29b4..9704733 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -41,51 +41,22 @@ static struct dma_trace_data *trace_data = NULL; -static int dma_trace_new_buffer(struct dma_trace_data *d, uint32_t buffer_size) -{ - struct dma_trace_buf *buffer = &d->dmatb; - - trace_buffer("nlb"); - - /* validate request */ - if (buffer_size == 0 || buffer_size > HEAP_BUFFER_SIZE) { - trace_buffer_error("ebg"); - trace_value(buffer_size); - return -ENOMEM; - } - - /* allocate new buffer */ - buffer->addr = rballoc(RZONE_RUNTIME, RFLAGS_NONE, buffer_size); - if (buffer->addr == NULL) { - trace_buffer_error("ebm"); - return -ENOMEM; - } - - bzero(buffer->addr, buffer_size); - - buffer->size = buffer_size; - buffer->w_ptr = buffer->r_ptr = buffer->addr; - buffer->end_addr = buffer->addr + buffer->size; - buffer->avail = 0; - - return 0; -} - -static void trace_send(struct dma_trace_data *d) +static uint64_t trace_work(void *data, uint64_t delay) { + struct dma_trace_data *d = (struct dma_trace_data *)data; struct dma_trace_buf *buffer = &d->dmatb; struct dma_sg_config *config = &d->config; unsigned long flags; int32_t offset = 0; uint32_t avail = buffer->avail; - uint32_t bytes_copied = avail; + uint32_t bytes_copied = 0; uint32_t size; uint32_t hsize; uint32_t lsize; /* any data to copy ? */ if (avail == 0) - return; + return DMA_TRACE_US; /* copy to host in sections if we wrap */ while (avail > 0) { @@ -106,12 +77,15 @@ static void trace_send(struct dma_trace_data *d) else size = lsize; + /* writeback trace data */ + dcache_writeback_region((void*)buffer->r_ptr, size); + /* copy this section to host */ - offset = dma_copy_to_host(config, d->host_offset, + offset = dma_copy_to_host(&d->dc, config, d->host_offset, buffer->r_ptr, size); if (offset < 0) { trace_buffer_error("ebb"); - return; + goto out; } /* update host pointer and check for wrap */ @@ -125,18 +99,13 @@ static void trace_send(struct dma_trace_data *d) buffer->r_ptr = buffer->addr; avail -= size; + bytes_copied += size; } +out: spin_lock_irq(&d->lock, flags); buffer->avail -= bytes_copied; spin_unlock_irq(&d->lock, flags); -} - -static uint64_t trace_work(void *data, uint64_t delay) -{ - struct dma_trace_data *d = (struct dma_trace_data *)data; - - trace_send(d); /* reschedule the trace copying work */ return DMA_TRACE_US; @@ -144,25 +113,41 @@ static uint64_t trace_work(void *data, uint64_t delay) int dma_trace_init(struct dma_trace_data *d) { - int err; + struct dma_trace_buf *buffer = &d->dmatb; + int ret; trace_buffer("dtn"); - /* init buffer elems */ - list_init(&d->config.elem_list); + /* allocate new buffer */ + buffer->addr = rballoc(RZONE_RUNTIME, RFLAGS_NONE, DMA_TRACE_LOCAL_SIZE); + if (buffer->addr == NULL) { + trace_buffer_error("ebm"); + return -ENOMEM; + } - /* allocate local DMA buffer */ - err = dma_trace_new_buffer(d, DMA_TRACE_LOCAL_SIZE); - if (err < 0) { - trace_buffer_error("ePb"); - return err; + /* init DMA copy context */ + ret = dma_copy_new(&d->dc, PLATFORM_TRACE_DMAC); + if (ret < 0) { + trace_buffer_error("edm"); + rfree(buffer->addr); + return ret; } + bzero(buffer->addr, DMA_TRACE_LOCAL_SIZE); + + /* initialise the DMA buffer */ + buffer->size = DMA_TRACE_LOCAL_SIZE; + buffer->w_ptr = buffer->r_ptr = buffer->addr; + buffer->end_addr = buffer->addr + buffer->size; + buffer->avail = 0; d->host_offset = 0; - trace_data = d; + d->enabled = 0; + list_init(&d->config.elem_list); work_init(&d->dmat_work, trace_work, d, WORK_ASYNC); spinlock_init(&d->lock); + trace_data = d; + return 0; } @@ -183,10 +168,18 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, return 0; } -void dma_trace_config_ready(struct dma_trace_data *d) +int dma_trace_enable(struct dma_trace_data *d) { + /* validate DMA context */ + if (d->dc.dmac == NULL || d->dc.chan < 0) { + trace_buffer_error("eem"); + return -ENODEV; + } + + /* TODO: fix crash when enabled */ + //d->enabled = 1; work_schedule_default(&d->dmat_work, DMA_TRACE_US); - d->ready = 1; + return 0; } void dtrace_event(const char *e, uint32_t length) @@ -226,6 +219,6 @@ void dtrace_event(const char *e, uint32_t length) spin_unlock_irq(&trace_data->lock, flags); /* schedule copy now if buffer > 50% full */ - if (trace_data->ready && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) + if (trace_data->enabled && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) work_reschedule_default(&trace_data->dmat_work, 100); } diff --git a/src/include/reef/alloc.h b/src/include/reef/alloc.h index 4e8a630..982af90 100644 --- a/src/include/reef/alloc.h +++ b/src/include/reef/alloc.h @@ -86,8 +86,8 @@ int rstrlen(const char *s); /* Heap save/restore contents and context for PM D0/D3 events */ uint32_t mm_pm_context_size(void); -int mm_pm_context_save(struct dma_sg_config *sg); -int mm_pm_context_restore(struct dma_sg_config *sg); +int mm_pm_context_save(struct dma_copy *dc, struct dma_sg_config *sg); +int mm_pm_context_restore(struct dma_copy *dc, struct dma_sg_config *sg); /* heap initialisation */ void init_heap(struct reef *reef); diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 20f2e18..83db484 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -55,17 +55,18 @@ struct dma_trace_buf { struct dma_trace_data { struct dma_sg_config config; struct dma_trace_buf dmatb; + struct dma_copy dc; int32_t host_offset; uint32_t host_size; struct work dmat_work; - uint32_t ready; + uint32_t enabled; spinlock_t lock; }; int dma_trace_init(struct dma_trace_data *d); int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, uint32_t host_size); -void dma_trace_config_ready(struct dma_trace_data *d); +int dma_trace_enable(struct dma_trace_data *d); void dtrace_event(const char *e, uint32_t size); diff --git a/src/include/reef/dma.h b/src/include/reef/dma.h index 881332f..33d1c9a 100644 --- a/src/include/reef/dma.h +++ b/src/include/reef/dma.h @@ -36,6 +36,7 @@ #include <reef/list.h> #include <reef/lock.h> #include <reef/reef.h> +#include <reef/wait.h> /* DMA directions */ #define DMA_DIR_MEM_TO_MEM 0 /* local memcpy */ @@ -228,12 +229,29 @@ static inline uint32_t dma_sg_get_size(struct dma_sg_config *sg) return size; } +/* generic DMA DSP <-> Host copier */ + +struct dma_copy { + int chan; + struct dma *dmac; + completion_t complete; +}; + +/* init dma copy context */ +int dma_copy_new(struct dma_copy *dc, int dmac); + +/* free dma copy context resources */ +static inline void dma_copy_free(struct dma_copy *dc) +{ + dma_channel_put(dc->dmac, dc->chan); +} + /* DMA copy data from host to DSP */ -int dma_copy_from_host(struct dma_sg_config *host_sg, +int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); /* DMA copy data from DSP to host */ -int dma_copy_to_host(struct dma_sg_config *host_sg, +int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); #endif diff --git a/src/ipc/dma-copy.c b/src/ipc/dma-copy.c index b345ac9..75dd3bd 100644 --- a/src/ipc/dma-copy.c +++ b/src/ipc/dma-copy.c @@ -38,6 +38,11 @@ #include <reef/wait.h> #include <platform/dma.h> +/* tracing */ +#define trace_dma(__e) trace_event(TRACE_CLASS_DMA, __e) +#define trace_dma_error(__e) trace_error(TRACE_CLASS_DMA, __e) +#define tracev_dma(__e) tracev_event(TRACE_CLASS_DMA, __e) + static struct dma_sg_elem *sg_get_elem_at(struct dma_sg_config *host_sg, int32_t *offset) { @@ -60,7 +65,7 @@ static struct dma_sg_elem *sg_get_elem_at(struct dma_sg_config *host_sg, } /* host offset in beyond end of SG buffer */ - //trace_mem_error("eMs"); + trace_dma_error("ex0"); return NULL; } @@ -72,27 +77,17 @@ static void dma_complete(void *data, uint32_t type, struct dma_sg_elem *next) wait_completed(comp); } -int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, - void *local_ptr, int32_t size) +int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) { struct dma_sg_config config; struct dma_sg_elem *host_sg_elem; struct dma_sg_elem local_sg_elem; - struct dma *dma = dma_get(DMA_ID_DMAC0); - completion_t complete; int32_t err; int32_t offset = host_offset; - int32_t chan; - if (dma == NULL) - return -ENODEV; - - /* get DMA channel from DMAC0 */ - chan = dma_channel_get(dma); - if (chan < 0) { - //trace_ipc_error("ePC"); - return chan; - } + if (size <= 0) + return 0; /* find host element with host_offset */ host_sg_elem = sg_get_elem_at(host_sg, &offset); @@ -100,7 +95,6 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, return -EINVAL; /* set up DMA configuration */ - complete.timeout = 100; /* wait 100 usecs for DMA to finish */ config.direction = DMA_DIR_LMEM_TO_HMEM; config.src_width = sizeof(uint32_t); config.dest_width = sizeof(uint32_t); @@ -113,21 +107,18 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, local_sg_elem.size = HOST_PAGE_SIZE - offset; list_item_prepend(&local_sg_elem.list, &config.elem_list); - dma_set_cb(dma, chan, DMA_IRQ_TYPE_LLIST, dma_complete, &complete); - /* transfer max PAGE size at a time to SG buffer */ while (size > 0) { /* start the DMA */ - wait_init(&complete); - dma_set_config(dma, chan, &config); - dma_start(dma, chan); + wait_init(&dc->complete); + dma_set_config(dc->dmac, dc->chan, &config); + dma_start(dc->dmac, dc->chan); /* wait for DMA to complete */ - err = wait_for_completion_timeout(&complete); + err = wait_for_completion_timeout(&dc->complete); if (err < 0) { - //trace_comp_error("eAp"); - dma_channel_put(dma, chan); + trace_dma_error("ex1"); return -EIO; } @@ -150,31 +141,20 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, } /* new host offset in SG buffer */ - dma_channel_put(dma, chan); return host_offset; } -int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, - void *local_ptr, int32_t size) +int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) { struct dma_sg_config config; struct dma_sg_elem *host_sg_elem; struct dma_sg_elem local_sg_elem; - struct dma *dma = dma_get(DMA_ID_DMAC0); - completion_t complete; int32_t err; int32_t offset = host_offset; - int32_t chan; - if (dma == NULL) - return -ENODEV; - - /* get DMA channel from DMAC0 */ - chan = dma_channel_get(dma); - if (chan < 0) { - //trace_ipc_error("ePC"); - return chan; - } + if (size <= 0) + return 0; /* find host element with host_offset */ host_sg_elem = sg_get_elem_at(host_sg, &offset); @@ -182,7 +162,6 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, return -EINVAL; /* set up DMA configuration */ - complete.timeout = 100; /* wait 100 usecs for DMA to finish */ config.direction = DMA_DIR_HMEM_TO_LMEM; config.src_width = sizeof(uint32_t); config.dest_width = sizeof(uint32_t); @@ -195,21 +174,18 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, local_sg_elem.size = HOST_PAGE_SIZE - offset; list_item_prepend(&local_sg_elem.list, &config.elem_list); - dma_set_cb(dma, chan, DMA_IRQ_TYPE_LLIST, dma_complete, &complete); - /* transfer max PAGE size at a time to SG buffer */ while (size > 0) { /* start the DMA */ - wait_init(&complete); - dma_set_config(dma, chan, &config); - dma_start(dma, chan); + wait_init(&dc->complete); + dma_set_config(dc->dmac, dc->chan, &config); + dma_start(dc->dmac, dc->chan); /* wait for DMA to complete */ - err = wait_for_completion_timeout(&complete); + err = wait_for_completion_timeout(&dc->complete); if (err < 0) { - //trace_comp_error("eAp"); - dma_channel_put(dma, chan); + trace_dma_error("ex2"); return -EIO; } @@ -232,6 +208,27 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, } /* new host offset in SG buffer */ - dma_channel_put(dma, chan); return host_offset; } + +int dma_copy_new(struct dma_copy *dc, int dmac) +{ + dc->dmac = dma_get(dmac); + if (dc->dmac == NULL) { + trace_dma_error("ec0"); + return -ENODEV; + } + + /* get DMA channel from DMAC0 */ + dc->chan = dma_channel_get(dc->dmac); + if (dc->chan < 0) { + trace_dma_error("ec1"); + return dc->chan; + } + + dc->complete.timeout = 100; /* wait 100 usecs for DMA to finish */ + dma_set_cb(dc->dmac, dc->chan, DMA_IRQ_TYPE_LLIST, dma_complete, + &dc->complete); + return 0; +} + diff --git a/src/ipc/intel-ipc.c b/src/ipc/intel-ipc.c index 4b56993..9b47ca9 100644 --- a/src/ipc/intel-ipc.c +++ b/src/ipc/intel-ipc.c @@ -629,7 +629,9 @@ static int ipc_dma_trace_config(uint32_t header) trace_ipc("DAp"); - dma_trace_config_ready(&_ipc->dmat); + err = dma_trace_enable(&_ipc->dmat); + if (err < 0) + goto error; /* write component values to the outbox */ reply.hdr.size = sizeof(reply); diff --git a/src/ipc/ipc.c b/src/ipc/ipc.c index 05de838..6c40d10 100644 --- a/src/ipc/ipc.c +++ b/src/ipc/ipc.c @@ -350,7 +350,6 @@ int ipc_init(struct reef *reef) /* init ipc data */ reef->ipc = rzalloc(RZONE_SYS, RFLAGS_NONE, sizeof(*reef->ipc)); reef->ipc->comp_data = rzalloc(RZONE_SYS, RFLAGS_NONE, SOF_IPC_MSG_MAX_SIZE); - reef->ipc->dmat.ready = 0; list_init(&reef->ipc->comp_list); diff --git a/src/lib/alloc.c b/src/lib/alloc.c index 0d9b07c..63f92de 100644 --- a/src/lib/alloc.c +++ b/src/lib/alloc.c @@ -573,7 +573,7 @@ uint32_t mm_pm_context_size(void) * must be disabled before calling this functions. No allocations are permitted after * calling this and before calling restore. */ -int mm_pm_context_save(struct dma_sg_config *sg) +int mm_pm_context_save(struct dma_copy *dc, struct dma_sg_config *sg) { uint32_t used; int32_t offset = 0; @@ -585,13 +585,13 @@ int mm_pm_context_save(struct dma_sg_config *sg) return -EINVAL; /* copy memory maps to SG */ - ret = dma_copy_to_host(sg, offset, + ret = dma_copy_to_host(dc, sg, offset, (void *)&memmap, sizeof(memmap)); if (ret < 0) return ret; /* copy system memory contents to SG */ - ret = dma_copy_to_host(sg, offset + ret, + ret = dma_copy_to_host(dc, sg, offset + ret, (void *)memmap.system.heap, (int32_t)(memmap.system.size)); if (ret < 0) return ret; @@ -611,19 +611,19 @@ int mm_pm_context_save(struct dma_sg_config *sg) * Restore the DSP memories to modules abd the system. This must be called immediately * after booting before any pipeline work. */ -int mm_pm_context_restore(struct dma_sg_config *sg) +int mm_pm_context_restore(struct dma_copy *dc, struct dma_sg_config *sg) { int32_t offset = 0; int32_t ret; /* copy memory maps from SG */ - ret = dma_copy_from_host(sg, offset, + ret = dma_copy_from_host(dc, sg, offset, (void *)&memmap, sizeof(memmap)); if (ret < 0) return ret; /* copy system memory contents from SG */ - ret = dma_copy_to_host(sg, offset + ret, + ret = dma_copy_to_host(dc, sg, offset + ret, (void *)memmap.system.heap, (int32_t)(memmap.system.size)); if (ret < 0) return ret; diff --git a/src/lib/trace.c b/src/lib/trace.c index bdd50ae..6f707c3 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -77,15 +77,11 @@ void _trace_error(uint32_t event) void _trace_event(uint32_t event) { - volatile uint64_t dt[2]; - uint32_t et = (event & 0xff000000); + uint64_t dt[2]; if (!trace.enable) return; - if (et == TRACE_CLASS_DMA) - return; - dt[0] = platform_timer_get(platform_timer); dt[1] = event; dtrace_event((const char*)dt, sizeof(uint64_t) * 2); diff --git a/src/platform/baytrail/include/platform/platform.h b/src/platform/baytrail/include/platform/platform.h index ff3a117..4d63f7b 100644 --- a/src/platform/baytrail/include/platform/platform.h +++ b/src/platform/baytrail/include/platform/platform.h @@ -82,6 +82,9 @@ struct reef; /* the interval of DMA trace copying */ #define DMA_TRACE_US 500000 +/* DMAC used for trace DMA */ +#define PLATFORM_TRACE_DMAC DMA_ID_DMAC0 + /* Platform defined panic code */ #define platform_panic(__x) \ shim_write(SHIM_IPCXL, ((shim_read(SHIM_IPCXL) & 0xc0000000) |\ -- 1.9.1

1 0

[Sound-open-firmware] [PATCH 2/2] Forward trace event to DMA buffer.
by yan.wang＠linux.intel.com 14 Oct '17

14 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Ignore DMA trace event when forwarding for avoiding dead lock because DMA tracing uses DMA API to copy trace event. 2. Add _trace_error() API to send error event by mail box at the same time too when copying error event by DMA. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/include/reef/trace.h | 4 +++- src/lib/trace.c | 28 +++++++++++++++++++++++++++- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/include/reef/trace.h b/src/include/reef/trace.h index 300e8d8..cdd8158 100644 --- a/src/include/reef/trace.h +++ b/src/include/reef/trace.h @@ -94,6 +94,7 @@ #define TRACEE 1 void _trace_event(uint32_t event); +void _trace_error(uint32_t event); void trace_off(void); void trace_init(struct reef * reef); @@ -117,7 +118,8 @@ void trace_init(struct reef * reef); /* error tracing */ #if TRACEE -#define trace_error(__c, __e) trace_event(__c, __e) +#define trace_error(__c, __e) \ + _trace_error(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #else #define trace_error(__c, __e) #endif diff --git a/src/lib/trace.c b/src/lib/trace.c index 33e1466..b0b32d6 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -34,6 +34,7 @@ #include <arch/cache.h> #include <platform/timer.h> #include <reef/lock.h> +#include <reef/audio/dma-trace.h> #include <stdint.h> struct trace { @@ -44,7 +45,7 @@ struct trace { static struct trace trace; -void _trace_event(uint32_t event) +void _trace_error(uint32_t event) { unsigned long flags; volatile uint32_t *t; @@ -52,6 +53,10 @@ void _trace_event(uint32_t event) if (!trace.enable) return; + /* save event to DMA tracing buffer */ + _trace_event(event); + + /* send event by mail box too. */ spin_lock_irq(&trace.lock, flags); /* write timestamp and event to trace buffer */ @@ -70,6 +75,27 @@ void _trace_event(uint32_t event) spin_unlock_irq(&trace.lock, flags); } +void _trace_event(uint32_t event) +{ + unsigned long flags; + volatile uint64_t dt[2]; + volatile uint32_t et = (event & 0xff000000); + + if (!trace.enable) + return; + + if (et == TRACE_CLASS_DMA) + return; + + spin_lock_irq(&trace.lock, flags); + + dt[0] = platform_timer_get(platform_timer); + dt[1] = event; + dtrace_event((const char*)dt, sizeof(uint64_t) * 2); + + spin_unlock_irq(&trace.lock, flags); +} + void trace_off(void) { trace.enable = 0; -- 2.7.4

3 2

[Sound-open-firmware] [PATCH] scheduler: enforce locking for edf_schedule list operations
by Liam Girdwood 13 Oct '17

13 Oct '17

make sure our task list is protected by lock for readers and writers. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/lib/schedule.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/lib/schedule.c b/src/lib/schedule.c index 993f94a..ab0602b 100644 --- a/src/lib/schedule.c +++ b/src/lib/schedule.c @@ -102,10 +102,15 @@ static inline struct task *edf_get_next(uint64_t current, uint64_t delta; uint64_t deadline; int reschedule = 0; + uint32_t flags; + spin_lock_irq(&sch->lock, flags); + /* any tasks in the scheduler ? */ - if (list_is_empty(&sch->list)) + if (list_is_empty(&sch->list)) { + spin_unlock_irq(&sch->lock, flags); return NULL; + } /* check every queued or running task in list */ list_for_item_safe(clist, tlist, &sch->list) { @@ -142,6 +147,7 @@ static inline struct task *edf_get_next(uint64_t current, } } + spin_unlock_irq(&sch->lock, flags); return next_task; } @@ -164,20 +170,15 @@ static struct task *schedule_edf(void) struct task *task; struct task *next_plus1_task = NULL; uint64_t current; - uint32_t flags; tracev_pipe("edf"); - /* get next component scheduled */ - spin_lock_irq(&sch->lock, flags); - /* get the current time */ current = platform_timer_get(platform_timer); /* get next task to be scheduled */ task = edf_get_next(current, NULL); - spin_unlock_irq(&sch->lock, flags); interrupt_clear(PLATFORM_SCHEDULE_IRQ); /* any tasks ? */ -- 1.9.1

1 1

[Sound-open-firmware] [PATCH] rmbox: move trace into separate parser function to ease future work.
by Liam Girdwood 13 Oct '17

13 Oct '17

Move trace handler into separate function to make it easier to add new trace features. Make sure we only support 64 bit timestamps. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- rmbox/rmbox.c | 159 ++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 109 insertions(+), 50 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index d650d30..9313f4b 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -82,6 +82,9 @@ #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) + +#define TRACE_BLOCK_SIZE 8 + static inline char get_char(uint32_t val, int idx) { char c = (val >> (idx * 8)) & 0xff; @@ -94,58 +97,41 @@ static inline char get_char(uint32_t val, int idx) static void usage(char *name) { fprintf(stdout, "Usage %s <option(s)> <file(s)>\n", name); + fprintf(stdout, "%s:\t \t\t\tDisplay mailbox contents\n", name); fprintf(stdout, "%s:\t -i infile -o outfile\tDump infile contents to outfile\n", name); fprintf(stdout, "%s:\t -c\t\t\tSet timestamp clock in MHz\n", name); fprintf(stdout, "%s:\t -s\t\t\tTake a snapshot of state\n", name); + fprintf(stdout, "%s:\t -t\t\t\tDisplay trace data\n", name); exit(0); } -static float to_usecs(uint64_t time, float clk) +static double to_usecs(uint64_t time, double clk) { /* trace timestamp uses CPU system clock at default 25MHz ticks */ // TODO: support variable clock rates return (double)time / clk; } -static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float clk, uint64_t align) +static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, double clk) { const char *trace; uint32_t class; uint64_t delta = val - *timestamp; - float fdelta = to_usecs(delta, clk); - float us = 0.0f; - uint64_t s = 0, ms = 0; - uint64_t ds = 0, dms = 0; + double fdelta = to_usecs(delta, clk); + double us = 0.0f; /* timestamp or value ? */ - if ((addr % align) == 0) { - /* buffer wrap ? */ - if (val < *timestamp) { - printf("----------------------------------------" - "----------------------------------------" - "--------------------------------------\n"); - delta = 0; - fdelta = 0.0; - } else { - delta = val - *timestamp; - fdelta = to_usecs(delta, clk); - } + if ((addr % (TRACE_BLOCK_SIZE * 2)) == 0) { + + delta = val - *timestamp; + fdelta = to_usecs(delta, clk); + + /* 64-bit timestamp */ + us = to_usecs(val, clk); + + printf("[%6.6f]\tdelta [%6.6f]\t", + us / 1000000.0 , fdelta / 1000000.0); - if (align == 8) { - /* 32-bit timestamp */ - printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", - (uint64_t)val, to_usecs(val, clk), - (uint64_t)delta, fdelta); - } else { - /* 64-bit timestamp */ - us = to_usecs(val, clk); - s = us / 1000000; - ms = us / 1000 - s * 1000; - ds = fdelta / 1000000; - dms = fdelta / 1000 - ds * 1000; - printf("trace.io: timestamp [%lu.%lu] \tdelta [%lu.%lu]\t", - s, ms, ds, dms); - } *timestamp = val; return; } @@ -206,6 +192,68 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c (char)(val >> 16), (char)(val >> 8), (char)val); } +static int trace_read(const char *in_file, const char *out_file, double clk, + int offset) +{ + int count, i; + FILE *in_fd = NULL, *out_fd = NULL; + char c, tmp[TRACE_BLOCK_SIZE] = {0}; + uint64_t addr = 0, val, timestamp = 0; + + in_fd = fopen(in_file, "r"); + if (in_fd == NULL) { + fprintf(stderr, "error: unable to open %s for reading %d\n", + in_file, errno); + return -EIO; + } + + if (out_file == NULL) + goto trace; + + out_fd = fopen(out_file, "w"); + if (out_fd == NULL) { + fprintf(stderr, "error: unable to open %s for writing %d\n", + out_file, errno); + } + +trace: + fprintf(stdout, "using %2.2fMHz timestamp clock\n", clk); + + while (1) { + count = fread(&tmp[0], 1, TRACE_BLOCK_SIZE, in_fd); + if (count != TRACE_BLOCK_SIZE) + break; + + if (addr < offset) { + addr += TRACE_BLOCK_SIZE; + continue; + } + + val = *((uint64_t*)tmp); + + for (i = 0; i < TRACE_BLOCK_SIZE / 2; i++) { + c = tmp[i]; + tmp[i] = tmp[TRACE_BLOCK_SIZE - i - 1]; + tmp[TRACE_BLOCK_SIZE - i - 1] = c; + } + + if (val == 0) + break; + + show_trace(val, addr, &timestamp, clk); + + if (out_fd) { + count = fwrite(&tmp[0], 1, TRACE_BLOCK_SIZE, out_fd); + if (count != TRACE_BLOCK_SIZE) + break; + } + + addr += TRACE_BLOCK_SIZE; + } + + return 0; +} + static void show_debug(uint32_t val, uint32_t addr) { printf("debug: 0x%x (%2.2d) = \t0x%8.8x \t(%8.8d) \t|%c%c%c%c|\n", @@ -233,7 +281,7 @@ static const char *debugfs[] = { static int snapshot(const char *name) { - const char *path = "/sys/kernel/debug"; + const char *path = "/sys/kernel/debug/sof"; uint32_t val, addr; char pinname[64], poutname[64], buffer[128]; FILE *in_fd, *out_fd; @@ -290,15 +338,15 @@ static int snapshot(const char *name) int main(int argc, char *argv[]) { - int opt, count; + int opt, count, trace = 0; const char * out_file = NULL, *in_file = "/sys/kernel/debug/sof/mbox"; FILE *in_fd = NULL, *out_fd = NULL; char c, tmp[8] = {0}; uint64_t addr = 0, val, timestamp = 0, align = 4, i; - float clk = 19.2f; - uint32_t is_dma_trace = 0; + double clk = 19.2; + int title_dbg_done = 0, title_exp_done = 0; - while ((opt = getopt(argc, argv, "ho:i:s:m:c:t:")) != -1) { + while ((opt = getopt(argc, argv, "ho:i:s:m:c:t")) != -1) { switch (opt) { case 'o': out_file = optarg; @@ -307,9 +355,7 @@ int main(int argc, char *argv[]) in_file = optarg; break; case 't': - in_file = optarg; - is_dma_trace = 1; - align = 8; + trace = 1; break; case 'c': clk = atof(optarg); @@ -322,6 +368,10 @@ int main(int argc, char *argv[]) } } + /* trace requested ? */ + if (trace) + return trace_read("/sys/kernel/debug/sof/trace", out_file, clk, 0); + /* open infile for reading */ in_fd = fopen(in_file, "r"); if (in_fd == NULL) { @@ -359,17 +409,21 @@ convert: tmp[align - i - 1] = c; } - if (is_dma_trace) - show_trace(val, addr, &timestamp, clk, align * 2); - else if (addr >= MAILBOX_TRACE_OFFSET && - addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) - show_trace(val, addr, &timestamp, clk, align * 2); - else if (addr >= MAILBOX_DEBUG_OFFSET && - addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) + if (addr >= MAILBOX_DEBUG_OFFSET && + addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) { + + if (!title_dbg_done++) + fprintf(stdout, "\nDebug log:\n"); + show_debug(val, addr); - else if (addr >= MAILBOX_EXCEPTION_OFFSET && - addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) + } else if (addr >= MAILBOX_EXCEPTION_OFFSET && + addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) { + + if (!title_exp_done++) + fprintf(stdout, "\nException log:\n"); + show_exception(val, addr); + } if (out_fd) { count = fwrite(&tmp[0], 1, align, out_fd); @@ -380,6 +434,11 @@ convert: addr += align; } + /* read debug */ + fprintf(stdout, "\nError log:\n"); + trace_read("/sys/kernel/debug/sof/mbox", out_file, clk, + MAILBOX_TRACE_OFFSET); + /* close files */ fclose(in_fd); if (out_fd) -- 1.9.1

1 0

[Sound-open-firmware] [PATCH] Use new output format for 64-bit timestamp.
by yan.wang＠linux.intel.com 13 Oct '17

13 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Use [second.microsecond] for 64-bit timestamp. 2. Keep previous format for 32-bit timestamp. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- rmbox/rmbox.c | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index 638158c..d650d30 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -113,6 +113,9 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c uint32_t class; uint64_t delta = val - *timestamp; float fdelta = to_usecs(delta, clk); + float us = 0.0f; + uint64_t s = 0, ms = 0; + uint64_t ds = 0, dms = 0; /* timestamp or value ? */ if ((addr % align) == 0) { @@ -128,9 +131,21 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c fdelta = to_usecs(delta, clk); } - printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", - (uint64_t)val, to_usecs(val, clk), - (uint64_t)delta, fdelta); + if (align == 8) { + /* 32-bit timestamp */ + printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", + (uint64_t)val, to_usecs(val, clk), + (uint64_t)delta, fdelta); + } else { + /* 64-bit timestamp */ + us = to_usecs(val, clk); + s = us / 1000000; + ms = us / 1000 - s * 1000; + ds = fdelta / 1000000; + dms = fdelta / 1000 - ds * 1000; + printf("trace.io: timestamp [%lu.%lu] \tdelta [%lu.%lu]\t", + s, ms, ds, dms); + } *timestamp = val; return; } -- 2.7.4

2 1

[Sound-open-firmware] [Sound-open-firmware-tools][PATCH] Add option "-t" to process DMA trace event with 64-bit tempstamp.
by yan.wang＠linux.intel.com 13 Oct '17

13 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Timestamp is changed to 64-bit width. 2. Trace event is still 32-bit. High 32-bit of 64-bit is ignored. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- rmbox/rmbox.c | 64 ++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 35 insertions(+), 29 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index 3ef6fb4..638158c 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -100,23 +100,22 @@ static void usage(char *name) exit(0); } -static float to_usecs(uint32_t time, float clk) +static float to_usecs(uint64_t time, float clk) { /* trace timestamp uses CPU system clock at default 25MHz ticks */ // TODO: support variable clock rates - return (float)time / clk; + return (double)time / clk; } -static void show_trace(uint32_t val, uint32_t addr, uint32_t *timestamp, float clk) +static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float clk, uint64_t align) { const char *trace; uint32_t class; - uint32_t delta = val - *timestamp; + uint64_t delta = val - *timestamp; float fdelta = to_usecs(delta, clk); /* timestamp or value ? */ - if ((addr % 8) == 0) { - + if ((addr % align) == 0) { /* buffer wrap ? */ if (val < *timestamp) { printf("----------------------------------------" @@ -129,9 +128,9 @@ static void show_trace(uint32_t val, uint32_t addr, uint32_t *timestamp, float c fdelta = to_usecs(delta, clk); } - printf("trace.io: timestamp 0x%8.8x (%2.2f us) \tdelta 0x%8.8x (%2.2f us)\t", - (uint32_t)val, to_usecs(val, clk), - (uint32_t)delta, fdelta); + printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", + (uint64_t)val, to_usecs(val, clk), + (uint64_t)delta, fdelta); *timestamp = val; return; } @@ -279,11 +278,12 @@ int main(int argc, char *argv[]) int opt, count; const char * out_file = NULL, *in_file = "/sys/kernel/debug/sof/mbox"; FILE *in_fd = NULL, *out_fd = NULL; - char c, tmp[4] = {0}; - uint32_t addr = 0, val, timestamp = 0; + char c, tmp[8] = {0}; + uint64_t addr = 0, val, timestamp = 0, align = 4, i; float clk = 19.2f; + uint32_t is_dma_trace = 0; - while ((opt = getopt(argc, argv, "ho:i:s:m:c:")) != -1) { + while ((opt = getopt(argc, argv, "ho:i:s:m:c:t:")) != -1) { switch (opt) { case 'o': out_file = optarg; @@ -291,6 +291,11 @@ int main(int argc, char *argv[]) case 'i': in_file = optarg; break; + case 't': + in_file = optarg; + is_dma_trace = 1; + align = 8; + break; case 'c': clk = atof(optarg); break; @@ -327,36 +332,37 @@ convert: fprintf(stdout, "using %2.2fMHz timestamp clock\n", clk); while (1) { - count = fread(&tmp[0], 1, 4, in_fd); - if (count != 4) + count = fread(&tmp[0], 1, align, in_fd); + if (count != align) break; - val = *((uint32_t*)tmp); + val = *((uint64_t*)tmp); - c = tmp[0]; - tmp[0] = tmp[3]; - tmp[3] = c; - c = tmp[1]; - tmp[1] = tmp[2]; - tmp[2] = c; + for (i = 0; i < align / 2; i++) { + c = tmp[i]; + tmp[i] = tmp[align - i - 1]; + tmp[align - i - 1] = c; + } - if (addr >= MAILBOX_TRACE_OFFSET && - addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) - show_trace(val, addr, &timestamp, clk); + if (is_dma_trace) + show_trace(val, addr, &timestamp, clk, align * 2); + else if (addr >= MAILBOX_TRACE_OFFSET && + addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) + show_trace(val, addr, &timestamp, clk, align * 2); else if (addr >= MAILBOX_DEBUG_OFFSET && - addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) + addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) show_debug(val, addr); else if (addr >= MAILBOX_EXCEPTION_OFFSET && - addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) + addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) show_exception(val, addr); if (out_fd) { - count = fwrite(&tmp[0], 1, 4, out_fd); - if (count != 4) + count = fwrite(&tmp[0], 1, align, out_fd); + if (count != align) break; } - addr += 4; + addr += align; } /* close files */ -- 2.7.4

3 2

[Sound-open-firmware] [PATCH 1/2] Modify API of DMA tracing for forwading trace to DMA buffer.
by yan.wang＠linux.intel.com 12 Oct '17

12 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Change trace data coping API for current trace event data including 64-bit timestamp. 2. Remove trace event of DMA tracing for avoiding dead lock. 3. If DMA tracing is ready, send event data when the data size is half full or the DMA tracing buffer arrive at the end. Otherwise, overwrite the data directly. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/audio/dma-trace.c | 22 ++++++++-------------- src/include/reef/audio/dma-trace.h | 3 ++- src/ipc/ipc.c | 1 + 3 files changed, 11 insertions(+), 15 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index d725fcf..123853c 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -93,8 +93,6 @@ static void trace_send(struct dma_trace_data *d) d->host_offset += size; buffer->r_ptr += size; - - trace_buffer("dts"); } static uint64_t trace_work(void *data, uint64_t delay) @@ -150,24 +148,20 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, void dma_trace_config_ready(struct dma_trace_data *d) { work_schedule_default(&d->dmat_work, DMA_TRACE_US); + d->ready = 1; } -void dtrace_event(char *e) +void dtrace_event(const char *e, uint32_t length) { struct dma_trace_buf *buffer = NULL; - int length = rstrlen(e); int margin = 0; - if (trace_data == NULL || length < 1) { - trace_buffer_error("ele"); + if (trace_data == NULL || length < 1) return; - } buffer = &trace_data->dmatb; - if (buffer == NULL) { - trace_buffer_error("ele"); + if (buffer == NULL) return; - } margin = buffer->end_addr - buffer->w_ptr; @@ -178,17 +172,17 @@ void dtrace_event(char *e) memcpy(buffer->w_ptr, e, margin); buffer->w_ptr += margin; - trace_send(trace_data); + if(trace_data->ready) + trace_send(trace_data); + buffer->w_ptr = buffer->r_ptr = buffer->addr; bzero(buffer->addr, buffer->size); memcpy(buffer->w_ptr, e + margin, length - margin); buffer->w_ptr += length -margin; - - trace_buffer("ebs"); } length = buffer->w_ptr - buffer->r_ptr; - if (length >= (DMA_TRACE_LOCAL_SIZE / 2)) + if (trace_data->ready && length >= (DMA_TRACE_LOCAL_SIZE / 2)) trace_send(trace_data); } diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 9ee88a0..438fd2f 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -57,6 +57,7 @@ struct dma_trace_data { int32_t host_offset; uint32_t host_size; struct work dmat_work; + uint32_t ready; }; int dma_trace_init(struct dma_trace_data *d); @@ -64,6 +65,6 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, uint32_t host_size); void dma_trace_config_ready(struct dma_trace_data *d); -void dtrace_event(char *e); +void dtrace_event(const char *e, uint32_t size); #endif diff --git a/src/ipc/ipc.c b/src/ipc/ipc.c index 6c40d10..05de838 100644 --- a/src/ipc/ipc.c +++ b/src/ipc/ipc.c @@ -350,6 +350,7 @@ int ipc_init(struct reef *reef) /* init ipc data */ reef->ipc = rzalloc(RZONE_SYS, RFLAGS_NONE, sizeof(*reef->ipc)); reef->ipc->comp_data = rzalloc(RZONE_SYS, RFLAGS_NONE, SOF_IPC_MSG_MAX_SIZE); + reef->ipc->dmat.ready = 0; list_init(&reef->ipc->comp_list); -- 2.7.4

2 1

[Sound-open-firmware] [PATCH] Use "const char*" instead of "char*" in rstrlen().
by yan.wang＠linux.intel.com 12 Oct '17

12 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> It is unnecessary to use "char*" for calculating string length. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/include/reef/alloc.h | 2 +- src/lib/lib.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/include/reef/alloc.h b/src/include/reef/alloc.h index a589959..4e8a630 100644 --- a/src/include/reef/alloc.h +++ b/src/include/reef/alloc.h @@ -82,7 +82,7 @@ void rbfree(void *ptr); /* utility */ void bzero(void *s, size_t n); void *memset(void *s, int c, size_t n); -int rstrlen(char *s); +int rstrlen(const char *s); /* Heap save/restore contents and context for PM D0/D3 events */ uint32_t mm_pm_context_size(void); diff --git a/src/lib/lib.c b/src/lib/lib.c index a1c9933..7e4c09d 100644 --- a/src/lib/lib.c +++ b/src/lib/lib.c @@ -99,9 +99,9 @@ void *memset(void *s, int c, size_t n) } /* generic strlen - TODO: can be optimsed for ARCH ? */ -int rstrlen(char *s) +int rstrlen(const char *s) { - char *p = s; + const char *p = s; while(*p++ != 0); return (p - s) - 1; -- 2.7.4

2 1

[Sound-open-firmware] [PATCH] ssp: pause: fix pause/release logic
by Liam Girdwood 12 Oct '17

12 Oct '17

SSP can either be in paused or prepared state during stream pause depending on the state of the other SSP data direction. Make sure this is taken into account. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/drivers/ssp.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/drivers/ssp.c b/src/drivers/ssp.c index a472974..404abd8 100644 --- a/src/drivers/ssp.c +++ b/src/drivers/ssp.c @@ -356,7 +356,8 @@ static int ssp_trigger(struct dai *dai, int cmd, int direction) ssp_start(dai, direction); break; case COMP_CMD_RELEASE: - if (ssp->state[direction] == COMP_STATE_PAUSED) + if (ssp->state[direction] == COMP_STATE_PAUSED || + ssp->state[direction] == COMP_STATE_PREPARE) ssp_start(dai, direction); break; case COMP_CMD_STOP: -- 2.11.0

1 10

[Sound-open-firmware] [PATCH] SRC: Support block sizes near or equal to period length
by Seppo Ingalsuo 11 Oct '17

11 Oct '17

This patch decouples the first and second stage in two phase conversion that is used for out/in rate fractions with high numerator or denominator value. For e.g. 44.1 -> 48 kHz 160/147 fraction the 1st 8/7 stage and 2nd 20/21 stage are executed number of times close to period length in time used for the scheduling rate. The number of consumed and produced samples per copy() is no more constant. The latency of 44.1 kHz is decreased about 2 ms and processing load is less variable. This patch removes mute feature due to non-compatibility with variable length data processing. It can be introduced later if needed as different implementation. The polyphase filter is also optimized slightly. More optimizations will follow. Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo(a)linux.intel.com> --- src/audio/src.c | 354 +++++++++++++++++++++---------------------- src/audio/src_core.c | 412 ++++++++++++++++++++++++--------------------------- src/audio/src_core.h | 27 +++- 3 files changed, 395 insertions(+), 398 deletions(-) diff --git a/src/audio/src.c b/src/audio/src.c index de84149..993c76b 100644 --- a/src/audio/src.c +++ b/src/audio/src.c @@ -56,170 +56,150 @@ /* src component private data */ struct comp_data { struct polyphase_src src[PLATFORM_MAX_CHANNELS]; + struct src_param param; int32_t *delay_lines; uint32_t sink_rate; uint32_t source_rate; - uint32_t period_bytes; /* sink period */ - int scratch_length; /* Buffer for stage1-stage2 */ + int32_t *sbuf_w_ptr; + int32_t *sbuf_r_ptr; + int sbuf_avail; int sign_extend_s24; /* Set if need to copy sign bit to b24..b31 */ - void (*src_func)(struct comp_dev *dev, + void (* src_func)(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, - int source_frames); + size_t *consumed, + size_t *produced); }; -/* Common mute function for 2s and 1s SRC. This preserves the same - * buffer consume and produce pattern as normal operation. - */ -static void src_muted_s32(struct comp_buffer *source, struct comp_buffer *sink, - int blk_in, int blk_out, int nch, int source_frames) +/* Fallback function */ +static void fallback_s32(struct comp_dev *dev, struct comp_buffer *source, + struct comp_buffer *sink, size_t *bytes_read, size_t *bytes_written) { - - int i; - int32_t *dest = (int32_t *) sink->w_ptr; - int32_t *end = (int32_t *) sink->end_addr; - int n_read = 0; - int n_max; - int n; - int n_written = 0; - - for (i = 0; i < source_frames - blk_in + 1; i += blk_in) { - n_max = end - dest; - n = nch*blk_out; - if (n < n_max) { - bzero(dest, n * sizeof(int32_t)); - dest += n; - } else { - /* Also case n_max == n is done here */ - bzero(dest, n_max * sizeof(int32_t)); - dest = (int32_t *) sink->addr; - bzero(dest, (n - n_max) * sizeof(int32_t)); - dest += n - n_max; - } - n_read += nch*blk_in; - n_written += nch*blk_out; - } -} - -/* Fallback function to just output muted samples and advance - * pointers. Note that a buffer that is not having integer number of - * frames in a period will drift since there is no similar blk in/out - * check as for SRC. - */ -static void fallback_s32(struct comp_dev *dev, - struct comp_buffer *source, - struct comp_buffer *sink, - int source_frames) -{ - - struct comp_data *cd = comp_get_drvdata(dev); - int nch = dev->params.channels; - int blk_in = cd->src[0].blk_in; - int blk_out = cd->src[0].blk_out; - - src_muted_s32(source, sink, blk_in, blk_out, nch, source_frames); - + *bytes_read = 0; + *bytes_written = 0; } /* Normal 2 stage SRC */ static void src_2s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, - int source_frames) + size_t *bytes_read, size_t *bytes_written) { - int i; - int j; struct polyphase_src *s; + struct src_stage_prm s1; + struct src_stage_prm s2; + int j; struct comp_data *cd = comp_get_drvdata(dev); - int blk_in = cd->src[0].blk_in; - int blk_out = cd->src[0].blk_out; - int n_times1 = cd->src[0].stage1_times; - int n_times2 = cd->src[0].stage2_times; - int nch = dev->params.channels; int32_t *dest = (int32_t *) sink->w_ptr; int32_t *src = (int32_t *) source->r_ptr; - struct src_stage_prm s1; - struct src_stage_prm s2; + int32_t *sbuf_addr = cd->delay_lines; + int32_t *sbuf_end_addr = &cd->delay_lines[cd->param.sbuf_length]; + int32_t sbuf_size = cd->param.sbuf_length * sizeof(int32_t); + const int nch = dev->params.channels; + const int s1_blk_in = cd->src[0].stage1->blk_in * nch; + const int s1_blk_out = cd->src[0].stage1->blk_out * nch; + const int s2_blk_in = cd->src[0].stage2->blk_in * nch; + const int s2_blk_out = cd->src[0].stage2->blk_out * nch; + int sbuf_free = cd->param.sbuf_length - cd->sbuf_avail; + int source_check = (source->avail >> 2) - s1_blk_in; /* for int32_t */ + int sink_check = (sink->free >> 2) - s2_blk_out; /* For int32_t */ int n_read = 0; int n_written = 0; + int n1 = 0; + int n2 = 0; - if (cd->src[0].mute) { - src_muted_s32(source, sink, blk_in, blk_out, nch, source_frames); - return; - } - - s1.times = n_times1; + s1.times = 1; s1.x_end_addr = source->end_addr; s1.x_size = source->size; s1.x_inc = nch; - s1.y_end_addr = &cd->delay_lines[cd->scratch_length]; - s1.y_size = cd->scratch_length * sizeof(int32_t); - s1.y_inc = 1; - - s2.times = n_times2; - s2.x_end_addr = &cd->delay_lines[cd->scratch_length]; - s2.x_size = cd->scratch_length * sizeof(int32_t); - s2.x_inc = 1; + s1.y_end_addr = sbuf_end_addr; + s1.y_size = sbuf_size; + s1.y_inc = nch; + + s2.times = 1; + s2.x_end_addr = sbuf_end_addr; + s2.x_size = sbuf_size; + s2.x_inc = nch; s2.y_end_addr = sink->end_addr; s2.y_size = sink->size; s2.y_inc = nch; - s1.x_rptr = src + nch - 1; - s2.y_wptr = dest + nch - 1; - - for (j = 0; j < nch; j++) { - s = &cd->src[j]; /* Point to src[] for this channel */ - s1.x_rptr = src++; - s2.y_wptr = dest++; - s1.state = &s->state1; - s1.stage = s->stage1; - s2.state = &s->state2; - s2.stage = s->stage2; - - for (i = 0; i < source_frames - blk_in + 1; i += blk_in) { - /* Reset output to buffer start, read interleaved */ - s1.y_wptr = cd->delay_lines; - s2.x_rptr = cd->delay_lines; - if (cd->sign_extend_s24) { + /* 1st stage runs once a long multiplied length block. + * The stage buffer much be large enough to fit one s1 output block + * plus one s2 input block plus jitter in s2 consumption. + */ + while ((n1 < cd->param.stage1_times_max) + && (n_read <= source_check) + && (sbuf_free >= s1_blk_out)) { + for (j = 0; j < nch; j++) { + s = &cd->src[j]; /* Point to src[] for this channel */ + s1.x_rptr = src++; + s1.y_wptr = cd->sbuf_w_ptr++; + src_circ_inc_wrap(&src, source->end_addr, source->size); + src_circ_inc_wrap(&cd->sbuf_w_ptr, sbuf_end_addr, sbuf_size); + s1.state = &s->state1; + s1.stage = s->stage1; + if (cd->sign_extend_s24) src_polyphase_stage_cir_s24(&s1); - src_polyphase_stage_cir_s24(&s2); - } else { + else src_polyphase_stage_cir(&s1); + + } + n_read += s1_blk_in; + cd->sbuf_avail += s1_blk_out; + sbuf_free -= s1_blk_out; + src = s1.x_rptr - nch + 1; + cd->sbuf_w_ptr = s1.y_wptr - nch + 1; + src_circ_dec_wrap(&src, source->addr, source->size); + src_circ_dec_wrap(&cd->sbuf_w_ptr, sbuf_addr, sbuf_size); + n1++; + } + + /* 2nd stage runs as many min size blocks as buffers allow */ + while ((n2 < cd->param.stage2_times_max) + && (cd->sbuf_avail >= s2_blk_in) + && (n_written <= sink_check)) { + for (j = 0; j < nch; j++) { + s2.x_rptr = cd->sbuf_r_ptr++; + s2.y_wptr = dest++; + src_circ_inc_wrap(&cd->sbuf_r_ptr, sbuf_end_addr, sbuf_size); + src_circ_inc_wrap(&dest, sink->end_addr, sink->size); + s = &cd->src[j]; /* Point to src[] for this channel */ + s2.state = &s->state2; + s2.stage = s->stage2; + if (cd->sign_extend_s24) + src_polyphase_stage_cir_s24(&s2); + else src_polyphase_stage_cir(&s2); - } - n_read += blk_in; - n_written += blk_out; } + cd->sbuf_r_ptr = s2.x_rptr - nch + 1; + dest = s2.y_wptr - nch + 1; + src_circ_dec_wrap(&cd->sbuf_r_ptr, sbuf_addr, sbuf_size); + src_circ_dec_wrap(&dest, sink->addr, sink->size); + n_written += s2_blk_out; + cd->sbuf_avail -= s2_blk_in; + n2++; } + *bytes_read = sizeof(int32_t) * n_read; + *bytes_written = sizeof(int32_t) * n_written; } /* 1 stage SRC for simple conversions */ static void src_1s_s32_default(struct comp_dev *dev, struct comp_buffer *source, struct comp_buffer *sink, - int source_frames) + size_t *bytes_read, size_t *bytes_written) { - int i; - int j; struct polyphase_src *s; - + struct src_stage_prm s1; + int j; struct comp_data *cd = comp_get_drvdata(dev); - int blk_in = cd->src[0].blk_in; - int blk_out = cd->src[0].blk_out; - int n_times = cd->src[0].stage1_times; - int nch = dev->params.channels; int32_t *dest = (int32_t *) sink->w_ptr; int32_t *src = (int32_t *) source->r_ptr; + int nch = dev->params.channels; int n_read = 0; int n_written = 0; - struct src_stage_prm s1; - if (cd->src[0].mute) { - src_muted_s32(source, sink, blk_in, blk_out, nch, - source_frames); - return; - } - - s1.times = n_times; + s1.times = cd->param.stage1_times; s1.x_end_addr = source->end_addr; s1.x_size = source->size; s1.x_inc = nch; @@ -233,20 +213,56 @@ static void src_1s_s32_default(struct comp_dev *dev, s = &cd->src[j]; /* Point to src for this channel */ s1.x_rptr = src++; s1.y_wptr = dest++; + src_circ_inc_wrap(&src, source->end_addr, source->size); + src_circ_inc_wrap(&dest, sink->end_addr, sink->size); s1.state = &s->state1; s1.stage = s->stage1; + if (cd->sign_extend_s24) + src_polyphase_stage_cir_s24(&s1); + else + src_polyphase_stage_cir(&s1); - for (i = 0; i + blk_in - 1 < source_frames; i += blk_in) { - if (cd->sign_extend_s24) - src_polyphase_stage_cir_s24(&s1); - else - src_polyphase_stage_cir(&s1); + n_read += cd->param.blk_in; + n_written += cd->param.blk_out; + } + *bytes_read = n_read * sizeof(int32_t); + *bytes_written = n_written * sizeof(int32_t); +} - n_read += blk_in; - n_written += blk_out; - } +/* A fast copy function for same in and out rate */ +static void src_copy_s32_default(struct comp_dev *dev, + struct comp_buffer *source, struct comp_buffer *sink, + size_t *bytes_read, size_t *bytes_written) +{ + struct comp_data *cd = comp_get_drvdata(dev); + int32_t *src = (int32_t *) source->r_ptr; + int32_t *snk = (int32_t *) sink->w_ptr; + int nch = dev->params.channels; + int frames = cd->param.blk_in; + int n; + int n_wrap_src; + int n_wrap_snk; + int n_wrap_min; + int n_copy; + + n = frames * nch; + while (n > 0) { + n_wrap_src = (int32_t *) source->end_addr - src; + n_wrap_snk = (int32_t *) sink->end_addr - snk; + n_wrap_min = (n_wrap_src < n_wrap_snk) ? n_wrap_src : n_wrap_snk; + n_copy = (n < n_wrap_min) ? n : n_wrap_min; + memcpy(snk, src, n_copy * sizeof(int32_t)); + + /* Update and check both source and destination for wrap */ + n -= n_copy; + src += n_copy; + snk += n_copy; + src_circ_inc_wrap(&src, source->end_addr, source->size); + src_circ_inc_wrap(&snk, sink->end_addr, sink->size); } + *bytes_read = frames * nch * sizeof(int32_t); + *bytes_written = frames * nch * sizeof(int32_t); } static struct comp_dev *src_new(struct sof_ipc_comp *comp) @@ -313,7 +329,6 @@ static int src_params(struct comp_dev *dev) struct comp_data *cd = comp_get_drvdata(dev); struct comp_buffer *sink; struct comp_buffer *source; - struct src_alloc need; size_t delay_lines_size; uint32_t source_rate; uint32_t sink_rate; @@ -359,7 +374,7 @@ static int src_params(struct comp_dev *dev) } /* Allocate needed memory for delay lines */ - err = src_buffer_lengths(&need, source_rate, sink_rate, + err = src_buffer_lengths(&cd->param, source_rate, sink_rate, params->channels, dev->frames, frames_is_for_source); if (err < 0) { trace_src_error("sr1"); @@ -370,7 +385,7 @@ static int src_params(struct comp_dev *dev) return err; } - delay_lines_size = sizeof(int32_t) * need.total; + delay_lines_size = sizeof(int32_t) * cd->param.total; if (delay_lines_size == 0) { trace_src_error("sr2"); return -EINVAL; @@ -389,17 +404,24 @@ static int src_params(struct comp_dev *dev) /* Clear all delay lines here */ memset(cd->delay_lines, 0, delay_lines_size); - cd->scratch_length = need.scratch; - buffer_start = cd->delay_lines + need.scratch; + buffer_start = cd->delay_lines + cd->param.sbuf_length; /* Initize SRC for actual sample rate */ nch = MIN(params->channels, PLATFORM_MAX_CHANNELS); for (i = 0; i < nch; i++) { - n = src_polyphase_init(&cd->src[i], &need, buffer_start); - buffer_start += need.single_src; + n = src_polyphase_init(&cd->src[i], &cd->param, buffer_start); + buffer_start += cd->param.single_src; } + /* Reset stage buffer */ + cd->sbuf_r_ptr = cd->delay_lines; + cd->sbuf_w_ptr = cd->delay_lines; + cd->sbuf_avail = 0; + switch (n) { + case 0: + cd->src_func = src_copy_s32_default; /* 1:1 fast copy */ + break; case 1: cd->src_func = src_1s_s32_default; /* Simpler 1 stage SRC */ break; @@ -422,19 +444,13 @@ static int src_params(struct comp_dev *dev) */ dev->frame_bytes = dev->params.sample_container_bytes * dev->params.channels; - cd->period_bytes = dev->frames * dev->frame_bytes; /* The downstream buffer must be at least length of blk_out plus - * dev->frames and an integer multiple of dev->frames. The + * a dev->frames and an integer multiple of dev->frames. The * buffer_set_size will return an error if the required length would * be too long. */ - q = need.blk_out / dev->frames; - if (q * (int)dev->frames < need.blk_out) - ++q; - - if (q * (int)dev->frames < need.blk_out + (int)dev->frames) - ++q; + q = src_ceil_divide(cd->param.blk_out, (int) dev->frames) + 1; /* Configure downstream buffer */ sink = list_first_item(&dev->bsink_list, struct comp_buffer, @@ -452,7 +468,7 @@ static int src_params(struct comp_dev *dev) /* Check that source buffer has sufficient size */ source = list_first_item(&dev->bsource_list, struct comp_buffer, sink_list); - if (source->size < need.blk_in * dev->frame_bytes) { + if (source->size < cd->param.blk_in * dev->frame_bytes) { trace_src_error("eSy"); return -EINVAL; } @@ -463,28 +479,8 @@ static int src_params(struct comp_dev *dev) static int src_ctrl_cmd(struct comp_dev *dev, struct sof_ipc_ctrl_data *cdata) { - struct comp_data *cd = comp_get_drvdata(dev); - int i; - - switch (cdata->cmd) { - case SOF_CTRL_CMD_MUTE: - trace_src("SMu"); - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_mute(&cd->src[i]); - - break; - case SOF_CTRL_CMD_UNMUTE: - trace_src("SUm"); - for (i = 0; i < PLATFORM_MAX_CHANNELS; i++) - src_polyphase_unmute(&cd->src[i]); - - break; - default: - trace_src_error("ec1"); - return -EINVAL; - } - - return 0; + trace_src_error("ec1"); + return -EINVAL; } /* used to pass standard and bespoke commands (with data) to component */ @@ -513,8 +509,8 @@ static int src_copy(struct comp_dev *dev) struct comp_buffer *sink; int need_source; int need_sink; - int blk_in; - int blk_out; + size_t consumed = 0; + size_t produced = 0; trace_comp("SRC"); @@ -525,23 +521,29 @@ static int src_copy(struct comp_dev *dev) source_list); /* Calculate needed amount of source buffer and sink buffer - * for one SRC run. + * for one SRC run. The blk_in and blk are minimum condition to + * call copy. Copy can consume or produce a slightly larger block + * with the rates where block sizes are not constant. E.g. for + * 1 ms schduling the blocks can be under or above 1 ms when the + * SRC interal block size constraint prevents exact 1 ms blocks. */ - blk_in = src_polyphase_get_blk_in(&cd->src[0]); - blk_out = src_polyphase_get_blk_out(&cd->src[0]); - need_source = blk_in * dev->frame_bytes; - need_sink = blk_out * dev->frame_bytes; + need_source = cd->param.blk_in * dev->frame_bytes; + need_sink = cd->param.blk_out * dev->frame_bytes; - /* Run as many times as buffers allow */ - while (((int) source->avail >= need_source) && ((int) sink->free >= need_sink)) { + /* Run SRC function if buffers avail and free allow */ + if (((int) source->avail >= need_source) && ((int) sink->free >= need_sink)) { /* Run src */ - cd->src_func(dev, source, sink, blk_in); + cd->src_func(dev, source, sink, &consumed, &produced); - /* calc new free and available */ - comp_update_buffer_consume(source, need_source); - comp_update_buffer_produce(sink, need_sink); - } + /* Calc new free and available if data was processed. These + * functions must not be called with 0 consumed/produced. + */ + if (consumed > 0) + comp_update_buffer_consume(source, consumed); + if (produced > 0) + comp_update_buffer_produce(sink, produced); + } return 0; } diff --git a/src/audio/src_core.c b/src/audio/src_core.c index 8098d87..4ee2efd 100644 --- a/src/audio/src_core.c +++ b/src/audio/src_core.c @@ -51,6 +51,18 @@ int sof_rates[SOF_RATES_LENGTH] = {8000, 11025, 12000, 16000, 18900, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000}; +/* Calculate ceil() for integer division */ +int src_ceil_divide(int a, int b) +{ + int c; + + c = a / b; + if (c * b < a) + c++; + + return c; +} + /* Calculates the needed FIR delay line length */ static int src_fir_delay_length(struct src_stage *s) { @@ -62,7 +74,7 @@ static int src_fir_delay_length(struct src_stage *s) static int src_out_delay_length(struct src_stage *s) { - return (s->num_of_subfilters - 1) * s->odm + 1; + return 1 + (s->num_of_subfilters - 1) * s->odm; } /* Returns index of a matching sample rate */ @@ -108,16 +120,16 @@ int32_t src_output_rates(void) } /* Calculates buffers to allocate for a SRC mode */ -int src_buffer_lengths(struct src_alloc *a, int fs_in, int fs_out, int nch, - int max_frames, int max_frames_is_for_source) +int src_buffer_lengths(struct src_param *a, int fs_in, int fs_out, int nch, + int frames, int frames_is_for_source) { - int blk_in; - int blk_out; - int k; - int s1_times; - int s2_times; struct src_stage *stage1; struct src_stage *stage2; + int k; + int q; + int den; + int num; + int frames2; a->idx_in = src_find_fs(src_in_fs, NUM_IN_FS, fs_in); a->idx_out = src_find_fs(src_out_fs, NUM_OUT_FS, fs_out); @@ -137,46 +149,59 @@ int src_buffer_lengths(struct src_alloc *a, int fs_in, int fs_out, int nch, a->fir_s1 = src_fir_delay_length(stage1); a->out_s1 = src_out_delay_length(stage1); - k = gcd(stage1->blk_out, stage2->blk_in); - s1_times = stage2->blk_in / k; - s2_times = s1_times * stage1->blk_out / stage2->blk_in; - blk_in = s1_times * stage1->blk_in; - blk_out = s2_times * stage2->blk_out; - /* Find out how many additional times the SRC can be executed while having block size less or equal to max_frames. */ - if (max_frames_is_for_source) { - k = max_frames / blk_in; + if (frames_is_for_source) { + /* Times that stage1 needs to run to input length of frames */ + a->stage1_times_max = src_ceil_divide(frames, stage1->blk_in); + q = frames / stage1->blk_in; + a->stage1_times = MAX(q, 1); + a->blk_in = a->stage1_times * stage1->blk_in; + + /* Times that stage2 needs to run */ + den = stage2->blk_in * stage1->blk_in; + num = frames * stage2->blk_out * stage1->blk_out; + frames2 = src_ceil_divide(num, den); + a->stage2_times_max = src_ceil_divide(frames2, stage2->blk_out); + q = frames2 / stage2->blk_out; + a->stage2_times = MAX(q, 1); + a->blk_out = a->stage2_times * stage2->blk_out; } else { - k = max_frames / blk_out; + /* Times that stage2 needs to run to output length of frames */ + a->stage2_times_max = src_ceil_divide(frames, stage2->blk_out); + q = frames / stage2->blk_out; + a->stage2_times = MAX(q, 1); + a->blk_out = a->stage2_times * stage2->blk_out; + + /* Times that stage1 needs to run */ + num = frames * stage2->blk_in * stage1->blk_in; + den = stage2->blk_out * stage1->blk_out; + frames2 = src_ceil_divide(num, den); + a->stage1_times_max = src_ceil_divide(frames2, stage1->blk_in); + q = frames2 / stage1->blk_in; + a->stage1_times = MAX(q, 1); + a->blk_in = a->stage1_times * stage1->blk_in; } - /* Mininum k is 1, when 0 max_frames is less than block length. In - * that case need to check in src.c that sink/source size is large - * enough for at least one block. - */ - if (k < 1) - k = 1; - - a->blk_mult = k; - a->blk_in = blk_in * k; - a->blk_out = blk_out * k; - a->stage1_times = s1_times * k; - a->stage2_times = s2_times * k; - if (stage2->filter_length == 1) { a->fir_s2 = 0; a->out_s2 = 0; - a->scratch = 0; a->stage2_times = 0; + a->stage2_times_max = 0; + a->sbuf_length = 0; } else { a->fir_s2 = src_fir_delay_length(stage2); a->out_s2 = src_out_delay_length(stage2); - a->scratch = stage1->blk_out * s1_times * k; + /* 2x is an empirically tested length. Since the sink buffer + * capability to receive samples varies a shorter stage 2 output + * block will create a peak in internal buffer usage. + */ + a->sbuf_length = 2 * nch * stage1->blk_out * a->stage1_times_max; } + a->single_src = a->fir_s1 + a->fir_s2 + a->out_s1 + a->out_s2; - a->total = a->scratch + nch * a->single_src; + a->total = a->sbuf_length + nch * a->single_src; return 0; } @@ -194,7 +219,7 @@ static void src_state_reset(struct src_state *state) static int init_stages( struct src_stage *stage1, struct src_stage *stage2, - struct polyphase_src *src, struct src_alloc *res, + struct polyphase_src *src, struct src_param *p, int n, int32_t *delay_lines_start) { /* Clear FIR state */ @@ -204,29 +229,27 @@ static int init_stages( src->number_of_stages = n; src->stage1 = stage1; src->stage2 = stage2; + src->blk_in = p->blk_in; + src->blk_out = p->blk_out; if (n == 1) { - src->blk_in = stage1->blk_in * res->blk_mult; - src->blk_out = stage1->blk_out * res->blk_mult; - src->stage1_times = res->stage1_times; + src->stage1_times = p->stage1_times; src->stage2_times = 0; if (stage1->blk_out == 0) return -EINVAL; } else { - src->stage1_times = res->stage1_times; - src->stage2_times = res->stage2_times; - src->blk_in = res->blk_in; - src->blk_out = res->blk_out; + src->stage1_times = p->stage1_times; + src->stage2_times = p->stage2_times; } /* Delay line sizes */ - src->state1.fir_delay_size = res->fir_s1; - src->state1.out_delay_size = res->out_s1; + src->state1.fir_delay_size = p->fir_s1; + src->state1.out_delay_size = p->out_s1; src->state1.fir_delay = delay_lines_start; src->state1.out_delay = src->state1.fir_delay + src->state1.fir_delay_size; if (n > 1) { - src->state2.fir_delay_size = res->fir_s2; - src->state2.out_delay_size = res->out_s2; + src->state2.fir_delay_size = p->fir_s2; + src->state2.out_delay_size = p->out_s2; src->state2.fir_delay = src->state1.out_delay + src->state1.out_delay_size; src->state2.out_delay = @@ -251,7 +274,6 @@ static int init_stages( } return 0; - } void src_polyphase_reset(struct polyphase_src *src) @@ -269,7 +291,7 @@ void src_polyphase_reset(struct polyphase_src *src) src_state_reset(&src->state2); } -int src_polyphase_init(struct polyphase_src *src, struct src_alloc *res, +int src_polyphase_init(struct polyphase_src *src, struct src_param *p, int32_t *delay_lines_start) { int n_stages; @@ -277,23 +299,28 @@ int src_polyphase_init(struct polyphase_src *src, struct src_alloc *res, struct src_stage *stage1; struct src_stage *stage2; - if ((res->idx_in < 0) || (res->idx_out < 0)) { - src->blk_in = res->blk_in; - src->blk_out = res->blk_out; + if ((p->idx_in < 0) || (p->idx_out < 0)) { + src->blk_in = p->blk_in; + src->blk_out = p->blk_out; return -EINVAL; } /* Get setup for 2 stage conversion */ - stage1 = src_table1[res->idx_out][res->idx_in]; - stage2 = src_table2[res->idx_out][res->idx_in]; - ret = init_stages(stage1, stage2, src, res, 2, delay_lines_start); + stage1 = src_table1[p->idx_out][p->idx_in]; + stage2 = src_table2[p->idx_out][p->idx_in]; + ret = init_stages(stage1, stage2, src, p, 2, delay_lines_start); if (ret < 0) return -EINVAL; /* Get number of stages used for optimize opportunity. 2nd * stage length is one if conversion needs only one stage. + * If input and output rate is the same return 0 to + * use a simple copy function instead of 1 stage FIR with one + * tap. */ n_stages = (src->stage2->filter_length == 1) ? 1 : 2; + if (p->idx_in == p->idx_out) + n_stages = 0; /* If filter length for first stage is zero this is a deleted * mode from in/out matrix. Computing of such SRC mode needs @@ -311,14 +338,20 @@ int src_polyphase_init(struct polyphase_src *src, struct src_alloc *res, static inline void fir_part(int64_t *y, int ntaps, const int16_t c[], int *ic, int32_t d[], int *id) { - int64_t p; int n; + int64_t a = 0; /* Data is Q1.31, coef is Q1.15, product is Q2.46 */ - for (n = 0; n < ntaps; n++) { - p = (int64_t) c[(*ic)++] * d[(*id)--]; - *y += p; + for (n = 0; n < (ntaps >> 1); n++) { + a += (int64_t) c[*ic] * d[*id] + + (int64_t) c[*ic + 1] * d[*id - 1]; + *ic += 2; + *id -= 2; } + if (ntaps & 1) + a += (int64_t) c[(*ic)++] * d[(*id)--]; + + *y += a; } #else @@ -326,15 +359,20 @@ static inline void fir_part(int64_t *y, int ntaps, const int16_t c[], int *ic, static inline void fir_part(int64_t *y, int ntaps, const int32_t c[], int *ic, int32_t d[], int *id) { - int64_t p; int n; + int64_t a = 0; /* Data is Q8.24, coef is Q1.23, product is Q9.47 */ - for (n = 0; n < ntaps; n++) { - - p = (int64_t) c[(*ic)++] * d[(*id)--]; - *y += p; + for (n = 0; n < (ntaps >> 1); n++) { + a += (int64_t) c[*ic] * d[*id] + + (int64_t) c[*ic + 1] * d[*id - 1]; + *ic += 2; + *id -= 2; } + if (ntaps & 1) + a += (int64_t) c[(*ic)++] * d[(*id)--]; + + *y += a; } #endif @@ -367,7 +405,7 @@ static inline int32_t fir_filter( /* Q2.46 -> Q2.31, saturate to Q1.31 */ y = y >> (15 + shift); - return (int32_t) sat_int32(y); + return(int32_t) sat_int32(y); } #else @@ -398,12 +436,14 @@ static inline int32_t fir_filter( /* Q9.47 -> Q9.24, saturate to Q8.24 */ y = y >> (23 + shift); - return (int32_t) sat_int32(y); + return(int32_t) sat_int32(y); } #endif -void src_polyphase_stage_cir(struct src_stage_prm *s) +void src_polyphase_stage_cir(struct src_stage_prm * s) { + struct src_state *fir = s->state; + struct src_stage *cfg = s->stage; int n; int m; int f; @@ -412,109 +452,80 @@ void src_polyphase_stage_cir(struct src_stage_prm *s) int n_wrap_fir; int n_wrap_buf; int n_wrap_min; + int n_min; int32_t z; for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * s->stage->blk_in; + m = s->x_inc * cfg->blk_in; while (m > 0) { - n_wrap_fir = - (s->state->fir_delay_size - s->state->fir_wi) + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * s->x_inc; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; - if (m < n_wrap_min) { - /* No circular wrap need */ - while (m > 0) { - s->state->fir_delay[s->state->fir_wi++] - = *s->x_rptr; - s->x_rptr += s->x_inc; - m -= s->x_inc; - } - } else { - /* Wrap in n_wrap_min/x_inc samples */ - while (n_wrap_min > 0) { - s->state->fir_delay[s->state->fir_wi++] - = *s->x_rptr; - s->x_rptr += s->x_inc; - n_wrap_min -= s->x_inc; - m -= s->x_inc; - } - /* Check both */ - if (s->x_rptr >= s->x_end_addr) - s->x_rptr = (int32_t *) - ((size_t) s->x_rptr - s->x_size); - if (s->state->fir_wi - == s->state->fir_delay_size) - s->state->fir_wi = 0; + n_min = (m < n_wrap_min) ? m : n_wrap_min; + while (n_min > 0) { + fir->fir_delay[fir->fir_wi++] = *s->x_rptr; + s->x_rptr += s->x_inc; + n_min -= s->x_inc; + m -= s->x_inc; } + /* Check for wrap */ + src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); + if (fir->fir_wi == fir->fir_delay_size) + fir->fir_wi = 0; } /* Filter */ c = 0; - r = s->state->fir_wi - s->stage->blk_in - - (s->stage->num_of_subfilters - 1) * s->stage->idm; + r = fir->fir_wi - cfg->blk_in + - (cfg->num_of_subfilters - 1) * cfg->idm; if (r < 0) - r += s->state->fir_delay_size; - - s->state->out_wi = s->state->out_ri; - for (f = 0; f < s->stage->num_of_subfilters; f++) { - s->state->fir_ri = r; - z = fir_filter(s->state, s->stage->coefs, &c, - s->stage->subfilter_length, s->stage->shift); - r += s->stage->idm; - if (r > s->state->fir_delay_size - 1) - r -= s->state->fir_delay_size; - - s->state->out_delay[s->state->out_wi] = z; - s->state->out_wi += s->stage->odm; - if (s->state->out_wi > s->state->out_delay_size - 1) - s->state->out_wi -= s->state->out_delay_size; + r += fir->fir_delay_size; + + fir->out_wi = fir->out_ri; + for (f = 0; f < cfg->num_of_subfilters; f++) { + fir->fir_ri = r; + z = fir_filter(fir, cfg->coefs, &c, + cfg->subfilter_length, cfg->shift); + r += cfg->idm; + if (r >= fir->fir_delay_size) + r -= fir->fir_delay_size; + + fir->out_delay[fir->out_wi] = z; + fir->out_wi += cfg->odm; + if (fir->out_wi >= fir->out_delay_size) + fir->out_wi -= fir->out_delay_size; } /* Output */ - m = s->y_inc * s->stage->num_of_subfilters; + m = s->y_inc * cfg->num_of_subfilters; while (m > 0) { - n_wrap_fir = - (s->state->out_delay_size - s->state->out_ri) + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * s->y_inc; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; - if (m < n_wrap_min) { - /* No circular wrap need */ - while (m > 0) { - *s->y_wptr = s->state->out_delay[ - s->state->out_ri++]; - s->y_wptr += s->y_inc; - m -= s->y_inc; - } - } else { - /* Wrap in n_wrap_min/y_inc samples */ - while (n_wrap_min > 0) { - *s->y_wptr = s->state->out_delay[ - s->state->out_ri++]; - s->y_wptr += s->y_inc; - n_wrap_min -= s->y_inc; - m -= s->y_inc; - } - /* Check both */ - if (s->y_wptr >= s->y_end_addr) - s->y_wptr = - (int32_t *) - ((size_t) s->y_wptr - s->y_size); - - if (s->state->out_ri - == s->state->out_delay_size) - s->state->out_ri = 0; + n_min = (m < n_wrap_min) ? m : n_wrap_min; + while (n_min > 0) { + *s->y_wptr = fir->out_delay[fir->out_ri++]; + s->y_wptr += s->y_inc; + n_min -= s->y_inc; + m -= s->y_inc; } + /* Check wrap */ + src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); + if (fir->out_ri == fir->out_delay_size) + fir->out_ri = 0; } } } -void src_polyphase_stage_cir_s24(struct src_stage_prm *s) +void src_polyphase_stage_cir_s24(struct src_stage_prm * s) { + struct src_state *fir = s->state; + struct src_stage *cfg = s->stage; int n; int m; int f; @@ -523,113 +534,82 @@ void src_polyphase_stage_cir_s24(struct src_stage_prm *s) int n_wrap_fir; int n_wrap_buf; int n_wrap_min; - int32_t se; + int n_min; int32_t z; + int32_t se; for (n = 0; n < s->times; n++) { /* Input data */ - m = s->x_inc * s->stage->blk_in; + m = s->x_inc * cfg->blk_in; while (m > 0) { - n_wrap_fir = - (s->state->fir_delay_size - s->state->fir_wi) + n_wrap_fir = (fir->fir_delay_size - fir->fir_wi) * s->x_inc; n_wrap_buf = s->x_end_addr - s->x_rptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; - if (m < n_wrap_min) { - /* No circular wrap need */ - while (m > 0) { - se = *s->x_rptr << 8; - s->state->fir_delay[s->state->fir_wi++] - = se >> 8; - s->x_rptr += s->x_inc; - m -= s->x_inc; - } - } else { - /* Wrap in n_wrap_min/x_inc samples */ - while (n_wrap_min > 0) { - se = *s->x_rptr << 8; - s->state->fir_delay[s->state->fir_wi++] - = se >> 8; - s->x_rptr += s->x_inc; - n_wrap_min -= s->x_inc; - m -= s->x_inc; - } - /* Check both */ - if (s->x_rptr >= s->x_end_addr) - s->x_rptr = (int32_t *) - ((size_t) s->x_rptr - s->x_size); - if (s->state->fir_wi - == s->state->fir_delay_size) - s->state->fir_wi = 0; + n_min = (m < n_wrap_min) ? m : n_wrap_min; + while (n_min > 0) { + se = *s->x_rptr << 8; + fir->fir_delay[fir->fir_wi++] = se >> 8; + s->x_rptr += s->x_inc; + n_min -= s->x_inc; + m -= s->x_inc; } + /* Check for wrap */ + src_circ_inc_wrap(&s->x_rptr, s->x_end_addr, s->x_size); + if (fir->fir_wi == fir->fir_delay_size) + fir->fir_wi = 0; } /* Filter */ c = 0; - r = s->state->fir_wi - s->stage->blk_in - - (s->stage->num_of_subfilters - 1) * s->stage->idm; + r = fir->fir_wi - cfg->blk_in + - (cfg->num_of_subfilters - 1) * cfg->idm; if (r < 0) - r += s->state->fir_delay_size; - - s->state->out_wi = s->state->out_ri; - for (f = 0; f < s->stage->num_of_subfilters; f++) { - s->state->fir_ri = r; - z = fir_filter(s->state, s->stage->coefs, &c, - s->stage->subfilter_length, s->stage->shift); - r += s->stage->idm; - if (r > s->state->fir_delay_size - 1) - r -= s->state->fir_delay_size; - - s->state->out_delay[s->state->out_wi] = z; - s->state->out_wi += s->stage->odm; - if (s->state->out_wi > s->state->out_delay_size - 1) - s->state->out_wi -= s->state->out_delay_size; + r += fir->fir_delay_size; + + fir->out_wi = fir->out_ri; + for (f = 0; f < cfg->num_of_subfilters; f++) { + fir->fir_ri = r; + z = fir_filter(fir, cfg->coefs, &c, + cfg->subfilter_length, cfg->shift); + r += cfg->idm; + if (r >= fir->fir_delay_size) + r -= fir->fir_delay_size; + + fir->out_delay[fir->out_wi] = z; + fir->out_wi += cfg->odm; + if (fir->out_wi >= fir->out_delay_size) + fir->out_wi -= fir->out_delay_size; } /* Output */ - m = s->y_inc * s->stage->num_of_subfilters; + m = s->y_inc * cfg->num_of_subfilters; while (m > 0) { - n_wrap_fir = - (s->state->out_delay_size - s->state->out_ri) + n_wrap_fir = (fir->out_delay_size - fir->out_ri) * s->y_inc; n_wrap_buf = s->y_end_addr - s->y_wptr; n_wrap_min = (n_wrap_fir < n_wrap_buf) ? n_wrap_fir : n_wrap_buf; - if (m < n_wrap_min) { - /* No circular wrap need */ - while (m > 0) { - *s->y_wptr = s->state->out_delay[ - s->state->out_ri++]; - s->y_wptr += s->y_inc; - m -= s->y_inc; - } - } else { - /* Wrap in n_wrap_min/y_inc samples */ - while (n_wrap_min > 0) { - *s->y_wptr = s->state->out_delay[ - s->state->out_ri++]; - s->y_wptr += s->y_inc; - n_wrap_min -= s->y_inc; - m -= s->y_inc; - } - /* Check both */ - if (s->y_wptr >= s->y_end_addr) - s->y_wptr = - (int32_t *) - ((size_t) s->y_wptr - s->y_size); - - if (s->state->out_ri - == s->state->out_delay_size) - s->state->out_ri = 0; + n_min = (m < n_wrap_min) ? m : n_wrap_min; + while (n_min > 0) { + *s->y_wptr = fir->out_delay[fir->out_ri++]; + s->y_wptr += s->y_inc; + n_min -= s->y_inc; + m -= s->y_inc; } + /* Check wrap */ + src_circ_inc_wrap(&s->y_wptr, s->y_end_addr, s->y_size); + if (fir->out_ri == fir->out_delay_size) + fir->out_ri = 0; } } } + #ifdef MODULE_TEST -void src_print_info(struct polyphase_src *src) +void src_print_info(struct polyphase_src * src) { int n1; diff --git a/src/audio/src_core.h b/src/audio/src_core.h index a9f66d4..3859e6f 100644 --- a/src/audio/src_core.h +++ b/src/audio/src_core.h @@ -35,19 +35,20 @@ #define MAX(a, b) (((a) > (b)) ? (a) : (b)) #define MIN(a, b) (((a) < (b)) ? (a) : (b)) -struct src_alloc { +struct src_param { int fir_s1; int fir_s2; int out_s1; int out_s2; - int scratch; + int sbuf_length; int single_src; int total; - int blk_mult; int blk_in; int blk_out; int stage1_times; int stage2_times; + int stage1_times_max; + int stage2_times_max; int idx_in; int idx_out; }; @@ -103,6 +104,18 @@ struct src_stage_prm { struct src_stage *stage; }; +static inline void src_circ_inc_wrap(int32_t **ptr, int32_t *end, size_t size) +{ + if (*ptr >= end) + *ptr = (int32_t *) ((size_t) * ptr - size); +} + +static inline void src_circ_dec_wrap(int32_t **ptr, int32_t *addr, size_t size) +{ + if (*ptr < addr) + *ptr = (int32_t *) ((size_t) * ptr + size); +} + static inline void src_polyphase_mute(struct polyphase_src *src) { src->mute = 1; @@ -130,7 +143,7 @@ static inline int src_polyphase_get_blk_out(struct polyphase_src *src) void src_polyphase_reset(struct polyphase_src *src); -int src_polyphase_init(struct polyphase_src *src, struct src_alloc *res, +int src_polyphase_init(struct polyphase_src *src, struct src_param *p, int32_t *delay_lines_start); int src_polyphase(struct polyphase_src *src, int32_t x[], int32_t y[], @@ -140,13 +153,15 @@ void src_polyphase_stage_cir(struct src_stage_prm *s); void src_polyphase_stage_cir_s24(struct src_stage_prm *s); -int src_buffer_lengths(struct src_alloc *a, int fs_in, int fs_out, int nch, - int max_frames, int max_frames_is_for_source); +int src_buffer_lengths(struct src_param *p, int fs_in, int fs_out, int nch, + int frames, int frames_is_for_source); int32_t src_input_rates(void); int32_t src_output_rates(void); +int src_ceil_divide(int a, int b); + #ifdef MODULE_TEST void src_print_info(struct polyphase_src *src); #endif -- 2.11.0

2 1

[Sound-open-firmware] [PATCH] Use 64-bit time instead of 32-bit time for work queue utility.
by yan.wang＠linux.intel.com 11 Oct '17

11 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> Current timer has been upgraded to 64-bit but work queue utility still uses 32-bit. So timer->hitime can't be added rightly because the 64-bit time is truncated by work queue utility. "rmbox" will still receive 32-bit timestamp value only and can't be upgraded to 64-bit timestamp. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/audio/dma-trace.c | 2 +- src/audio/volume.c | 2 +- src/include/reef/reef.h | 1 + src/include/reef/wait.h | 4 ++-- src/include/reef/work.h | 4 ++-- src/lib/schedule.c | 2 +- src/lib/work.c | 30 +++++++++++++++--------------- 7 files changed, 23 insertions(+), 22 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index 8fc220e..d725fcf 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -97,7 +97,7 @@ static void trace_send(struct dma_trace_data *d) trace_buffer("dts"); } -static uint32_t trace_work(void *data, uint32_t delay) +static uint64_t trace_work(void *data, uint64_t delay) { struct dma_trace_data *d = (struct dma_trace_data *)data; diff --git a/src/audio/volume.c b/src/audio/volume.c index 68c8453..04d1b34 100644 --- a/src/audio/volume.c +++ b/src/audio/volume.c @@ -277,7 +277,7 @@ static void vol_update(struct comp_data *cd, uint32_t chan) } /* this ramps volume changes over time */ -static uint32_t vol_work(void *data, uint32_t delay) +static uint64_t vol_work(void *data, uint64_t delay) { struct comp_dev *dev = (struct comp_dev *)data; struct comp_data *cd = comp_get_drvdata(dev); diff --git a/src/include/reef/reef.h b/src/include/reef/reef.h index 0cf8261..3450208 100644 --- a/src/include/reef/reef.h +++ b/src/include/reef/reef.h @@ -39,6 +39,7 @@ struct ipc; /* TODO: define for unsigned and short, byte */ #define MAX_INT 0xffffffff +#define MAX_INT64 0xffffffffffffffff /* use same syntax as Linux for simplicity */ #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) diff --git a/src/include/reef/wait.h b/src/include/reef/wait.h index c830a75..08fc0b0 100644 --- a/src/include/reef/wait.h +++ b/src/include/reef/wait.h @@ -45,7 +45,7 @@ typedef struct { uint32_t complete; struct work work; - uint32_t timeout; + uint64_t timeout; } completion_t; void arch_wait_for_interrupt(int level); @@ -57,7 +57,7 @@ static inline void wait_for_interrupt(int level) tracev_event(TRACE_CLASS_WAIT, "WFX"); } -static uint32_t _wait_cb(void *data, uint32_t delay) +static uint64_t _wait_cb(void *data, uint64_t delay) { volatile completion_t *wc = (volatile completion_t*)data; diff --git a/src/include/reef/work.h b/src/include/reef/work.h index 516f98f..0cdb085 100644 --- a/src/include/reef/work.h +++ b/src/include/reef/work.h @@ -45,10 +45,10 @@ struct work_queue; #define WORK_SYNC (1 << 0) /* work is scheduled synchronously */ struct work { - uint32_t (*cb)(void*, uint32_t udelay); /* returns reschedule timeout in msecs */ + uint64_t (*cb)(void*, uint64_t udelay); /* returns reschedule timeout in msecs */ void *cb_data; struct list_item list; - uint32_t timeout; + uint64_t timeout; uint32_t pending; uint32_t flags; }; diff --git a/src/lib/schedule.c b/src/lib/schedule.c index 427ca2e..993f94a 100644 --- a/src/lib/schedule.c +++ b/src/lib/schedule.c @@ -146,7 +146,7 @@ static inline struct task *edf_get_next(uint64_t current, } /* work set in the future when next task can be scheduled */ -static uint32_t sch_work(void *data, uint32_t delay) +static uint64_t sch_work(void *data, uint64_t delay) { tracev_pipe("wrk"); schedule(); diff --git a/src/lib/work.c b/src/lib/work.c index a267b80..cd21b20 100644 --- a/src/lib/work.c +++ b/src/lib/work.c @@ -98,8 +98,8 @@ static int is_work_pending(struct work_queue *queue) { struct list_item *wlist; struct work *work; - uint32_t win_end; - uint32_t win_start; + uint64_t win_end; + uint64_t win_start; int pending_count = 0; /* get the current valid window of work */ @@ -131,7 +131,7 @@ static int is_work_pending(struct work_queue *queue) /* if work has timed out then mark it as pending to run */ if (work->timeout <= win_end || - (work->timeout >= win_start && work->timeout < MAX_INT)) { + (work->timeout >= win_start && work->timeout < MAX_INT64)) { work->pending = 1; pending_count++; } else { @@ -144,7 +144,7 @@ static int is_work_pending(struct work_queue *queue) } static inline void work_next_timeout(struct work_queue *queue, - struct work *work, uint32_t reschedule_usecs) + struct work *work, uint64_t reschedule_usecs) { /* reschedule work */ if (work->flags & WORK_SYNC) { @@ -162,8 +162,8 @@ static void run_work(struct work_queue *queue, uint32_t *flags) struct list_item *wlist; struct list_item *tlist; struct work *work; - uint32_t reschedule_usecs; - uint32_t udelay; + uint64_t reschedule_usecs; + uint64_t udelay; /* check each work item in queue for pending */ list_for_item_safe(wlist, tlist, &queue->work) { @@ -192,9 +192,9 @@ static void run_work(struct work_queue *queue, uint32_t *flags) } } -static inline uint32_t calc_delta_ticks(uint32_t current, uint32_t work) +static inline uint64_t calc_delta_ticks(uint64_t current, uint64_t work) { - uint32_t max = MAX_INT; + uint64_t max = MAX_INT64; /* does work run in next cycle ? */ if (work < current) { @@ -210,10 +210,10 @@ static void queue_get_next_timeout(struct work_queue *queue) { struct list_item *wlist; struct work *work; - uint32_t delta = MAX_INT; - uint32_t current; - uint32_t d; - uint32_t ticks; + uint64_t delta = MAX_INT64; + uint64_t current; + uint64_t d; + uint64_t ticks; /* only recalc if work list not empty */ if (list_is_empty(&queue->work)) { @@ -246,9 +246,9 @@ static void queue_recalc_timers(struct work_queue *queue, { struct list_item *wlist; struct work *work; - uint32_t delta_ticks; - uint32_t delta_usecs; - uint32_t current; + uint64_t delta_ticks; + uint64_t delta_usecs; + uint64_t current; /* get current time */ current = work_get_timer(queue); -- 2.7.4

2 1

[Sound-open-firmware] [PATCH] Fix the calculation of 64bit timeout.
by yan.wang＠linux.intel.com 09 Oct '17

09 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> Before the 1st rollover, timer->hitimeout = 0, it will cause platform_timer_64_handler() set timeout = 1. So the time irq is forced to be fired at the beginning of rollover. And the timeout of platform_timer_set() will be invalid and work queue cannot be fired. Just set the new hitimeout to timer->hitimeout. timer->hitime will be added in the next rollover. It is unnecessary to check timer->hitimout > 0. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/platform/baytrail/timer.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/platform/baytrail/timer.c b/src/platform/baytrail/timer.c index 9256dd9..3397ef0 100644 --- a/src/platform/baytrail/timer.c +++ b/src/platform/baytrail/timer.c @@ -66,7 +66,7 @@ static void platform_timer_64_handler(void *arg) } /* get next timeout value */ - if (timer->hitimeout > 0 && timer->hitimeout == timer->hitime) { + if (timer->hitimeout == timer->hitime) { /* timeout is in this 32 bit period */ timeout = timer->lowtimeout; } else { @@ -108,17 +108,13 @@ int platform_timer_set(struct timer *timer, uint64_t ticks) flags = arch_interrupt_global_disable(); /* same hi 64 bit context as ticks ? */ - if (hitimeout == timer->hitime) { - /* yes, then set the value for next timeout */ - time = ticks; - timer->lowtimeout = 0; - timer->hitimeout = 0; - } else if (hitimeout < timer->hitime) { + if (hitimeout < timer->hitime) { /* cant be in the past */ arch_interrupt_global_enable(flags); return -EINVAL; } else { /* set for checking at next timeout */ + time = ticks; timer->hitimeout = hitimeout; timer->lowtimeout = ticks; } -- 2.7.4

2 1

[Sound-open-firmware] [PATCH] component: make sure we can enter the start from paused state
by Liam Girdwood 05 Oct '17

05 Oct '17

Fix state checking to make sure start can be entered after pause. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/audio/component.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/audio/component.c b/src/audio/component.c index ec170c6..80311e3 100644 --- a/src/audio/component.c +++ b/src/audio/component.c @@ -122,7 +122,8 @@ int comp_set_state(struct comp_dev *dev, int cmd) switch (cmd) { case COMP_CMD_START: - if (dev->state == COMP_STATE_PREPARE) { + if (dev->state == COMP_STATE_PREPARE || + dev->state == COMP_STATE_PAUSED) { dev->state = COMP_STATE_ACTIVE; } else { trace_comp_error("CES"); -- 2.11.0

1 1

[Sound-open-firmware] [PATCH] topology: Allows playback and capture pipelines to share same PCM
by Liam Girdwood 02 Oct '17

02 Oct '17

Add support so that different playback and capture pipelines can share the same host PCM device. Modify board configs to use PCM0 for playback and capture. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- topology/m4/local.m4 | 62 +++++++++++++++++++-------- topology/reef-apl-nocodec.m4 | 15 ++++--- topology/reef-bdw-rt286.m4 | 15 ++++--- topology/reef-bdw-rt5640.m4 | 15 ++++--- topology/reef-bxt-nocodec.m4 | 13 +++--- topology/reef-byt-nocodec.m4 | 11 +++-- topology/reef-byt-rt5640.m4 | 11 +++-- topology/reef-byt-rt5651.m4 | 11 +++-- topology/reef-cht-nocodec.m4 | 11 +++-- topology/reef-hsw-rt5640.m4 | 15 ++++--- topology/sof/pipe-low-latency-capture.m4 | 28 ++---------- topology/sof/pipe-low-latency-playback.m4 | 29 ++----------- topology/sof/pipe-passthrough-playback.m4 | 4 +- topology/sof/pipe-passthrough-src-playback.m4 | 4 +- topology/sof/pipe-passthrough-vol-playback.m4 | 4 +- topology/sof/pipe-pcm-media.m4 | 6 +-- 16 files changed, 130 insertions(+), 124 deletions(-) diff --git a/topology/m4/local.m4 b/topology/m4/local.m4 index 50c6b5d..e521267 100644 --- a/topology/m4/local.m4 +++ b/topology/m4/local.m4 @@ -67,12 +67,13 @@ define(`W_BUFFER', `}') dnl PCM name) -define(`N_PCM', `PCM'PCM_ID) +define(`N_PCMP', `PCM'PCM_ID`P') +define(`N_PCMC', `PCM'PCM_ID`C') dnl W_PCM_PLAYBACK(stream, dmac, dmac_chan, periods_sink, periods_source, preload) dnl PCM platform configuration define(`W_PCM_PLAYBACK', -`SectionVendorTuples."'N_PCM($1)`_tuples_w_comp" {' +`SectionVendorTuples."'N_PCMP($1)`_tuples_w_comp" {' ` tokens "sof_comp_tokens"' ` tuples."word" {' ` SOF_TKN_COMP_PERIOD_SINK_COUNT' STR($4) @@ -80,34 +81,34 @@ define(`W_PCM_PLAYBACK', ` SOF_TKN_COMP_PRELOAD_COUNT' STR($6) ` }' `}' -`SectionData."'N_PCM($1)`_data_w_comp" {' -` tuples "'N_PCM($1)`_tuples_w_comp"' +`SectionData."'N_PCMP($1)`_data_w_comp" {' +` tuples "'N_PCMP($1)`_tuples_w_comp"' `}' -`SectionVendorTuples."'N_PCM($1)`_tuples" {' +`SectionVendorTuples."'N_PCMP($1)`_tuples" {' ` tokens "sof_pcm_tokens"' ` tuples."word" {' ` SOF_TKN_PCM_DMAC' STR($2) ` SOF_TKN_PCM_DMAC_CHAN' STR($3) ` }' `}' -`SectionData."'N_PCM($1)`_data" {' -` tuples "'N_PCM($1)`_tuples"' +`SectionData."'N_PCMP($1)`_data" {' +` tuples "'N_PCMP($1)`_tuples"' `}' -`SectionWidget."'N_PCM`" {' +`SectionWidget."'N_PCMP`" {' ` index "'PIPELINE_ID`"' ` type "aif_out"' ` no_pm "true"' ` stream_name "'$1`"' ` data [' -` "'N_PCM($1)`_data"' -` "'N_PCM($1)`_data_w_comp"' +` "'N_PCMP($1)`_data"' +` "'N_PCMP($1)`_data_w_comp"' ` ]' `}') dnl W_PCM_PLAYBACK(stream, dmac, dmac_chan, periods_sink, periods_source, preload) define(`W_PCM_CAPTURE', -`SectionVendorTuples."'N_PCM($1)`_tuples_w_comp" {' +`SectionVendorTuples."'N_PCMC($1)`_tuples_w_comp" {' ` tokens "sof_comp_tokens"' ` tuples."word" {' ` SOF_TKN_COMP_PERIOD_SINK_COUNT' STR($4) @@ -115,27 +116,27 @@ define(`W_PCM_CAPTURE', ` SOF_TKN_COMP_PRELOAD_COUNT' STR($6) ` }' `}' -`SectionData."'N_PCM($1)`_data_w_comp" {' -` tuples "'N_PCM($1)`_tuples_w_comp"' +`SectionData."'N_PCMC($1)`_data_w_comp" {' +` tuples "'N_PCMC($1)`_tuples_w_comp"' `}' -`SectionVendorTuples."'N_PCM($1)`_tuples" {' +`SectionVendorTuples."'N_PCMC($1)`_tuples" {' ` tokens "sof_pcm_tokens"' ` tuples."word" {' ` SOF_TKN_PCM_DMAC' STR($2) ` SOF_TKN_PCM_DMAC_CHAN' STR($3) ` }' `}' -`SectionData."'N_PCM($1)`_data" {' -` tuples "'N_PCM($1)`_tuples"' +`SectionData."'N_PCMC($1)`_data" {' +` tuples "'N_PCMC($1)`_tuples"' `}' -`SectionWidget."'N_PCM`" {' +`SectionWidget."'N_PCMC`" {' ` index "'PIPELINE_ID`"' ` type "aif_out"' ` no_pm "true"' ` stream_name "'$1`"' ` data [' -` "'N_PCM($1)`_data"' -` "'N_PCM($1)`_data_w_comp"' +` "'N_PCMC($1)`_data"' +` "'N_PCMC($1)`_data_w_comp"' ` ]' `}') @@ -478,5 +479,28 @@ define(`COMP_SAMPLE_SIZE', dnl COMP_BUFFER_SIZE( num_periods, sample_size, channels, fmames) define(`COMP_BUFFER_SIZE', `eval(`$1 * $2 * $3 * $4')') +dnl PCM_DUPLEX_ADD(name, pipeline, pcm_id, dai_id, playback, capture) +define(`PCM_DUPLEX_ADD', +`SectionPCM.STR($1) {' +`' +` index STR($2)' +`' +` # used for binding to the PCM' +` id STR($3)' +`' +` dai.STR($1 $3) {' +` id STR($4)' +` }' +`' +` pcm."capture" {' +`' +` capabilities STR($6)' +` }' +`' +` pcm."playback" {' +`' +` capabilities STR($5)' +` }' +`}') divert(0) dnl diff --git a/topology/reef-apl-nocodec.m4 b/topology/reef-apl-nocodec.m4 index 5e497f6..96f28d5 100644 --- a/topology/reef-apl-nocodec.m4 +++ b/topology/reef-apl-nocodec.m4 @@ -36,25 +36,25 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 96, 2000, 1, 0, 0, 3) -# PCM Media Playback pipeline 4 on PCM 3 using max 2 channels of s32le. +# PCM Media Playback pipeline 4 on PCM 2 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 4 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 4, 3, 2, s32le, + 4, 2, 2, s32le, 96, 2000, 1, 0, 0, 4) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -97,6 +97,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-bdw-rt286.m4 b/topology/reef-bdw-rt286.m4 index cb11ad6..512efe9 100644 --- a/topology/reef-bdw-rt286.m4 +++ b/topology/reef-bdw-rt286.m4 @@ -36,25 +36,25 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 96, 2000, 1, 0, 0, 3) -# PCM Media Playback pipeline 4 on PCM 3 using max 2 channels of s32le. +# PCM Media Playback pipeline 4 on PCM 2 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 4 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 4, 3, 2, s32le, + 4, 2, 2, s32le, 96, 2000, 1, 0, 0, 4) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -97,6 +97,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-bdw-rt5640.m4 b/topology/reef-bdw-rt5640.m4 index b3c19c2..5e259a6 100644 --- a/topology/reef-bdw-rt5640.m4 +++ b/topology/reef-bdw-rt5640.m4 @@ -36,25 +36,25 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 96, 2000, 1, 0, 0, 3) -# PCM Media Playback pipeline 4 on PCM 3 using max 2 channels of s32le. +# PCM Media Playback pipeline 4 on PCM 2 using max 2 channels of s32le. # Schedule 96 frames per 2000us deadline on core 0 with priority 1 # Use DMAC 0 channel 4 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 4, 3, 2, s32le, + 4, 2, 2, s32le, 96, 2000, 1, 0, 0, 4) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -97,6 +97,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-bxt-nocodec.m4 b/topology/reef-bxt-nocodec.m4 index 58bc6f6..e3c45c9 100644 --- a/topology/reef-bxt-nocodec.m4 +++ b/topology/reef-bxt-nocodec.m4 @@ -36,21 +36,21 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) -# PCM Media Playback pipeline 4 on PCM 3 using max 2 channels of s32le. +# PCM Media Playback pipeline 4 on PCM 2 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, @@ -97,6 +97,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-byt-nocodec.m4 b/topology/reef-byt-nocodec.m4 index 5f6cd1d..3db415d 100644 --- a/topology/reef-byt-nocodec.m4 +++ b/topology/reef-byt-nocodec.m4 @@ -34,18 +34,18 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -86,6 +86,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-byt-rt5640.m4 b/topology/reef-byt-rt5640.m4 index c5e8b52..1e9bb5f 100644 --- a/topology/reef-byt-rt5640.m4 +++ b/topology/reef-byt-rt5640.m4 @@ -34,18 +34,18 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -86,6 +86,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-byt-rt5651.m4 b/topology/reef-byt-rt5651.m4 index e335d66..0867f91 100644 --- a/topology/reef-byt-rt5651.m4 +++ b/topology/reef-byt-rt5651.m4 @@ -34,18 +34,18 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -86,6 +86,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 3, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-cht-nocodec.m4 b/topology/reef-cht-nocodec.m4 index ddeb71e..195ae5c 100644 --- a/topology/reef-cht-nocodec.m4 +++ b/topology/reef-cht-nocodec.m4 @@ -34,18 +34,18 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -86,6 +86,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/reef-hsw-rt5640.m4 b/topology/reef-hsw-rt5640.m4 index efd815b..1b06828 100644 --- a/topology/reef-hsw-rt5640.m4 +++ b/topology/reef-hsw-rt5640.m4 @@ -36,25 +36,25 @@ PIPELINE_PCM_ADD(sof/pipe-low-latency-playback.m4, 1, 0, 2, s32le, 48, 1000, 0, 0, 0, 1) -# Low Latency capture pipeline 2 on PCM 1 using max 2 channels of s32le. +# Low Latency capture pipeline 2 on PCM 0 using max 2 channels of s32le. # Schedule 48 frames per 1000us deadline on core 0 with priority 0 # Use DMAC 0 channel 2 for PCM audio capture data PIPELINE_PCM_ADD(sof/pipe-low-latency-capture.m4, - 2, 1, 2, s32le, + 2, 0, 2, s32le, 48, 1000, 0, 0, 0, 2) -# PCM Media Playback pipeline 3 on PCM 2 using max 2 channels of s32le. +# PCM Media Playback pipeline 3 on PCM 1 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 3, 1, 2, s32le, 192, 4000, 1, 0, 0, 3) -# PCM Media Playback pipeline 4 on PCM 3 using max 2 channels of s32le. +# PCM Media Playback pipeline 4 on PCM 2 using max 2 channels of s32le. # Schedule 192 frames per 4000us deadline on core 0 with priority 1 # Use DMAC 0 channel 3 for PCM audio playback data PIPELINE_PCM_ADD(sof/pipe-pcm-media.m4, - 3, 2, 2, s32le, + 4, 2, 2, s32le, 192, 4000, 1, 0, 0, 4) # Tone Playback pipeline 5 using max 2 channels of s32le. @@ -97,6 +97,9 @@ DAI_ADD(sof/pipe-dai-capture.m4, PIPELINE_SINK_2, 2, s24le, 48, 1000, 0, 0) +# PCM Low Latency +PCM_DUPLEX_ADD(Low Latency, 6, 0, 0, PIPELINE_PCM_1, PIPELINE_PCM_2) + # # BE configurations - overrides config in ACPI if present # diff --git a/topology/sof/pipe-low-latency-capture.m4 b/topology/sof/pipe-low-latency-capture.m4 index 22df648..0c989a7 100644 --- a/topology/sof/pipe-low-latency-capture.m4 +++ b/topology/sof/pipe-low-latency-capture.m4 @@ -65,8 +65,8 @@ SectionGraph."pipe-ll-capture-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(Low Latency Capture PCM_ID, N_PCM) - dapm(N_PCM, N_BUFFER(1)) + dapm(Low Latency Capture PCM_ID, N_PCMC) + dapm(N_PCMC, N_BUFFER(1)) dapm(N_BUFFER(1), N_PGA(0)) dapm(N_PGA(0), N_BUFFER(0)) ] @@ -76,12 +76,7 @@ SectionGraph."pipe-ll-capture-PIPELINE_ID" { # Pipeline Source and Sinks # indir(`define', concat(`PIPELINE_SINK_', PIPELINE_ID), N_BUFFER(0)) - -# -# Pipeline Configuration. -# - -#W_PIPELINE(N_PGA(0), SCHEDULE_DEADLINE, SCHEDULE_PRIORITY, SCHEDULE_FRAMES, SCHEDULE_CORE, pipe_ll_schedule_plat) +indir(`define', concat(`PIPELINE_PCM_', PIPELINE_ID), Low Latency Capture PCM_ID) # # PCM Configuration @@ -102,20 +97,3 @@ SectionPCMCapabilities.STR(Low Latency Capture PCM_ID) { buffer_size_max "65536" } -# PCM Low Latency Capture -SectionPCM.STR(PCM PCM_ID) { - - index STR(PIPELINE_ID) - - # used for binding to the PCM - id STR(PCM_ID) - - dai.STR(Low Latency Capture PCM_ID) { - id STR(PCM_ID) - } - - pcm."capture" { - - capabilities STR(Low Latency Capture PCM_ID) - } -} diff --git a/topology/sof/pipe-low-latency-playback.m4 b/topology/sof/pipe-low-latency-playback.m4 index c29165e..cd04ccf 100644 --- a/topology/sof/pipe-low-latency-playback.m4 +++ b/topology/sof/pipe-low-latency-playback.m4 @@ -125,8 +125,8 @@ SectionGraph."pipe-ll-playback-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(N_PCM, Low Latency Playback PCM_ID) - dapm(N_BUFFER(0), N_PCM) + dapm(N_PCMP, Low Latency Playback PCM_ID) + dapm(N_BUFFER(0), N_PCMP) dapm(N_PGA(0), N_BUFFER(0)) dapm(N_BUFFER(1), N_PGA(0)) dapm(N_MIXER(0), N_BUFFER(1)) @@ -141,12 +141,7 @@ SectionGraph."pipe-ll-playback-PIPELINE_ID" { # indir(`define', concat(`PIPELINE_SOURCE_', PIPELINE_ID), N_BUFFER(3)) indir(`define', concat(`PIPELINE_MIXER_', PIPELINE_ID), N_MIXER(0)) - -# -# Pipeline Configuration. -# - -#W_PIPELINE(N_PGA(1), SCHEDULE_DEADLINE, SCHEDULE_PRIORITY, SCHEDULE_FRAMES, SCHEDULE_CORE, pipe_ll_schedule_plat) +indir(`define', concat(`PIPELINE_PCM_', PIPELINE_ID), Low Latency Playback PCM_ID) # # PCM Configuration @@ -168,21 +163,3 @@ SectionPCMCapabilities.STR(Low Latency Playback PCM_ID) { buffer_size_max "65536" } -# PCM Low Latency Playback -SectionPCM.STR(PCM PCM_ID) { - - index STR(PIPELINE_ID) - - # used for binding to the PCM - id STR(PCM_ID) - - dai.STR(Low Latency Playback PCM_ID) { - id STR(PCM_ID) - } - - # Playback and Capture Configuration - pcm."playback" { - - capabilities STR(Low Latency Playback PCM_ID) - } -} diff --git a/topology/sof/pipe-passthrough-playback.m4 b/topology/sof/pipe-passthrough-playback.m4 index 46ed949..4e6e705 100644 --- a/topology/sof/pipe-passthrough-playback.m4 +++ b/topology/sof/pipe-passthrough-playback.m4 @@ -39,8 +39,8 @@ SectionGraph."pipe-pass-playback-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(N_PCM, Passthrough Playback PCM_ID) - dapm(N_BUFFER(0), N_PCM) + dapm(N_PCMP, Passthrough Playback PCM_ID) + dapm(N_BUFFER(0), N_PCMP) dapm(N_DAI_OUT, N_BUFFER(0)) ] } diff --git a/topology/sof/pipe-passthrough-src-playback.m4 b/topology/sof/pipe-passthrough-src-playback.m4 index 0ffc2a4..3cadaf2 100644 --- a/topology/sof/pipe-passthrough-src-playback.m4 +++ b/topology/sof/pipe-passthrough-src-playback.m4 @@ -62,8 +62,8 @@ SectionGraph."pipe-pass-src-playback-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(N_PCM, Passthrough Playback PCM_ID) - dapm(N_BUFFER(0), N_PCM) + dapm(N_PCMP, Passthrough Playback PCM_ID) + dapm(N_BUFFER(0), N_PCMP) dapm(N_SRC(0), N_BUFFER(0)) dapm(N_BUFFER(1), N_SRC(0)) dapm(N_DAI_OUT, N_BUFFER(1)) diff --git a/topology/sof/pipe-passthrough-vol-playback.m4 b/topology/sof/pipe-passthrough-vol-playback.m4 index ffc9000..f0e39e8 100644 --- a/topology/sof/pipe-passthrough-vol-playback.m4 +++ b/topology/sof/pipe-passthrough-vol-playback.m4 @@ -76,8 +76,8 @@ SectionGraph."pipe-pass-vol-playback-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(N_PCM, Passthrough Playback PCM_ID) - dapm(N_BUFFER(0), N_PCM) + dapm(N_PCMP, Passthrough Playback PCM_ID) + dapm(N_BUFFER(0), N_PCMP) dapm(N_PGA(0), N_BUFFER(0)) dapm(N_BUFFER(1), N_PGA(0)) dapm(N_DAI_OUT, N_BUFFER(1)) diff --git a/topology/sof/pipe-pcm-media.m4 b/topology/sof/pipe-pcm-media.m4 index b04b353..7bfb35a 100644 --- a/topology/sof/pipe-pcm-media.m4 +++ b/topology/sof/pipe-pcm-media.m4 @@ -93,8 +93,8 @@ SectionGraph."pipe-media-PIPELINE_ID" { index STR(PIPELINE_ID) lines [ - dapm(N_PCM, Media Playback PCM_ID) - dapm(N_BUFFER(0), N_PCM) + dapm(N_PCMP, Media Playback PCM_ID) + dapm(N_BUFFER(0), N_PCMP) dapm(N_PGA(0), N_BUFFER(0)) dapm(N_BUFFER(1), N_PGA(0)) dapm(N_SRC(0), N_BUFFER(1)) @@ -134,7 +134,7 @@ SectionPCMCapabilities.STR(Media Playback PCM_ID) { } # PCM Low Latency Playback and Capture -SectionPCM.STR(PCM PCM_ID) { +SectionPCM.STR(Media Playback PCM_ID) { index STR(PIPELINE_ID) -- 1.9.1

1 0