Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dac630e7 authored by Linux Build Service Account's avatar Linux Build Service Account
Browse files

Merge e15314a5 on remote branch 

Change-Id: Ife0495252331401ff83226ad741b5991ae49cded
parents cf97586e e15314a5

asoc/codecs/bolero/rx-macro.c

+5 −1
Original line number Diff line number Diff line
@@ -1601,6 +1601,8 @@ static int rx_macro_config_classh(struct snd_soc_codec *codec, 
				0x40, 0x40);

		break;

	case INTERP_AUX:

		snd_soc_update_bits(codec, BOLERO_CDC_RX_RX2_RX_PATH_CFG0,

				0x08, 0x08);

		snd_soc_update_bits(codec, BOLERO_CDC_RX_RX2_RX_PATH_CFG0,

				0x10, 0x10);

		break;
@@ -2140,14 +2142,16 @@ static int rx_macro_enable_interp_clk(struct snd_soc_codec *codec, 
			(interp_idx * RX_MACRO_RX_PATH_OFFSET);

	dsm_reg = BOLERO_CDC_RX_RX0_RX_PATH_DSM_CTL +

			(interp_idx * RX_MACRO_RX_PATH_OFFSET);

	if (interp_idx == INTERP_AUX)

		dsm_reg = BOLERO_CDC_RX_RX2_RX_PATH_DSM_CTL;

	rx_cfg2_reg = BOLERO_CDC_RX_RX0_RX_PATH_CFG2 +

			(interp_idx * RX_MACRO_RX_PATH_OFFSET);



	if (SND_SOC_DAPM_EVENT_ON(event)) {

		if (rx_priv->main_clk_users[interp_idx] == 0) {

			snd_soc_update_bits(codec, dsm_reg, 0x01, 0x01);

			/* Main path PGA mute enable */

			snd_soc_update_bits(codec, main_reg, 0x10, 0x10);

			snd_soc_update_bits(codec, dsm_reg, 0x01, 0x01);

			/* Clk enable */

			snd_soc_update_bits(codec, main_reg, 0x20, 0x20);

			snd_soc_update_bits(codec, rx_cfg2_reg, 0x03, 0x03);

asoc/codecs/bolero/wsa-macro.c

+73 −0
Original line number Diff line number Diff line
@@ -223,6 +223,7 @@ struct wsa_macro_priv { 
	int is_softclip_on[WSA_MACRO_SOFTCLIP_MAX];

	int softclip_clk_users[WSA_MACRO_SOFTCLIP_MAX];

	struct wsa_macro_bcl_pmic_params bcl_pmic_params;

	int wsa_digital_mute_status[WSA_MACRO_RX_MAX];

};



static int wsa_macro_config_ear_spkr_gain(struct snd_soc_codec *codec,
@@ -1710,6 +1711,66 @@ static int wsa_macro_set_ec_hq(struct snd_kcontrol *kcontrol, 
	return 0;

}



static int wsa_macro_get_rx_mute_status(struct snd_kcontrol *kcontrol,

			       struct snd_ctl_elem_value *ucontrol)

{



	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);

	struct device *wsa_dev = NULL;

	struct wsa_macro_priv *wsa_priv = NULL;

	int wsa_rx_shift = ((struct soc_multi_mixer_control *)

		       kcontrol->private_value)->shift;



	if (!wsa_macro_get_data(codec, &wsa_dev, &wsa_priv, __func__))

		return -EINVAL;



	ucontrol->value.integer.value[0] =

		wsa_priv->wsa_digital_mute_status[wsa_rx_shift];

	return 0;

}



static int wsa_macro_set_rx_mute_status(struct snd_kcontrol *kcontrol,

			       struct snd_ctl_elem_value *ucontrol)

{

	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);

	struct device *wsa_dev = NULL;

	struct wsa_macro_priv *wsa_priv = NULL;

	int value = ucontrol->value.integer.value[0];

	int wsa_rx_shift = ((struct soc_multi_mixer_control *)

			kcontrol->private_value)->shift;



	if (!wsa_macro_get_data(codec, &wsa_dev, &wsa_priv, __func__))

		return -EINVAL;



	switch (wsa_rx_shift) {

	case 0:

		snd_soc_update_bits(codec, BOLERO_CDC_WSA_RX0_RX_PATH_CTL,

				0x10, value << 4);

		break;

	case 1:

		snd_soc_update_bits(codec, BOLERO_CDC_WSA_RX1_RX_PATH_CTL,

				0x10, value << 4);

		break;

	case 2:

		snd_soc_update_bits(codec, BOLERO_CDC_WSA_RX0_RX_PATH_MIX_CTL,

				0x10, value << 4);

		break;

	case 3:

		snd_soc_update_bits(codec, BOLERO_CDC_WSA_RX1_RX_PATH_MIX_CTL,

				0x10, value << 4);

		break;

	default:

		pr_err("%s: invalid argument rx_shift = %d\n", __func__,

			wsa_rx_shift);

		return -EINVAL;

	}



	dev_dbg(codec->dev, "%s: WSA Digital Mute RX %d Enable %d\n",

		__func__, wsa_rx_shift, value);

	wsa_priv->wsa_digital_mute_status[wsa_rx_shift] = value;

	return 0;

}



static int wsa_macro_get_compander(struct snd_kcontrol *kcontrol,

			       struct snd_ctl_elem_value *ucontrol)

{
@@ -2016,6 +2077,18 @@ static const struct snd_kcontrol_new wsa_macro_snd_controls[] = { 
	SOC_SINGLE_SX_TLV("WSA_RX1 Digital Volume",

			  BOLERO_CDC_WSA_RX1_RX_VOL_CTL,

			  0, -84, 40, digital_gain),

	SOC_SINGLE_EXT("WSA_RX0 Digital Mute", SND_SOC_NOPM, WSA_MACRO_RX0, 1,

			0, wsa_macro_get_rx_mute_status,

			wsa_macro_set_rx_mute_status),

	SOC_SINGLE_EXT("WSA_RX1 Digital Mute", SND_SOC_NOPM, WSA_MACRO_RX1, 1,

			0, wsa_macro_get_rx_mute_status,

			wsa_macro_set_rx_mute_status),

	SOC_SINGLE_EXT("WSA_RX0_MIX Digital Mute", SND_SOC_NOPM,

			WSA_MACRO_RX_MIX0, 1, 0, wsa_macro_get_rx_mute_status,

			wsa_macro_set_rx_mute_status),

	SOC_SINGLE_EXT("WSA_RX1_MIX Digital Mute", SND_SOC_NOPM,

			WSA_MACRO_RX_MIX1, 1, 0, wsa_macro_get_rx_mute_status,

			wsa_macro_set_rx_mute_status),

	SOC_SINGLE_EXT("WSA_COMP1 Switch", SND_SOC_NOPM, WSA_MACRO_COMP1, 1, 0,

		wsa_macro_get_compander, wsa_macro_set_compander),

	SOC_SINGLE_EXT("WSA_COMP2 Switch", SND_SOC_NOPM, WSA_MACRO_COMP2, 1, 0,

asoc/codecs/wcd937x/wcd937x.c

+3 −1
Original line number Diff line number Diff line
@@ -129,6 +129,9 @@ static int wcd937x_init_reg(struct snd_soc_codec *codec) 
	snd_soc_update_bits(codec, WCD937X_RX_OCP_CTL, 0x0F, 0x02);

	snd_soc_update_bits(codec, WCD937X_HPH_SURGE_HPHLR_SURGE_EN, 0xFF,

			    0xD9);

	snd_soc_update_bits(codec, WCD937X_MICB1_TEST_CTL_1, 0xFF, 0xFA);

	snd_soc_update_bits(codec, WCD937X_MICB2_TEST_CTL_1, 0xFF, 0xFA);

	snd_soc_update_bits(codec, WCD937X_MICB3_TEST_CTL_1, 0xFF, 0xFA);

	return 0;

}
@@ -1384,7 +1387,6 @@ static int wcd937x_get_logical_addr(struct swr_device *swr_dev) 
		dev_err(&swr_dev->dev,

			"%s get devnum %d for dev addr %lx failed\n",

			__func__, devnum, swr_dev->addr);

		swr_remove_device(swr_dev);

		return ret;

	}

	swr_dev->dev_num = devnum;

asoc/msm-compress-q6-v2.c

+15 −1
Original line number Diff line number Diff line 
/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.

/* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -1602,6 +1602,7 @@ static int msm_compr_playback_open(struct snd_compr_stream *cstream) 
	struct msm_compr_audio *prtd = NULL;

	struct msm_compr_pdata *pdata =

			snd_soc_platform_get_drvdata(rtd->platform);

	enum apr_subsys_state q6_state;



	pr_debug("%s\n", __func__);

	if (pdata->is_in_use[rtd->dai_link->id] == true) {
@@ -1609,6 +1610,12 @@ static int msm_compr_playback_open(struct snd_compr_stream *cstream) 
			__func__, rtd->dai_link->cpu_dai_name, -EBUSY);

		return -EBUSY;

	}



	q6_state = apr_get_q6_state();

	if (q6_state == APR_SUBSYS_DOWN) {

		pr_debug("%s: adsp is down\n", __func__);

		return -ENETRESET;

	}

	prtd = kzalloc(sizeof(struct msm_compr_audio), GFP_KERNEL);

	if (prtd == NULL) {

		pr_err("Failed to allocate memory for msm_compr_audio\n");
@@ -1703,8 +1710,15 @@ static int msm_compr_capture_open(struct snd_compr_stream *cstream) 
	struct msm_compr_audio *prtd;

	struct msm_compr_pdata *pdata =

			snd_soc_platform_get_drvdata(rtd->platform);

	enum apr_subsys_state q6_state;



	pr_debug("%s\n", __func__);



	q6_state = apr_get_q6_state();

	if (q6_state == APR_SUBSYS_DOWN) {

		pr_debug("%s: adsp is down\n", __func__);

		return -ENETRESET;

	}

	prtd = kzalloc(sizeof(struct msm_compr_audio), GFP_KERNEL);

	if (prtd == NULL) {

		pr_err("Failed to allocate memory for msm_compr_audio\n");

asoc/msm-lsm-client.c

+52 −10
Original line number Diff line number Diff line
@@ -202,7 +202,8 @@ static int lsm_lab_buffer_sanity(struct lsm_priv *prtd, 
}



static void lsm_event_handler(uint32_t opcode, uint32_t token,

			      uint32_t *payload, void *priv)

			      uint32_t *payload, uint16_t client_size,

				void *priv)

{

	unsigned long flags;

	struct lsm_priv *prtd = priv;
@@ -285,6 +286,12 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 
	}



	case LSM_SESSION_EVENT_DETECTION_STATUS:

                if (client_size < 3 * sizeof(uint8_t)) {

			dev_err(rtd->dev,

					"%s: client_size has invalid size[%d]\n",

					__func__, client_size);

			return;

		}

		status = (uint16_t)((uint8_t *)payload)[0];

		payload_size = (uint16_t)((uint8_t *)payload)[2];

		index = 4;
@@ -294,6 +301,12 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 
		break;



	case LSM_SESSION_EVENT_DETECTION_STATUS_V2:

		if (client_size < 2 * sizeof(uint8_t)) {

			dev_err(rtd->dev,

					"%s: client_size has invalid size[%d]\n",

					__func__, client_size);

			return;

		}

		status = (uint16_t)((uint8_t *)payload)[0];

		payload_size = (uint16_t)((uint8_t *)payload)[1];

		index = 2;
@@ -303,6 +316,12 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 
		break;



	case LSM_SESSION_EVENT_DETECTION_STATUS_V3:

		if (client_size < 2 * (sizeof(uint32_t) + sizeof(uint8_t))) {

			dev_err(rtd->dev,

					"%s: client_size has invalid size[%d]\n",

					__func__, client_size);

			return;

		}

		event_ts_lsw = ((uint32_t *)payload)[0];

		event_ts_msw = ((uint32_t *)payload)[1];

		status = (uint16_t)((uint8_t *)payload)[8];
@@ -316,6 +335,13 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 


	case LSM_SESSION_DETECTION_ENGINE_GENERIC_EVENT: {

		struct snd_lsm_event_status *tmp;

		if (client_size < 2 * sizeof(uint16_t)) {

			dev_err(rtd->dev,

					"%s: client_size has invalid size[%d]\n",

					__func__, client_size);

			return;

		}





		status = ((uint16_t *)payload)[0];

		payload_size = ((uint16_t *)payload)[1];
@@ -338,8 +364,16 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 
		prtd->det_event = tmp;

		prtd->det_event->status = status;

		prtd->det_event->payload_size = payload_size;

		memcpy(prtd->det_event->payload, &((uint8_t *)payload)[4],

		       payload_size);

		if (client_size >= payload_size + 4) {

			memcpy(prtd->det_event->payload,

				&((uint8_t *)payload)[4], payload_size);

		} else {

			spin_unlock_irqrestore(&prtd->event_lock, flags);

			dev_err(rtd->dev,

				"%s: Failed to copy memory with invalid size = %d\n",

				__func__, payload_size);

			return;

		}

		prtd->event_avail = 1;

		spin_unlock_irqrestore(&prtd->event_lock, flags);

		wake_up(&prtd->event_wait);
@@ -381,12 +415,20 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token, 
		prtd->event_status->payload_size = payload_size;



		if (likely(prtd->event_status)) {

			if (client_size >= (payload_size + index)) {

				memcpy(prtd->event_status->payload,

					&((uint8_t *)payload)[index],

					payload_size);

				prtd->event_avail = 1;

				spin_unlock_irqrestore(&prtd->event_lock, flags);

				wake_up(&prtd->event_wait);

			} else {

				spin_unlock_irqrestore(&prtd->event_lock, flags);

				dev_err(rtd->dev,

						"%s: Failed to copy memory with invalid size = %d\n",

						__func__, payload_size);

				return;

			}

		} else {

			spin_unlock_irqrestore(&prtd->event_lock, flags);

			dev_err(rtd->dev,