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

Commit 7adc34e4 authored by Laxminath Kasam's avatar Laxminath Kasam
Browse files

asoc: codecs: Add new class-H driver for wcd937x 



Add new class-H driver with sequences to support
both class-H and class-AB modes on wcd937x variants.

Change-Id: Ie109f3d951af1e8a0079dd39ab2fe1e9883bd6c2
Signed-off-by: default avatarLaxminath Kasam <lkasam@codeaurora.org>
parent 838f0b88

asoc/codecs/Kbuild

+1 −0
Original line number Diff line number Diff line
@@ -98,6 +98,7 @@ ifdef CONFIG_WCD9XXX_CODEC_CORE 
endif



ifdef CONFIG_SND_SOC_WCD9XXX_V2

	WCD9XXX_OBJS += wcd-clsh.o

	WCD9XXX_OBJS += wcd9xxx-common-v2.o

	WCD9XXX_OBJS += wcd9xxx-resmgr-v2.o

	WCD9XXX_OBJS += wcdcal-hwdep.o

asoc/codecs/bolero/rx-macro.c

+4 −11
Original line number Diff line number Diff line
@@ -1535,12 +1535,12 @@ static void rx_macro_hd2_control(struct snd_soc_codec *codec, 


	switch (interp_idx) {

	case INTERP_HPHL:

		hd2_scale_reg = BOLERO_CDC_RX_RX1_RX_PATH_SEC3;

		hd2_enable_reg = BOLERO_CDC_RX_RX1_RX_PATH_CFG0;

		hd2_scale_reg = BOLERO_CDC_RX_RX0_RX_PATH_SEC3;

		hd2_enable_reg = BOLERO_CDC_RX_RX0_RX_PATH_CFG0;

		break;

	case INTERP_HPHR:

		hd2_scale_reg = BOLERO_CDC_RX_RX2_RX_PATH_SEC3;

		hd2_enable_reg = BOLERO_CDC_RX_RX2_RX_PATH_CFG0;

		hd2_scale_reg = BOLERO_CDC_RX_RX1_RX_PATH_SEC3;

		hd2_enable_reg = BOLERO_CDC_RX_RX1_RX_PATH_CFG0;

		break;

	}
@@ -1908,18 +1908,15 @@ static void rx_macro_hphdelay_lutbypass(struct snd_soc_codec *codec, 
					struct rx_macro_priv *rx_priv,

					u16 interp_idx, int event)

{

	u8 hph_dly_mask = 0;

	u16 hph_lut_bypass_reg = 0;

	u16 hph_comp_ctrl7 = 0;



	switch (interp_idx) {

	case INTERP_HPHL:

		hph_dly_mask = 1;

		hph_lut_bypass_reg = BOLERO_CDC_RX_TOP_HPHL_COMP_LUT;

		hph_comp_ctrl7 = BOLERO_CDC_RX_COMPANDER0_CTL7;

		break;

	case INTERP_HPHR:

		hph_dly_mask = 2;

		hph_lut_bypass_reg = BOLERO_CDC_RX_TOP_HPHR_COMP_LUT;

		hph_comp_ctrl7 = BOLERO_CDC_RX_COMPANDER1_CTL7;

		break;
@@ -1928,8 +1925,6 @@ static void rx_macro_hphdelay_lutbypass(struct snd_soc_codec *codec, 
	}



	if (hph_lut_bypass_reg && SND_SOC_DAPM_EVENT_ON(event)) {

		snd_soc_update_bits(codec, BOLERO_CDC_RX_CLSH_TEST0,

				    hph_dly_mask, 0x0);

		if (interp_idx == INTERP_HPHL) {

			if (rx_priv->is_ear_mode_on)

				snd_soc_update_bits(codec,
@@ -1947,8 +1942,6 @@ static void rx_macro_hphdelay_lutbypass(struct snd_soc_codec *codec, 
	}



	if (hph_lut_bypass_reg && SND_SOC_DAPM_EVENT_OFF(event)) {

		snd_soc_update_bits(codec, BOLERO_CDC_RX_CLSH_TEST0,

				    hph_dly_mask, hph_dly_mask);

		snd_soc_update_bits(codec, BOLERO_CDC_RX_RX0_RX_PATH_CFG1,

					0x02, 0x00);

		snd_soc_update_bits(codec, hph_lut_bypass_reg, 0x80, 0x00);

asoc/codecs/wcd-clsh.c

0 → 100644
+575 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2015-2018, 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

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/module.h>

#include <linux/slab.h>

#include <sound/soc.h>

#include <linux/kernel.h>

#include <linux/delay.h>

#include <asoc/wcd9xxx_registers.h>

#include "wcd-clsh.h"



#define WCD_USLEEP_RANGE 50



static void (*clsh_state_fp[NUM_CLSH_STATES])(struct snd_soc_codec *,

					      struct wcd_clsh_cdc_info *,

					      u8 req_state, bool en, int mode);



static const char *mode_to_str(int mode)

{

	switch (mode) {

	case CLS_H_NORMAL:

		return WCD_CLSH_STRINGIFY(CLS_H_NORMAL);

	case CLS_H_HIFI:

		return WCD_CLSH_STRINGIFY(CLS_H_HIFI);

	case CLS_H_LOHIFI:

		return WCD_CLSH_STRINGIFY(CLS_H_LOHIFI);

	case CLS_H_LP:

		return WCD_CLSH_STRINGIFY(CLS_H_LP);

	case CLS_H_ULP:

		return WCD_CLSH_STRINGIFY(CLS_H_ULP);

	case CLS_AB:

		return WCD_CLSH_STRINGIFY(CLS_AB);

	case CLS_AB_HIFI:

		return WCD_CLSH_STRINGIFY(CLS_AB_HIFI);

	default:

		return WCD_CLSH_STRINGIFY(CLS_H_INVALID);

	};

}



static const char *state_to_str(u8 state, char *buf, size_t buflen)

{

	int i;

	int cnt = 0;

	/*

	 * This array of strings should match with enum wcd_clsh_state_bit.

	 */

	static const char *const states[] = {

		"STATE_EAR",

		"STATE_HPH_L",

		"STATE_HPH_R",

		"STATE_AUX",

	};



	if (state == WCD_CLSH_STATE_IDLE) {

		snprintf(buf, buflen, "[STATE_IDLE]");

		goto done;

	}



	buf[0] = '\0';

	for (i = 0; i < ARRAY_SIZE(states); i++) {

		if (!(state & (1 << i)))

			continue;

		cnt = snprintf(buf, buflen - cnt - 1, "%s%s%s", buf,

			       buf[0] == '\0' ? "[" : "|",

			       states[i]);

	}

	if (cnt > 0)

		strlcat(buf + cnt, "]", buflen);



done:

	if (buf[0] == '\0')

		snprintf(buf, buflen, "[STATE_UNKNOWN]");

	return buf;

}



static inline int wcd_clsh_get_int_mode(struct wcd_clsh_cdc_info *clsh_d,

					int clsh_state)

{

	int mode;



	if ((clsh_state != WCD_CLSH_STATE_EAR) &&

	    (clsh_state != WCD_CLSH_STATE_HPHL) &&

	    (clsh_state != WCD_CLSH_STATE_HPHR) &&

	    (clsh_state != WCD_CLSH_STATE_AUX))

		mode = CLS_NONE;

	else

		mode = clsh_d->interpolator_modes[ffs(clsh_state)];



	return mode;

}



static inline void wcd_clsh_set_int_mode(struct wcd_clsh_cdc_info *clsh_d,

					int clsh_state, int mode)

{

	if ((clsh_state != WCD_CLSH_STATE_EAR) &&

	    (clsh_state != WCD_CLSH_STATE_HPHL) &&

	    (clsh_state != WCD_CLSH_STATE_HPHR) &&

	    (clsh_state != WCD_CLSH_STATE_AUX))

		return;



	clsh_d->interpolator_modes[ffs(clsh_state)] = mode;

}



static inline void wcd_clsh_set_buck_mode(struct snd_soc_codec *codec,

					  int mode)

{

	if (mode == CLS_H_HIFI || mode == CLS_H_LOHIFI ||

	    mode == CLS_AB_HIFI)

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    0x08, 0x08); /* set to HIFI */

	else

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    0x08, 0x00); /* set to default */

}



static inline void wcd_clsh_set_flyback_mode(struct snd_soc_codec *codec,

					     int mode)

{

	if (mode == CLS_H_HIFI || mode == CLS_H_LOHIFI ||

	    mode == CLS_AB_HIFI) {

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    0x04, 0x04);

		snd_soc_update_bits(codec, WCD9XXX_FLYBACK_VNEG_CTRL_4,

				    0xF0, 0x80);

	} else {

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    0x04, 0x00); /* set to Default */

		snd_soc_update_bits(codec, WCD9XXX_FLYBACK_VNEG_CTRL_4,

				    0xF0, 0x70);

	}

}



static inline void wcd_clsh_force_iq_ctl(struct snd_soc_codec *codec,

					 int mode, bool enable)

{

	if (enable) {

		snd_soc_update_bits(codec, WCD9XXX_FLYBACK_VNEGDAC_CTRL_2,

				    0xE0, 0xA0);

		/* 100usec delay is needed as per HW requirement */

		usleep_range(100, 110);

		snd_soc_update_bits(codec, WCD9XXX_CLASSH_MODE_3,

				    0x02, 0x02);

		snd_soc_update_bits(codec, WCD9XXX_CLASSH_MODE_2,

				    0xFF, 0x1C);

		if (mode == CLS_H_LOHIFI) {

			snd_soc_update_bits(codec, WCD9XXX_HPH_NEW_INT_PA_MISC2,

					    0x20, 0x20);

			snd_soc_update_bits(codec, WCD9XXX_RX_BIAS_HPH_LOWPOWER,

					    0xF0, 0xC0);

			snd_soc_update_bits(codec, WCD9XXX_HPH_PA_CTL1,

					    0x0E, 0x02);

		}

	} else {

		snd_soc_update_bits(codec, WCD9XXX_HPH_NEW_INT_PA_MISC2,

				    0x20, 0x00);

		snd_soc_update_bits(codec, WCD9XXX_RX_BIAS_HPH_LOWPOWER,

				    0xF0, 0x80);

		snd_soc_update_bits(codec, WCD9XXX_HPH_PA_CTL1,

				    0x0E, 0x06);

	}

}



static void wcd_clsh_buck_ctrl(struct snd_soc_codec *codec,

			       struct wcd_clsh_cdc_info *clsh_d,

			       int mode,

			       bool enable)

{

	/* enable/disable buck */

	if ((enable && (++clsh_d->buck_users == 1)) ||

	   (!enable && (--clsh_d->buck_users == 0))) {

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    (1 << 7), (enable << 7));

		/*

		 * 500us sleep is required after buck enable/disable

		 * as per HW requirement

		 */

		usleep_range(500, 510);

		if (mode == CLS_H_LOHIFI || mode == CLS_H_ULP ||

			mode == CLS_H_HIFI || mode == CLS_H_LP)

			snd_soc_update_bits(codec, WCD9XXX_CLASSH_MODE_3,

					    0x02, 0x00);



		snd_soc_update_bits(codec, WCD9XXX_CLASSH_MODE_2, 0xFF, 0x3A);

		/* 500usec delay is needed as per HW requirement */

		usleep_range(500, 500 + WCD_USLEEP_RANGE);

	}

	dev_dbg(codec->dev, "%s: buck_users %d, enable %d, mode: %s\n",

		__func__, clsh_d->buck_users, enable, mode_to_str(mode));

}



static void wcd_clsh_flyback_ctrl(struct snd_soc_codec *codec,

				  struct wcd_clsh_cdc_info *clsh_d,

				  int mode,

				  bool enable)

{

	/* enable/disable flyback */

	if ((enable && (++clsh_d->flyback_users == 1)) ||

	   (!enable && (--clsh_d->flyback_users == 0))) {

		snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

				    (1 << 6), (enable << 6));

		/*

		 * 100us sleep is required after flyback enable/disable

		 * as per HW requirement

		 */

		usleep_range(100, 110);

		snd_soc_update_bits(codec, WCD9XXX_FLYBACK_VNEGDAC_CTRL_2,

			    0xE0, 0xE0);

		/* 500usec delay is needed as per HW requirement */

		usleep_range(500, 500 + WCD_USLEEP_RANGE);

	}

	dev_dbg(codec->dev, "%s: flyback_users %d, enable %d, mode: %s\n",

		__func__, clsh_d->flyback_users, enable, mode_to_str(mode));

}



static void wcd_clsh_set_hph_mode(struct snd_soc_codec *codec,

				  int mode)

{

	u8 val = 0;



	switch (mode) {

	case CLS_H_NORMAL:

	case CLS_H_LOHIFI:

		val = 0x00;

		break;

	case CLS_AB:

	case CLS_H_ULP:

		val = 0x0C;

		break;

	case CLS_AB_HIFI:

	case CLS_H_HIFI:

		val = 0x08;

		break;

	case CLS_H_LP:

		val = 0x04;

		break;

	default:

		dev_err(codec->dev, "%s:Invalid mode %d\n", __func__, mode);

		return;

	};



	snd_soc_update_bits(codec, WCD9XXX_ANA_HPH, 0x0C, val);

}



static void wcd_clsh_set_flyback_current(struct snd_soc_codec *codec, int mode)

{



	snd_soc_update_bits(codec, WCD9XXX_RX_BIAS_FLYB_BUFF, 0x0F, 0x0A);

	snd_soc_update_bits(codec, WCD9XXX_RX_BIAS_FLYB_BUFF, 0xF0, 0xA0);

	/* Sleep needed to avoid click and pop as per HW requirement */

	usleep_range(100, 110);

}



static void wcd_clsh_set_buck_regulator_mode(struct snd_soc_codec *codec,

					     int mode)

{

	snd_soc_update_bits(codec, WCD9XXX_ANA_RX_SUPPLIES,

			    0x02, 0x00);

}



static void wcd_clsh_state_ear_aux(struct snd_soc_codec *codec,

				  struct wcd_clsh_cdc_info *clsh_d,

				  u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");

}



static void wcd_clsh_state_hph_aux(struct snd_soc_codec *codec,

				  struct wcd_clsh_cdc_info *clsh_d,

				  u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");

}



static void wcd_clsh_state_hph_ear(struct snd_soc_codec *codec,

				  struct wcd_clsh_cdc_info *clsh_d,

				  u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");

}



static void wcd_clsh_state_hph_st(struct snd_soc_codec *codec,

				  struct wcd_clsh_cdc_info *clsh_d,

				  u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");

}



static void wcd_clsh_state_hph_r(struct snd_soc_codec *codec,

				 struct wcd_clsh_cdc_info *clsh_d,

				 u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");



	if (mode == CLS_H_NORMAL) {

		dev_dbg(codec->dev, "%s: Normal mode not applicable for hph_r\n",

			__func__);

		return;

	}



	if (is_enable) {

		wcd_clsh_set_buck_regulator_mode(codec, mode);

		wcd_clsh_set_flyback_mode(codec, mode);

		wcd_clsh_force_iq_ctl(codec, mode, true);

		wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_flyback_current(codec, mode);

		wcd_clsh_set_buck_mode(codec, mode);

		wcd_clsh_buck_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_hph_mode(codec, mode);

	} else {

		wcd_clsh_set_hph_mode(codec, CLS_H_NORMAL);



		/* buck and flyback set to default mode and disable */

		wcd_clsh_flyback_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_buck_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_force_iq_ctl(codec, CLS_H_NORMAL, false);

		wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL);

		wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL);

	}

}



static void wcd_clsh_state_hph_l(struct snd_soc_codec *codec,

				 struct wcd_clsh_cdc_info *clsh_d,

				 u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");



	if (mode == CLS_H_NORMAL) {

		dev_dbg(codec->dev, "%s: Normal mode not applicable for hph_l\n",

			__func__);

		return;

	}



	if (is_enable) {

		wcd_clsh_set_buck_regulator_mode(codec, mode);

		wcd_clsh_set_flyback_mode(codec, mode);

		wcd_clsh_force_iq_ctl(codec, mode, true);

		wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_flyback_current(codec, mode);

		wcd_clsh_set_buck_mode(codec, mode);

		wcd_clsh_buck_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_hph_mode(codec, mode);

	} else {

		wcd_clsh_set_hph_mode(codec, CLS_H_NORMAL);



		/* set buck and flyback to Default Mode */

		wcd_clsh_flyback_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_buck_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_force_iq_ctl(codec, CLS_H_NORMAL, false);

		wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL);

		wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL);

	}

}



static void wcd_clsh_state_aux(struct snd_soc_codec *codec,

			      struct wcd_clsh_cdc_info *clsh_d,

			      u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");



	if (is_enable) {

		wcd_clsh_set_buck_mode(codec, mode);

		wcd_clsh_set_flyback_mode(codec, mode);

		wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_flyback_current(codec, mode);

		wcd_clsh_buck_ctrl(codec, clsh_d, mode, true);

	} else {

		wcd_clsh_buck_ctrl(codec, clsh_d, mode, false);

		wcd_clsh_flyback_ctrl(codec, clsh_d, mode, false);

		wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL);

		wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL);

	}

}



static void wcd_clsh_state_ear(struct snd_soc_codec *codec,

		struct wcd_clsh_cdc_info *clsh_d,

		u8 req_state, bool is_enable, int mode)

{

	dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode),

		is_enable ? "enable" : "disable");



	if (is_enable) {

		wcd_clsh_set_buck_regulator_mode(codec, mode);

		wcd_clsh_set_flyback_mode(codec, mode);

		wcd_clsh_force_iq_ctl(codec, mode, true);

		wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_flyback_current(codec, mode);

		wcd_clsh_set_buck_mode(codec, mode);

		wcd_clsh_buck_ctrl(codec, clsh_d, mode, true);

		wcd_clsh_set_hph_mode(codec, mode);

	} else {

		wcd_clsh_set_hph_mode(codec, CLS_H_NORMAL);



		/* set buck and flyback to Default Mode */

		wcd_clsh_flyback_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_buck_ctrl(codec, clsh_d, CLS_H_NORMAL, false);

		wcd_clsh_force_iq_ctl(codec, CLS_H_NORMAL, false);

		wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL);

		wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL);

	}

}



static void wcd_clsh_state_err(struct snd_soc_codec *codec,

		struct wcd_clsh_cdc_info *clsh_d,

		u8 req_state, bool is_enable, int mode)

{

	char msg[128];



	dev_err(codec->dev,

		"%s Wrong request for class H state machine requested to %s %s\n",

		__func__, is_enable ? "enable" : "disable",

		state_to_str(req_state, msg, sizeof(msg)));

}



/*

 * Function: wcd_clsh_is_state_valid

 * Params: state

 * Description:

 * Provides information on valid states of Class H configuration

 */

static bool wcd_clsh_is_state_valid(u8 state)

{

	switch (state) {

	case WCD_CLSH_STATE_IDLE:

	case WCD_CLSH_STATE_EAR:

	case WCD_CLSH_STATE_HPHL:

	case WCD_CLSH_STATE_HPHR:

	case WCD_CLSH_STATE_HPH_ST:

	case WCD_CLSH_STATE_AUX:

	case WCD_CLSH_STATE_HPHL_AUX:

	case WCD_CLSH_STATE_HPHR_AUX:

	case WCD_CLSH_STATE_HPH_ST_AUX:

	case WCD_CLSH_STATE_EAR_AUX:

		return true;

	default:

		return false;

	};

}



/*

 * Function: wcd_cls_h_fsm

 * Params: codec, cdc_clsh_d, req_state, req_type, clsh_event

 * Description:

 * This function handles PRE DAC and POST DAC conditions of different devices

 * and updates class H configuration of different combination of devices

 * based on validity of their states. cdc_clsh_d will contain current

 * class h state information

 */

void wcd_cls_h_fsm(struct snd_soc_codec *codec,

		struct wcd_clsh_cdc_info *cdc_clsh_d,

		u8 clsh_event, u8 req_state,

		int int_mode)

{

	u8 old_state, new_state;

	char msg0[128], msg1[128];



	switch (clsh_event) {

	case WCD_CLSH_EVENT_PRE_DAC:

		old_state = cdc_clsh_d->state;

		new_state = old_state | req_state;



		if (!wcd_clsh_is_state_valid(new_state)) {

			dev_err(codec->dev,

				"%s: Class-H not a valid new state: %s\n",

				__func__,

				state_to_str(new_state, msg0, sizeof(msg0)));

			return;

		}

		if (new_state == old_state) {

			dev_err(codec->dev,

				"%s: Class-H already in requested state: %s\n",

				__func__,

				state_to_str(new_state, msg0, sizeof(msg0)));

			return;

		}

		cdc_clsh_d->state = new_state;

		wcd_clsh_set_int_mode(cdc_clsh_d, req_state, int_mode);

		(*clsh_state_fp[new_state]) (codec, cdc_clsh_d, req_state,

					     CLSH_REQ_ENABLE, int_mode);

		dev_dbg(codec->dev,

			"%s: ClassH state transition from %s to %s\n",

			__func__, state_to_str(old_state, msg0, sizeof(msg0)),

			state_to_str(cdc_clsh_d->state, msg1, sizeof(msg1)));

		break;

	case WCD_CLSH_EVENT_POST_PA:

		old_state = cdc_clsh_d->state;

		new_state = old_state & (~req_state);

		if (new_state < NUM_CLSH_STATES) {

			if (!wcd_clsh_is_state_valid(old_state)) {

				dev_err(codec->dev,

					"%s:Invalid old state:%s\n",

					__func__,

					state_to_str(old_state, msg0,

						     sizeof(msg0)));

				return;

			}

			if (new_state == old_state) {

				dev_err(codec->dev,

					"%s: Class-H already in requested state: %s\n",

					__func__,

					state_to_str(new_state, msg0,

						     sizeof(msg0)));

				return;

			}

			(*clsh_state_fp[old_state]) (codec, cdc_clsh_d,

					req_state, CLSH_REQ_DISABLE,

					int_mode);

			cdc_clsh_d->state = new_state;

			wcd_clsh_set_int_mode(cdc_clsh_d, req_state, CLS_NONE);

			dev_dbg(codec->dev, "%s: ClassH state transition from %s to %s\n",

				__func__, state_to_str(old_state, msg0,

						       sizeof(msg0)),

				state_to_str(cdc_clsh_d->state, msg1,

					     sizeof(msg1)));

		}

		break;

	};

}

EXPORT_SYMBOL(wcd_cls_h_fsm);



/*

 * wcd_cls_h_init: Called to init clsh info

 *

 * @clsh: pointer for clsh state information.

 */

void wcd_cls_h_init(struct wcd_clsh_cdc_info *clsh)

{

	int i;



	clsh->state = WCD_CLSH_STATE_IDLE;



	for (i = 0; i < NUM_CLSH_STATES; i++)

		clsh_state_fp[i] = wcd_clsh_state_err;



	clsh_state_fp[WCD_CLSH_STATE_EAR] = wcd_clsh_state_ear;

	clsh_state_fp[WCD_CLSH_STATE_HPHL] = wcd_clsh_state_hph_l;

	clsh_state_fp[WCD_CLSH_STATE_HPHR] = wcd_clsh_state_hph_r;

	clsh_state_fp[WCD_CLSH_STATE_HPH_ST] = wcd_clsh_state_hph_st;

	clsh_state_fp[WCD_CLSH_STATE_AUX] = wcd_clsh_state_aux;

	clsh_state_fp[WCD_CLSH_STATE_HPHL_AUX] = wcd_clsh_state_hph_aux;

	clsh_state_fp[WCD_CLSH_STATE_HPHR_AUX] = wcd_clsh_state_hph_aux;

	clsh_state_fp[WCD_CLSH_STATE_HPH_ST_AUX] =

						wcd_clsh_state_hph_aux;

	clsh_state_fp[WCD_CLSH_STATE_EAR_AUX] = wcd_clsh_state_ear_aux;

	clsh_state_fp[WCD_CLSH_STATE_HPHL_EAR] = wcd_clsh_state_hph_ear;

	clsh_state_fp[WCD_CLSH_STATE_HPHR_EAR] = wcd_clsh_state_hph_ear;

	clsh_state_fp[WCD_CLSH_STATE_HPH_ST_EAR] = wcd_clsh_state_hph_ear;

	/* Set interpolaotr modes to NONE */

	wcd_clsh_set_int_mode(clsh, WCD_CLSH_STATE_EAR, CLS_NONE);

	wcd_clsh_set_int_mode(clsh, WCD_CLSH_STATE_HPHL, CLS_NONE);

	wcd_clsh_set_int_mode(clsh, WCD_CLSH_STATE_HPHR, CLS_NONE);

	wcd_clsh_set_int_mode(clsh, WCD_CLSH_STATE_AUX, CLS_NONE);

	clsh->flyback_users = 0;

	clsh->buck_users = 0;

}

EXPORT_SYMBOL(wcd_cls_h_init);



MODULE_DESCRIPTION("WCD Class-H Driver");

MODULE_LICENSE("GPL v2");

asoc/codecs/wcd-clsh.h

0 → 100644
+104 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2015-2018, 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

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#ifndef _WCD_CLSH

#define _WCD_CLSH



#include <linux/stringify.h>



#define WCD_CLSH_STRINGIFY(s)  __stringify(s)

#define CLSH_REQ_ENABLE true

#define CLSH_REQ_DISABLE false



#define WCD_CLSH_EVENT_PRE_DAC 0x01

#define WCD_CLSH_EVENT_POST_PA 0x02

/*

 * Basic states for Class H state machine.

 * represented as a bit mask within a u8 data type

 * bit 0: EAR mode

 * bit 1: HPH Left mode

 * bit 2: HPH Right mode

 * bit 3: AUX mode

 */

#define	WCD_CLSH_STATE_IDLE 0x00

#define	WCD_CLSH_STATE_EAR (0x01 << 0)

#define	WCD_CLSH_STATE_HPHL (0x01 << 1)

#define	WCD_CLSH_STATE_HPHR (0x01 << 2)

#define	WCD_CLSH_STATE_AUX (0x01 << 3)



/*

 * Though number of CLSH states is 4, max state should be 5

 * because state array index starts from 1.

 */

#define WCD_CLSH_STATE_MAX 5

#define NUM_CLSH_STATES (0x01 << WCD_CLSH_STATE_MAX)



/* Derived State: Bits 1 and 2 should be set for Headphone stereo */

#define WCD_CLSH_STATE_HPH_ST (WCD_CLSH_STATE_HPHL | \

			       WCD_CLSH_STATE_HPHR)



#define WCD_CLSH_STATE_HPHL_AUX (WCD_CLSH_STATE_HPHL | \

				    WCD_CLSH_STATE_AUX)

#define WCD_CLSH_STATE_HPHR_AUX (WCD_CLSH_STATE_HPHR | \

				    WCD_CLSH_STATE_AUX)

#define WCD_CLSH_STATE_HPH_ST_AUX (WCD_CLSH_STATE_HPH_ST | \

				      WCD_CLSH_STATE_AUX)

#define WCD_CLSH_STATE_EAR_AUX (WCD_CLSH_STATE_EAR | \

				   WCD_CLSH_STATE_AUX)

#define WCD_CLSH_STATE_HPHL_EAR (WCD_CLSH_STATE_HPHL | \

				     WCD_CLSH_STATE_EAR)

#define WCD_CLSH_STATE_HPHR_EAR (WCD_CLSH_STATE_HPHR | \

				     WCD_CLSH_STATE_EAR)

#define WCD_CLSH_STATE_HPH_ST_EAR (WCD_CLSH_STATE_HPH_ST | \

				       WCD_CLSH_STATE_EAR)



enum {

	CLS_H_NORMAL = 0, /* Class-H Default */

	CLS_H_HIFI, /* Class-H HiFi */

	CLS_H_LP, /* Class-H Low Power */

	CLS_AB, /* Class-AB Low HIFI*/

	CLS_H_LOHIFI, /* LoHIFI */

	CLS_H_ULP, /* Ultra Low power */

	CLS_AB_HIFI, /* Class-AB */

	CLS_NONE, /* None of the above modes */

};



/* Class H data that the codec driver will maintain */

struct wcd_clsh_cdc_info {

	u8 state;

	int flyback_users;

	int buck_users;

	int interpolator_modes[WCD_CLSH_STATE_MAX];

};



#ifdef CONFIG_SND_SOC_WCD9XXX_V2

extern void wcd_cls_h_fsm(struct snd_soc_codec *codec,

		struct wcd_clsh_cdc_info *cdc_clsh_d,

		u8 clsh_event, u8 req_state,

		int int_mode);



extern void wcd_cls_h_init(struct wcd_clsh_cdc_info *clsh);

#else

extern void wcd_cls_h_fsm(struct snd_soc_codec *codec,

		struct wcd_clsh_cdc_info *cdc_clsh_d,

		u8 clsh_event, u8 req_state,

		int int_mode)

{

}



extern void wcd_cls_h_init(struct wcd_clsh_cdc_info *clsh)

{

}

#endif /* CONFIG_SND_SOC_WCD9XXX_V2 */



#endif

asoc/codecs/wcd937x/internal.h

+3 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#ifndef _WCD937X_INTERNAL_H

#define _WCD937X_INTERNAL_H



#include "../wcd-clsh.h"

#include "../wcd-mbhc-v2.h"

#include "asoc/wcd-irq.h"

#include "wcd937x-mbhc.h"
@@ -54,6 +55,8 @@ struct wcd937x_priv { 
	s32 dmic_0_1_clk_cnt;

	s32 dmic_2_3_clk_cnt;

	s32 dmic_4_5_clk_cnt;

	/* class h specific info */

	struct wcd_clsh_cdc_info clsh_info;

	/* mbhc module */

	struct wcd937x_mbhc *mbhc;