From 6ad2a9763d9aaab30c0470d039877b1bb61dda3b Mon Sep 17 00:00:00 2001

From: Mengdong Lin <mengdong.lin@linux.intel.com>

Date: Tue, 27 Dec 2016 18:08:58 +0800

Subject: [PATCH 01/37] ucm: Add ATTRIBUTE_UNUSED for unused parameters of

 execute_component_seq()

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

To fix the following warnings:

main.c: In function ‘execute_component_seq’:

main.c:489:24: warning: unused parameter ‘value_list1’ [-Wunused-parameter]

      struct list_head *value_list1,

                        ^

main.c:490:24: warning: unused parameter ‘value_list2’ [-Wunused-parameter]

      struct list_head *value_list2,

                        ^

main.c:491:24: warning: unused parameter ‘value_list3’ [-Wunused-parameter]

      struct list_head *value_list3,

                        ^

Signed-off-by: Mengdong Lin <mengdong.lin@linux.intel.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/ucm/main.c | 6 +++---

 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ucm/main.c b/src/ucm/main.c

index 750e65d..38a5e81 100644

--- a/src/ucm/main.c

+++ b/src/ucm/main.c

@@ -486,9 +486,9 @@ static int execute_sequence(snd_use_case_mgr_t *uc_mgr,

  */

 static int execute_component_seq(snd_use_case_mgr_t *uc_mgr,

 				 struct component_sequence *cmpt_seq,

-				 struct list_head *value_list1,

-				 struct list_head *value_list2,

-				 struct list_head *value_list3,

+				 struct list_head *value_list1 ATTRIBUTE_UNUSED,

+				 struct list_head *value_list2 ATTRIBUTE_UNUSED,

+				 struct list_head *value_list3 ATTRIBUTE_UNUSED,

 				 char *cdev)

 {

 	struct use_case_device *device = cmpt_seq->device;

-- 

2.9.3

From 9ed4075f05a4242f32331f7f2c365767970f5003 Mon Sep 17 00:00:00 2001

From: Gustavo Zacarias <gustavo@zacarias.com.ar>

Date: Wed, 21 Dec 2016 19:46:34 -0300

Subject: [PATCH 02/37] ucm: parser needs limits.h

It's using PATH_MAX which is defined there, otherwise the build fails on

musl libc.

Signed-off-by: Gustavo Zacarias <gustavo@zacarias.com.ar>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/ucm/parser.c | 1 +

 1 file changed, 1 insertion(+)

diff --git a/src/ucm/parser.c b/src/ucm/parser.c

index c98373a..f520abc 100644

--- a/src/ucm/parser.c

+++ b/src/ucm/parser.c

@@ -32,6 +32,7 @@

 #include "ucm_local.h"

 #include <dirent.h>

+#include <limits.h>

 /** The name of the environment variable containing the UCM directory */

 #define ALSA_CONFIG_UCM_VAR "ALSA_CONFIG_UCM"

-- 

2.9.3

From 0a61c796810fcec8b386e5311e871b1744b45a67 Mon Sep 17 00:00:00 2001

From: Joshua Frkuska <joshua_frkuska@mentor.com>

Date: Fri, 30 Dec 2016 11:56:15 +0530

Subject: [PATCH 03/37] pcm: direct: allow users to configure different period

 sizes

This patch allows the effective period size to be a multiple of the

slave-pcm period size.

Allowing only exact multiple of original period size is achieved by

borrowing code from the kernel hwrules implementation.

This patch is intended to save cpu workload when for example, the

slave operates with very small periods but a user does not need that

small periods.

This feature is enabled by default and can be disabled by adding

config option 'var_periodsize 0'.

Signed-off-by: Alexander Jahn <ajahn@de.adit-jv.com>

Signed-off-by: Andreas Pape <apape@de.adit-jv.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/pcm/pcm_direct.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++------

 src/pcm/pcm_direct.h |  3 ++

 src/pcm/pcm_dmix.c   |  1 +

 src/pcm/pcm_dshare.c |  1 +

 src/pcm/pcm_dsnoop.c |  1 +

 5 files changed, 84 insertions(+), 10 deletions(-)

diff --git a/src/pcm/pcm_direct.c b/src/pcm/pcm_direct.c

index 6434983..f5d922f 100644

--- a/src/pcm/pcm_direct.c

+++ b/src/pcm/pcm_direct.c

@@ -660,6 +660,29 @@ static int hw_param_interval_refine_minmax(snd_pcm_hw_params_t *params,

 	return hw_param_interval_refine_one(params, var, &t);

 }

+/* this code is used 'as-is' from the alsa kernel code */

+static int snd_interval_step(struct snd_interval *i, unsigned int min,

+			     unsigned int step)

+{

+	unsigned int n;

+	int changed = 0;

+	n = (i->min - min) % step;

+	if (n != 0 || i->openmin) {

+		i->min += step - n;

+		changed = 1;

+	}

+	n = (i->max - min) % step;

+	if (n != 0 || i->openmax) {

+		i->max -= n;

+		changed = 1;

+	}

+	if (snd_interval_checkempty(i)) {

+		i->empty = 1;

+		return -EINVAL;

+	}

+	return changed;

+}

+

 #undef REFINE_DEBUG

 int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

@@ -710,15 +733,16 @@ int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

 					   &dshare->shmptr->hw.rate);

 	if (err < 0)

 		return err;

-	err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,

-					   &dshare->shmptr->hw.period_size);

-	if (err < 0)

-		return err;

-	err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_TIME,

-					   &dshare->shmptr->hw.period_time);

-	if (err < 0)

-		return err;

+

 	if (dshare->max_periods < 0) {

+		err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,

+						   &dshare->shmptr->hw.period_size);

+		if (err < 0)

+			return err;

+		err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_TIME,

+						   &dshare->shmptr->hw.period_time);

+		if (err < 0)

+			return err;

 		err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_BUFFER_SIZE,

 						   &dshare->shmptr->hw.buffer_size);

 		if (err < 0)

@@ -730,11 +754,38 @@ int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

 	} else if (params->rmask & ((1<

 				    (1<

 				    (1<

-				    (1<

+				    (1<

+				    (1<

+				    (1<

+				    (1<

+		snd_interval_t period_size = dshare->shmptr->hw.period_size;

+		snd_interval_t period_time = dshare->shmptr->hw.period_time;

 		int changed;

 		unsigned int max_periods = dshare->max_periods;

 		if (max_periods < 2)

 			max_periods = dshare->slave_buffer_size / dshare->slave_period_size;

+

+		/* make sure buffer size does not exceed slave buffer size */

+		err = hw_param_interval_refine_minmax(params, SND_PCM_HW_PARAM_BUFFER_SIZE,

+					2 * dshare->slave_period_size, dshare->slave_buffer_size);

+		if (err < 0)

+			return err;

+		if (dshare->var_periodsize) {

+			/* more tolerant settings... */

+			if (dshare->shmptr->hw.buffer_size.max / 2 > period_size.max)

+				period_size.max = dshare->shmptr->hw.buffer_size.max / 2;

+			if (dshare->shmptr->hw.buffer_time.max / 2 > period_time.max)

+				period_time.max = dshare->shmptr->hw.buffer_time.max / 2;

+		}

+

+		err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,

+						   &period_size);

+		if (err < 0)

+			return err;

+		err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_TIME,

+						   &period_time);

+		if (err < 0)

+			return err;

 		do {

 			changed = 0;

 			err = hw_param_interval_refine_minmax(params, SND_PCM_HW_PARAM_PERIODS,

@@ -746,8 +797,16 @@ int snd_pcm_direct_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)

 			if (err < 0)

 				return err;

 			changed |= err;

+			err = snd_interval_step(hw_param_interval(params, SND_PCM_HW_PARAM_PERIOD_SIZE),

+								0, dshare->slave_period_size);

+			if (err < 0)

+				return err;

+			changed |= err;

+			if (err)

+				params->rmask |= (1 << SND_PCM_HW_PARAM_PERIOD_SIZE);

 		} while (changed);

 	}

+	dshare->timer_ticks = hw_param_interval(params, SND_PCM_HW_PARAM_PERIOD_SIZE)->max / dshare->slave_period_size;

 	params->info = dshare->shmptr->s.info;

 #ifdef REFINE_DEBUG

 	snd_output_puts(log, "DMIX REFINE (end):\n");

@@ -1183,6 +1242,7 @@ int snd_pcm_direct_initialize_poll_fd(snd_pcm_direct_t *dmix)

 	dmix->tread = 1;

 	dmix->timer_need_poll = 0;

+	dmix->timer_ticks = 1;

 	ret = snd_pcm_info(dmix->spcm, &info;;

 	if (ret < 0) {

 		SNDERR("unable to info for slave pcm");

@@ -1366,7 +1426,7 @@ int snd_pcm_direct_set_timer_params(snd_pcm_direct_t *dmix)

 	snd_timer_params_set_auto_start(&params, 1);

 	if (dmix->type != SND_PCM_TYPE_DSNOOP)

 		snd_timer_params_set_early_event(&params, 1);

-	snd_timer_params_set_ticks(&params, 1);

+	snd_timer_params_set_ticks(&params, dmix->timer_ticks);

 	if (dmix->tread) {

 		filter = (1<

 			 dmix->timer_events;

@@ -1656,6 +1716,7 @@ int snd_pcm_direct_parse_open_conf(snd_config_t *root, snd_config_t *conf,

 	rec->ipc_gid = -1;

 	rec->slowptr = 1;

 	rec->max_periods = 0;

+	rec->var_periodsize = 1;

 	/* read defaults */

 	if (snd_config_search(root, "defaults.pcm.dmix_max_periods", &n) >= 0) {

@@ -1762,6 +1823,13 @@ int snd_pcm_direct_parse_open_conf(snd_config_t *root, snd_config_t *conf,

 			rec->max_periods = val;

 			continue;

 		}

+		if (strcmp(id, "var_periodsize") == 0) {

+			err = snd_config_get_bool(n);

+			if (err < 0)

+				return err;

+			rec->var_periodsize = err;

+			continue;

+		}

 		SNDERR("Unknown field %s", id);

 		return -EINVAL;

 	}

diff --git a/src/pcm/pcm_direct.h b/src/pcm/pcm_direct.h

index 611ad29..91e816c 100644

--- a/src/pcm/pcm_direct.h

+++ b/src/pcm/pcm_direct.h

@@ -147,12 +147,14 @@ struct snd_pcm_direct {

 	int tread: 1;

 	int timer_need_poll: 1;

 	unsigned int timer_events;

+	unsigned int timer_ticks;

 	int server_fd;

 	pid_t server_pid;

 	snd_timer_t *timer; 		/* timer used as poll_fd */

 	int interleaved;	 	/* we have interleaved buffer */

 	int slowptr;			/* use slow but more precise ptr updates */

 	int max_periods;		/* max periods (-1 = fixed periods, 0 = max buffer size) */

+	int var_periodsize;		/* allow variable period size if max_periods is != -1*/

 	unsigned int channels;		/* client's channels */

 	unsigned int *bindings;

 	union {

@@ -326,6 +328,7 @@ struct snd_pcm_direct_open_conf {

 	int ipc_gid;

 	int slowptr;

 	int max_periods;

+	int var_periodsize;

 	snd_config_t *slave;

 	snd_config_t *bindings;

 };

diff --git a/src/pcm/pcm_dmix.c b/src/pcm/pcm_dmix.c

index 825677f..0ab7323 100644

--- a/src/pcm/pcm_dmix.c

+++ b/src/pcm/pcm_dmix.c

@@ -1040,6 +1040,7 @@ int snd_pcm_dmix_open(snd_pcm_t **pcmp, const char *name,

 	dmix->state = SND_PCM_STATE_OPEN;

 	dmix->slowptr = opts->slowptr;

 	dmix->max_periods = opts->max_periods;

+	dmix->var_periodsize = opts->var_periodsize;

 	dmix->sync_ptr = snd_pcm_dmix_sync_ptr;

  retry:

diff --git a/src/pcm/pcm_dshare.c b/src/pcm/pcm_dshare.c

index 29cd6c6..a1fed5d 100644

--- a/src/pcm/pcm_dshare.c

+++ b/src/pcm/pcm_dshare.c

@@ -725,6 +725,7 @@ int snd_pcm_dshare_open(snd_pcm_t **pcmp, const char *name,

 	dshare->state = SND_PCM_STATE_OPEN;

 	dshare->slowptr = opts->slowptr;

 	dshare->max_periods = opts->max_periods;

+	dshare->var_periodsize = opts->var_periodsize;

 	dshare->sync_ptr = snd_pcm_dshare_sync_ptr;

  retry:

diff --git a/src/pcm/pcm_dsnoop.c b/src/pcm/pcm_dsnoop.c

index 1aedf3c..85f0ff4 100644

--- a/src/pcm/pcm_dsnoop.c

+++ b/src/pcm/pcm_dsnoop.c

@@ -606,6 +606,7 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,

 	dsnoop->state = SND_PCM_STATE_OPEN;

 	dsnoop->slowptr = opts->slowptr;

 	dsnoop->max_periods = opts->max_periods;

+	dsnoop->var_periodsize = opts->var_periodsize;

 	dsnoop->sync_ptr = snd_pcm_dsnoop_sync_ptr;

  retry:

-- 

2.9.3

From 8eeee1ab7d7db3110b7b3bb31cfb989304dced94 Mon Sep 17 00:00:00 2001

From: Alexander Jahn <ajahn@de.adit-jv.com>

Date: Fri, 30 Dec 2016 11:59:11 +0530

Subject: [PATCH 04/37] pcm: dshare: enable silence

This issue depends on system load - if the process using dshare is

scheduled fast enough, then there is no noise. A delay of e.g >~2ms

produces hearable noise.

Reproduction with instrumented aplay(sleep every 100th period for a

given time):

During the sleep time of 2000000us (2s) the hardware plays old samples

in a loop before xrun is detected and recovered after the sleep.

This is resolved by placing it in silence, in case of dshare plugin.

Signed-off-by: Alexander Jahn <ajahn@de.adit-jv.com>

Signed-off-by: Andreas Pape <apape@de.adit-jv.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/pcm/pcm_direct.c | 3 ++-

 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pcm/pcm_direct.c b/src/pcm/pcm_direct.c

index f5d922f..0770abc 100644

--- a/src/pcm/pcm_direct.c

+++ b/src/pcm/pcm_direct.c

@@ -1161,7 +1161,8 @@ int snd_pcm_direct_initialize_slave(snd_pcm_direct_t *dmix, snd_pcm_t *spcm, str

 		return ret;

 	}

-	if (dmix->type != SND_PCM_TYPE_DMIX)

+	if (dmix->type != SND_PCM_TYPE_DMIX &&

+	    dmix->type != SND_PCM_TYPE_DSHARE)

 		goto __skip_silencing;

 	ret = snd_pcm_sw_params_set_silence_threshold(spcm, &sw_params, 0);

-- 

2.9.3

From 7570e5d77514d8d8af387da04a010fa2ccaf543c Mon Sep 17 00:00:00 2001

From: "mahendran.k" <mahendran.kuppusamy@in.bosch.com>

Date: Fri, 30 Dec 2016 11:59:27 +0530

Subject: [PATCH 05/37] pcm: rate: fix the hw_ptr update until the boundary

 available

For long time test case, the slave_hw_ptr will exceed the boundary

and wraparound the slave_hw_ptr. This slave boundary wraparound will

cause the rate->hw_ptr to wraparound irrespective of the

rate->boundary availability and due to that the available size goes

wrong.

Hence, to get the correct available size,

- Its necessary to increment the rate->hw_ptr upto the rate->boundary

and then wraparound the rate->hw_ptr.

- While handling fraction part of slave period, rounded value will be

introduced by input_frames(). To eliminate rounding issue on

rate->hw_ptr, subtract last rounded value from rate->hw_ptr and add

new rounded value of present slave_hw_ptr fraction part to

rate->hw_ptr.

Signed-off-by: mahendran.k <mahendran.kuppusamy@in.bosch.com>

Signed-off-by: Mounesh Sutar <mounesh_sutar@mentor.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/pcm/pcm_rate.c | 31 +++++++++++++++++++++++++------

 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c

index 1f830dd..61cf979 100644

--- a/src/pcm/pcm_rate.c

+++ b/src/pcm/pcm_rate.c

@@ -50,7 +50,7 @@ typedef struct _snd_pcm_rate snd_pcm_rate_t;

 struct _snd_pcm_rate {

 	snd_pcm_generic_t gen;

-	snd_pcm_uframes_t appl_ptr, hw_ptr;

+	snd_pcm_uframes_t appl_ptr, hw_ptr, last_slave_hw_ptr;

 	snd_pcm_uframes_t last_commit_ptr;

 	snd_pcm_uframes_t orig_avail_min;

 	snd_pcm_sw_params_t sw_params;

@@ -563,14 +563,31 @@ static inline void snd_pcm_rate_sync_hwptr0(snd_pcm_t *pcm, snd_pcm_uframes_t sl

 {

 	snd_pcm_rate_t *rate = pcm->private_data;

+	snd_pcm_sframes_t slave_hw_ptr_diff = slave_hw_ptr - rate->last_slave_hw_ptr;

+	snd_pcm_sframes_t last_slave_hw_ptr_frac;

+

 	if (pcm->stream != SND_PCM_STREAM_PLAYBACK)

 		return;

-	/* FIXME: boundary overlap of slave hw_ptr isn't evaluated here!

-	 *        e.g. if slave rate is small... 

+

+	if (slave_hw_ptr_diff < 0)

+		slave_hw_ptr_diff += rate->gen.slave->boundary; /* slave boundary wraparound */

+	else if (slave_hw_ptr_diff == 0)

+		return;

+	last_slave_hw_ptr_frac = rate->last_slave_hw_ptr % rate->gen.slave->period_size;

+	/* While handling fraction part fo slave period, rounded value will be

+	 * introduced by input_frames().

+	 * To eliminate rounding issue on rate->hw_ptr, subtract last rounded

+	 * value from rate->hw_ptr and add new rounded value of present

+	 * slave_hw_ptr fraction part to rate->hw_ptr. Hence,

+	 * rate->hw_ptr += [ (no. of updated slave periods * pcm rate period size) -

+	 * 	fractional part of last_slave_hw_ptr rounded value +

+	 * 	fractional part of updated slave hw ptr's rounded value ]

 	 */

-	rate->hw_ptr =

-		(slave_hw_ptr / rate->gen.slave->period_size) * pcm->period_size +

-		rate->ops.input_frames(rate->obj, slave_hw_ptr % rate->gen.slave->period_size);

+	rate->hw_ptr += (

+			(((last_slave_hw_ptr_frac + slave_hw_ptr_diff) / rate->gen.slave->period_size) * pcm->period_size) -

+			rate->ops.input_frames(rate->obj, last_slave_hw_ptr_frac) +

+			rate->ops.input_frames(rate->obj, (last_slave_hw_ptr_frac + slave_hw_ptr_diff) % rate->gen.slave->period_size));

+	rate->last_slave_hw_ptr = slave_hw_ptr;

 	rate->hw_ptr %= pcm->boundary;

 }

@@ -635,6 +652,7 @@ static int snd_pcm_rate_prepare(snd_pcm_t *pcm)

 		return err;

 	*pcm->hw.ptr = 0;

 	*pcm->appl.ptr = 0;

+	rate->last_slave_hw_ptr = 0;

 	err = snd_pcm_rate_init(pcm);

 	if (err < 0)

 		return err;

@@ -650,6 +668,7 @@ static int snd_pcm_rate_reset(snd_pcm_t *pcm)

 		return err;

 	*pcm->hw.ptr = 0;

 	*pcm->appl.ptr = 0;

+	rate->last_slave_hw_ptr = 0;

 	err = snd_pcm_rate_init(pcm);

 	if (err < 0)

 		return err;

-- 

2.9.3

From 88e4ae27bb4e47029ed57cc8e02fb1ddf2157fd9 Mon Sep 17 00:00:00 2001

From: Andreas Pape <apape@de.adit-jv.com>

Date: Mon, 19 Dec 2016 12:37:50 +0900

Subject: [PATCH 06/37] plugin: dynamically update avail_min on slave

mmapped capture access on some plugins can fetch data from

slave in the 'background'. A subsequent snd_pcm_wait waits

for too long time to reach avail_min threshold again.

Waiting too long leads to xruns on other devices waiting for

the capture data.

As a fix the avail_min on slave is recalculated dynamically.

V2: updated patch to fix within 80 characters per line

Signed-off-by: Andreas Pape <apape@de.adit-jv.com>

Signed-off-by: Jiada Wang <jiada_wang@mentor.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/pcm/pcm_plugin.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++-

 1 file changed, 63 insertions(+), 1 deletion(-)

diff --git a/src/pcm/pcm_plugin.c b/src/pcm/pcm_plugin.c

index e53c5bb..5b65ac3 100644

--- a/src/pcm/pcm_plugin.c

+++ b/src/pcm/pcm_plugin.c

@@ -535,6 +535,68 @@ static int snd_pcm_plugin_status(snd_pcm_t *pcm, snd_pcm_status_t * status)

 	return 0;

 }

+static int snd_pcm_plugin_may_wait_for_avail_min(snd_pcm_t *pcm,

+						 snd_pcm_uframes_t avail)

+{

+	if (pcm->stream == SND_PCM_STREAM_CAPTURE &&

+	    pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED &&

+	    pcm->access != SND_PCM_ACCESS_RW_NONINTERLEAVED) {

+		/* mmap access on capture device already consumes data from

+		 * slave in avail_update operation. Entering snd_pcm_wait after

+		 * having already consumed some fragments leads to waiting for

+		 * too long time, as slave will unnecessarily wait for avail_min

+		 * condition reached again. To avoid unnecessary wait times we

+		 * adapt the avail_min threshold on slave dynamically. Just

+		 * modifying slave->avail_min as a shortcut and lightweight

+		 * solution does not work for all slave plugin types and in

+		 * addition it will not propagate the change through all

+		 * downstream plugins, so we have to use the sw_params API.

+		 * note: reading fragmental parts from slave will only happen

+		 * in case

+		 * a) the slave can provide contineous hw_ptr between periods

+		 * b) avail_min does not match one slave_period

+		 */

+		snd_pcm_plugin_t *plugin = pcm->private_data;

+		snd_pcm_t *slave = plugin->gen.slave;

+		snd_pcm_uframes_t needed_slave_avail_min;

+		snd_pcm_sframes_t available;

+

+		/* update, as it might have changed. This will also call

+		 * avail_update on slave and also can return error

+		 */

+		available = snd_pcm_avail_update(pcm);

+		if (available < 0)

+			return 0;

+

+		if (available >= pcm->avail_min)

+			/* don't wait at all. As we can't configure avail_min

+			 * of slave to 0 return here

+			 */

+			return 0;

+

+		needed_slave_avail_min = pcm->avail_min - available;

+		if (slave->avail_min != needed_slave_avail_min) {

+			snd_pcm_sw_params_t *swparams;

+			snd_pcm_sw_params_alloca(&swparams);

+			/* pray that changing sw_params while running is

+			 * properly implemented in all downstream plugins...

+			 * it's legal but not commonly used.

+			 */

+			snd_pcm_sw_params_current(slave, swparams);

+			/* snd_pcm_sw_params_set_avail_min() restricts setting

+			 * to >= period size. This conflicts at least with our

+			 * dshare patch which allows combining multiple periods

+			 * or with slaves which return hw postions between

+			 * periods -> set directly in sw_param structure

+			 */

+			swparams->avail_min = needed_slave_avail_min;

+			snd_pcm_sw_params(slave, swparams);

+		}

+		avail = available;

+	}

+	return snd_pcm_generic_may_wait_for_avail_min(pcm, avail);

+}

+

 const snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops = {

 	.status = snd_pcm_plugin_status,

 	.state = snd_pcm_generic_state,

@@ -564,7 +626,7 @@ const snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops = {

 	.poll_descriptors_count = snd_pcm_generic_poll_descriptors_count,

 	.poll_descriptors = snd_pcm_generic_poll_descriptors,

 	.poll_revents = snd_pcm_generic_poll_revents,

-	.may_wait_for_avail_min = snd_pcm_generic_may_wait_for_avail_min,

+	.may_wait_for_avail_min = snd_pcm_plugin_may_wait_for_avail_min,

 };

 #endif

-- 

2.9.3

From ff1f669df4b05da3c44dc4a79ce00233fe9de9b7 Mon Sep 17 00:00:00 2001

From: Andreas Pape <apape@de.adit-jv.com>

Date: Mon, 19 Dec 2016 12:37:51 +0900

Subject: [PATCH 07/37] rate: dynamic update avail_min on slave

Signed-off-by: Andreas Pape <apape@de.adit-jv.com>

Signed-off-by: Jiada Wang <jiada_wang@mentor.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/pcm/pcm_plugin.c | 4 ++--

 src/pcm/pcm_plugin.h | 3 +++

 src/pcm/pcm_rate.c   | 2 +-

 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/pcm/pcm_plugin.c b/src/pcm/pcm_plugin.c

index 5b65ac3..ad4a102 100644

--- a/src/pcm/pcm_plugin.c

+++ b/src/pcm/pcm_plugin.c

@@ -535,8 +535,8 @@ static int snd_pcm_plugin_status(snd_pcm_t *pcm, snd_pcm_status_t * status)

 	return 0;

 }

-static int snd_pcm_plugin_may_wait_for_avail_min(snd_pcm_t *pcm,

-						 snd_pcm_uframes_t avail)

+int snd_pcm_plugin_may_wait_for_avail_min(snd_pcm_t *pcm,

+					  snd_pcm_uframes_t avail)

 {

 	if (pcm->stream == SND_PCM_STREAM_CAPTURE &&

 	    pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED &&

diff --git a/src/pcm/pcm_plugin.h b/src/pcm/pcm_plugin.h

index 217f075..95aacb3 100644

--- a/src/pcm/pcm_plugin.h

+++ b/src/pcm/pcm_plugin.h

@@ -50,6 +50,8 @@ typedef struct {

 /* make local functions really local */

 #define snd_pcm_plugin_init \

 	snd1_pcm_plugin_init

+#define snd_pcm_plugin_may_wait_for_avail_min \

+	snd1_pcm_plugin_may_wait_for_avail_min

 #define snd_pcm_plugin_fast_ops \

 	snd1_pcm_plugin_fast_ops

 #define snd_pcm_plugin_undo_read_generic \

@@ -64,6 +66,7 @@ typedef struct {

 void snd_pcm_plugin_init(snd_pcm_plugin_t *plugin);

 snd_pcm_sframes_t snd_pcm_plugin_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames);

 snd_pcm_sframes_t snd_pcm_plugin_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames);

+int snd_pcm_plugin_may_wait_for_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t avail);

 extern const snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops;

diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c

index 61cf979..cbb7618 100644

--- a/src/pcm/pcm_rate.c

+++ b/src/pcm/pcm_rate.c

@@ -1213,7 +1213,7 @@ static const snd_pcm_fast_ops_t snd_pcm_rate_fast_ops = {

 	.poll_descriptors_count = snd_pcm_generic_poll_descriptors_count,

 	.poll_descriptors = snd_pcm_generic_poll_descriptors,

 	.poll_revents = snd_pcm_rate_poll_revents,

-	.may_wait_for_avail_min = snd_pcm_generic_may_wait_for_avail_min,

+	.may_wait_for_avail_min = snd_pcm_plugin_may_wait_for_avail_min,

 };

 static const snd_pcm_ops_t snd_pcm_rate_ops = {

-- 

2.9.3

From 6f7eaf92e7de73eb32bd97bad83a14fcb0f408f7 Mon Sep 17 00:00:00 2001

From: Takashi Sakamoto <o-takashi@sakamocchi.jp>

Date: Wed, 30 Nov 2016 00:44:32 +0900

Subject: [PATCH 08/37] topology: fix unused-const-variable warning

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

Last year, unused static const variable was added, then compiler generates

a below warning.

dapm.c:43:30: warning: ‘widget_control_map’ defined but not used [-Wunused-const-variable=]

 static const struct map_elem widget_control_map[] = {

                              ^~~~~~~~~~~~~~~~~~

This commit removes it.

Fixes: 01a0e1a1c219 ("topology: Add DAPM object parser")

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>

Acked-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/topology/dapm.c | 8 --------

 1 file changed, 8 deletions(-)

diff --git a/src/topology/dapm.c b/src/topology/dapm.c

index e830751..8c585a7 100644

--- a/src/topology/dapm.c

+++ b/src/topology/dapm.c

@@ -39,14 +39,6 @@ static const struct map_elem widget_map[] = {

 	{"dai_link", SND_SOC_TPLG_DAPM_DAI_LINK},

 };

-/* mapping of widget kcontrol text names to types */

-static const struct map_elem widget_control_map[] = {

-	{"volsw", SND_SOC_TPLG_DAPM_CTL_VOLSW},

-	{"enum_double", SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE},

-	{"enum_virt", SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT},

-	{"enum_value", SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE},

-};

-

 static int lookup_widget(const char *w)

 {

 	unsigned int i;

-- 

2.9.3

From 1eddf1f918845d1e6cbcac5516319b20cad80f2f Mon Sep 17 00:00:00 2001

From: Adam Goode <agoode@google.com>

Date: Tue, 3 Jan 2017 08:33:42 -0500

Subject: [PATCH 09/37] seq: improve documentation about new get pid/card

 functions

Document the technique for determining if the running kernel supports

the new snd_seq_client_info_get_pid and snd_seq_client_info_get_card

functions. Also add a little information about how to use these

functions and add some cross references.

Signed-off-by: Adam Goode <agoode@google.com>

Signed-off-by: Takashi Iwai <tiwai@suse.de>

---

 src/seq/seq.c | 44 ++++++++++++++++++++++++++++++++++++++++++--

 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/seq/seq.c b/src/seq/seq.c

index 9279830..b206e2f 100644

--- a/src/seq/seq.c

+++ b/src/seq/seq.c

@@ -1530,7 +1530,25 @@ int snd_seq_client_info_get_error_bounce(const snd_seq_client_info_t *info)

  * \param info client_info container

  * \return card number or -1 if value is not available.

  *

- * Only available for SND_SEQ_KERNEL_CLIENT clients.

+ * Only available for #SND_SEQ_KERNEL_CLIENT clients.

+ *

+ * The card number can be used to query state about the hardware