Merge "asoc: codecs: Add new class-H driver for wcd937x" (3de80a4a) · Commits · e / devices / android_kernel_fairphone_FP4

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
		@@ -1540,12 +1540,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;
		}

		@@ -1941,18 +1941,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;
		@@ -1961,8 +1958,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,
		@@ -1982,8 +1977,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;