Commit 5aaca44d authored by Ian Minett's avatar Ian Minett Committed by Takashi Iwai
Browse files

ALSA: hda/ca0132: Init chip, DSP effects and mixer settings 



This patch adds the framework to set effect parameters: ca0132_effects_set()
and ca0132_setup_defaults() are general functions for parameter setting and
initializing to default values. dspio_set_param() and dspio_set_uint_param()
are lower-level fns to simplify setting individual DSP parameters via an
SCP buffer transfer to the firmware.
The CA0132 chip parameter init code is added in ca0132_init_params().
In chipio_[write,read]_data(), the current chip address is auto-incremented
if no error has occurred.
ca0132_select_out() selects the current output. If autodetect is enabled,
use headphones (if jack detected) or speakers (if no jack).
ca0132_select_mic() selects the current mic in. If autodetect is enabled,
use exterior mic (if jack detected) or built-in mic (if no jack).
Init digital mic and switch between dmic and amic with ca0132_init_dmic(),
ca0132_set_dmic(). amic2 is initialized in ca0132_init_analog_mic2().
Finally, add verb tables for configuring DSP firmware.

Signed-off-by: default avatarIan Minett <ian_minett@creativelabs.com>
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent ef6b2ead

sound/pci/hda/patch_ca0132.c

+700 −32
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include "hda_codec.h"

#include "hda_local.h"

#include "hda_auto_parser.h"

#include "hda_jack.h"



#include "ca0132_regs.h"
@@ -672,22 +673,11 @@ enum ca0132_sample_rate { 
	SR_RATE_UNKNOWN = 0x1F

};



/*

 *  Scp Helper function

 */

enum get_set {

	IS_SET = 0,

	IS_GET = 1,

};



/*

 * Duplicated from ca0110 codec

 */



static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)

{

	if (pin) {

		snd_hda_set_pin_ctl(codec, pin, PIN_HP);

		snd_hda_codec_write(codec, pin, 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);

		if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)

			snd_hda_codec_write(codec, pin, 0,

					    AC_VERB_SET_AMP_GAIN_MUTE,
@@ -701,16 +691,23 @@ static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac) 
static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)

{

	if (pin) {

		snd_hda_set_pin_ctl(codec, pin, PIN_IN |

				    snd_hda_get_default_vref(codec, pin));

		snd_hda_codec_write(codec, pin, 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80);

		if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)

			snd_hda_codec_write(codec, pin, 0,

					    AC_VERB_SET_AMP_GAIN_MUTE,

					    AMP_IN_UNMUTE(0));

	}

	if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP))

	if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP)) {

		snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE,

				    AMP_IN_UNMUTE(0));



		/* init to 0 dB and unmute. */

		snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,

					 HDA_AMP_VOLMASK, 0x5a);

		snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,

					 HDA_AMP_MUTE, 0);

	}

}



static int _add_switch(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
@@ -774,11 +771,18 @@ enum dsp_download_state { 
 */



struct ca0132_spec {

	const struct hda_verb *base_init_verbs;

	const struct hda_verb *base_exit_verbs;

	const struct hda_verb *init_verbs[5];

	unsigned int num_init_verbs;  /* exclude base init verbs */

	struct auto_pin_cfg autocfg;



	/* Nodes configurations */

	struct hda_multi_out multiout;

	hda_nid_t out_pins[AUTO_CFG_MAX_OUTS];

	hda_nid_t dacs[AUTO_CFG_MAX_OUTS];

	hda_nid_t hp_dac;

	unsigned int num_outputs;

	hda_nid_t input_pins[AUTO_PIN_LAST];

	hda_nid_t adcs[AUTO_PIN_LAST];

	hda_nid_t dig_out;
@@ -788,7 +792,7 @@ struct ca0132_spec { 
	long curr_hp_volume[2];

	long curr_speaker_switch;

	const char *input_labels[AUTO_PIN_LAST];

	struct hda_pcm pcm_rec[2]; /* PCM information */

	struct hda_pcm pcm_rec[5]; /* PCM information */



	/* chip access */

	struct mutex chipio_mutex; /* chip access mutex */
@@ -803,6 +807,18 @@ struct ca0132_spec { 
	unsigned int scp_resp_header;

	unsigned int scp_resp_data[4];

	unsigned int scp_resp_count;



	/* mixer and effects related */

	unsigned char dmic_ctl;

	int cur_out_type;

	int cur_mic_type;

	long vnode_lvol[VNODES_COUNT];

	long vnode_rvol[VNODES_COUNT];

	long vnode_lswitch[VNODES_COUNT];

	long vnode_rswitch[VNODES_COUNT];

	long effects_switch[EFFECTS_COUNT];

	long voicefx_val;

	long cur_mic_boost;

};



/*
@@ -886,6 +902,7 @@ static int chipio_write_address(struct hda_codec *codec, 
 */

static int chipio_write_data(struct hda_codec *codec, unsigned int data)

{

	struct ca0132_spec *spec = codec->spec;

	int res;



	/* send low 16 bits of the data */
@@ -897,6 +914,10 @@ static int chipio_write_data(struct hda_codec *codec, unsigned int data) 
				  data >> 16);

	}



	/*If no error encountered, automatically increment the address

	as per chip behaviour*/

	spec->curr_chip_addx = (res != -EIO) ?

					(spec->curr_chip_addx + 4) : ~0UL;

	return res;

}
@@ -926,6 +947,7 @@ static int chipio_write_data_multiple(struct hda_codec *codec, 
 */

static int chipio_read_data(struct hda_codec *codec, unsigned int *data)

{

	struct ca0132_spec *spec = codec->spec;

	int res;



	/* post read */
@@ -943,6 +965,10 @@ static int chipio_read_data(struct hda_codec *codec, unsigned int *data) 
					   0);

	}



	/*If no error encountered, automatically increment the address

	as per chip behaviour*/

	spec->curr_chip_addx = (res != -EIO) ?

					(spec->curr_chip_addx + 4) : ~0UL;

	return res;

}
@@ -1418,6 +1444,21 @@ static int dspio_scp(struct hda_codec *codec, 
	return status;

}



/*

 * Set DSP parameters

 */

static int dspio_set_param(struct hda_codec *codec, int mod_id,

			int req, void *data, unsigned int len)

{

	return dspio_scp(codec, mod_id, req, SCP_SET, data, len, NULL, NULL);

}



static int dspio_set_uint_param(struct hda_codec *codec, int mod_id,

			int req, unsigned int data)

{

	return dspio_set_param(codec, mod_id, req, &data, sizeof(unsigned int));

}



/*

 * Allocate a DSP DMA channel via an SCP message

 */
@@ -2597,6 +2638,9 @@ static bool dspload_wait_loaded(struct hda_codec *codec) 
	return false;

}



/*

 * Controls stuffs.

 */



/*

 * Mixer controls helpers.
@@ -2698,6 +2742,300 @@ static int ca0132_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);

}



/*

 * Select the active output.

 * If autodetect is enabled, output will be selected based on jack detection.

 * If jack inserted, headphone will be selected, else built-in speakers

 * If autodetect is disabled, output will be selected based on selection.

 */

static int ca0132_select_out(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	unsigned int pin_ctl;

	int jack_present;

	int auto_jack;

	unsigned int tmp;

	int err;



	snd_printdd(KERN_INFO "ca0132_select_out\n");



	snd_hda_power_up(codec);



	auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];



	if (auto_jack)

		jack_present = snd_hda_jack_detect(codec, spec->out_pins[1]);

	else

		jack_present =

			spec->vnode_lswitch[VNID_HP_SEL - VNODE_START_NID];



	if (jack_present)

		spec->cur_out_type = HEADPHONE_OUT;

	else

		spec->cur_out_type = SPEAKER_OUT;



	if (spec->cur_out_type == SPEAKER_OUT) {

		snd_printdd(KERN_INFO "ca0132_select_out speaker\n");

		/*speaker out config*/

		tmp = FLOAT_ONE;

		err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);

		if (err < 0)

			goto exit;

		/*enable speaker EQ*/

		tmp = FLOAT_ONE;

		err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);

		if (err < 0)

			goto exit;



		/* Setup EAPD */

		snd_hda_codec_write(codec, spec->out_pins[1], 0,

				    VENDOR_CHIPIO_EAPD_SEL_SET, 0x02);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_EAPD_BTLENABLE, 0x00);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    VENDOR_CHIPIO_EAPD_SEL_SET, 0x00);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_EAPD_BTLENABLE, 0x02);



		/* disable headphone node */

		pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,

					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

		snd_hda_codec_write(codec, spec->out_pins[1], 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL,

				    pin_ctl & 0xBF);

		/* enable speaker node */

		pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,

					     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL,

				    pin_ctl | 0x40);

	} else {

		snd_printdd(KERN_INFO "ca0132_select_out hp\n");

		/*headphone out config*/

		tmp = FLOAT_ZERO;

		err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);

		if (err < 0)

			goto exit;

		/*disable speaker EQ*/

		tmp = FLOAT_ZERO;

		err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);

		if (err < 0)

			goto exit;



		/* Setup EAPD */

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    VENDOR_CHIPIO_EAPD_SEL_SET, 0x00);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_EAPD_BTLENABLE, 0x00);

		snd_hda_codec_write(codec, spec->out_pins[1], 0,

				    VENDOR_CHIPIO_EAPD_SEL_SET, 0x02);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_EAPD_BTLENABLE, 0x02);



		/* disable speaker*/

		pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,

					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

		snd_hda_codec_write(codec, spec->out_pins[0], 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL,

				    pin_ctl & 0xBF);

		/* enable headphone*/

		pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,

					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

		snd_hda_codec_write(codec, spec->out_pins[1], 0,

				    AC_VERB_SET_PIN_WIDGET_CONTROL,

				    pin_ctl | 0x40);

	}



exit:

	snd_hda_power_down(codec);



	return err < 0 ? err : 0;

}



static void ca0132_set_dmic(struct hda_codec *codec, int enable);

static int ca0132_mic_boost_set(struct hda_codec *codec, long val);

static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val);



/*

 * Select the active VIP source

 */

static int ca0132_set_vipsource(struct hda_codec *codec, int val)

{

	struct ca0132_spec *spec = codec->spec;

	unsigned int tmp;



	if (!dspload_is_loaded(codec))

		return 0;



	/* if CrystalVoice if off, vipsource should be 0 */

	if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ||

	    (val == 0)) {

		chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0);

		chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);

		chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);

		if (spec->cur_mic_type == DIGITAL_MIC)

			tmp = FLOAT_TWO;

		else

			tmp = FLOAT_ONE;

		dspio_set_uint_param(codec, 0x80, 0x00, tmp);

		tmp = FLOAT_ZERO;

		dspio_set_uint_param(codec, 0x80, 0x05, tmp);

	} else {

		chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_16_000);

		chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_16_000);

		if (spec->cur_mic_type == DIGITAL_MIC)

			tmp = FLOAT_TWO;

		else

			tmp = FLOAT_ONE;

		dspio_set_uint_param(codec, 0x80, 0x00, tmp);

		tmp = FLOAT_ONE;

		dspio_set_uint_param(codec, 0x80, 0x05, tmp);

		msleep(20);

		chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, val);

	}



	return 1;

}



/*

 * Select the active microphone.

 * If autodetect is enabled, mic will be selected based on jack detection.

 * If jack inserted, ext.mic will be selected, else built-in mic

 * If autodetect is disabled, mic will be selected based on selection.

 */

static int ca0132_select_mic(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	int jack_present;

	int auto_jack;



	snd_printdd(KERN_INFO "ca0132_select_mic\n");



	snd_hda_power_up(codec);



	auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];



	if (auto_jack)

		jack_present = snd_hda_jack_detect(codec, spec->input_pins[0]);

	else

		jack_present =

			spec->vnode_lswitch[VNID_AMIC1_SEL - VNODE_START_NID];



	if (jack_present)

		spec->cur_mic_type = LINE_MIC_IN;

	else

		spec->cur_mic_type = DIGITAL_MIC;



	if (spec->cur_mic_type == DIGITAL_MIC) {

		/* enable digital Mic */

		chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_32_000);

		ca0132_set_dmic(codec, 1);

		ca0132_mic_boost_set(codec, 0);

		/* set voice focus */

		ca0132_effects_set(codec, VOICE_FOCUS,

				   spec->effects_switch

				   [VOICE_FOCUS - EFFECT_START_NID]);

	} else {

		/* disable digital Mic */

		chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_96_000);

		ca0132_set_dmic(codec, 0);

		ca0132_mic_boost_set(codec, spec->cur_mic_boost);

		/* disable voice focus */

		ca0132_effects_set(codec, VOICE_FOCUS, 0);

	}



	snd_hda_power_down(codec);



	return 0;

}



/*

 * Set the effects parameters

 */

static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val)

{

	struct ca0132_spec *spec = codec->spec;

	unsigned int on;

	int num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;

	int err = 0;

	int idx = nid - EFFECT_START_NID;



	if ((idx < 0) || (idx >= num_fx))

		return 0; /* no changed */



	/* for out effect, qualify with PE */

	if ((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) {

		/* if PE if off, turn off out effects. */

		if (!spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])

			val = 0;

	}



	/* for in effect, qualify with CrystalVoice */

	if ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID)) {

		/* if CrystalVoice if off, turn off in effects. */

		if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID])

			val = 0;



		/* Voice Focus applies to 2-ch Mic, Digital Mic */

		if ((nid == VOICE_FOCUS) && (spec->cur_mic_type != DIGITAL_MIC))

			val = 0;

	}



	snd_printdd(KERN_INFO, "ca0132_effect_set: nid=0x%x, val=%ld\n",

		    nid, val);



	on = (val == 0) ? FLOAT_ZERO : FLOAT_ONE;

	err = dspio_set_uint_param(codec, ca0132_effects[idx].mid,

				   ca0132_effects[idx].reqs[0], on);



	if (err < 0)

		return 0; /* no changed */



	return 1;

}



/* Check if Mic1 is streaming, if so, stop streaming */

static int stop_mic1(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	unsigned int oldval = snd_hda_codec_read(codec, spec->adcs[0], 0,

						 AC_VERB_GET_CONV, 0);

	if (oldval != 0)

		snd_hda_codec_write(codec, spec->adcs[0], 0,

				    AC_VERB_SET_CHANNEL_STREAMID,

				    0);

	return oldval;

}



/* Resume Mic1 streaming if it was stopped. */

static void resume_mic1(struct hda_codec *codec, unsigned int oldval)

{

	struct ca0132_spec *spec = codec->spec;

	/* Restore the previous stream and channel */

	if (oldval != 0)

		snd_hda_codec_write(codec, spec->adcs[0], 0,

				    AC_VERB_SET_CHANNEL_STREAMID,

				    oldval);

}



/*

 * Set Mic Boost

 */

static int ca0132_mic_boost_set(struct hda_codec *codec, long val)

{

	struct ca0132_spec *spec = codec->spec;

	int ret = 0;



	if (val) /* on */

		ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,

					HDA_INPUT, 0, HDA_AMP_VOLMASK, 3);

	else /* off */

		ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,

					HDA_INPUT, 0, HDA_AMP_VOLMASK, 0);



	return ret;

}



/*

 */

static struct hda_pcm_stream ca0132_pcm_analog_playback = {
@@ -3021,6 +3359,215 @@ static int ca0132_build_controls(struct hda_codec *codec) 
	return 0;

}



static void refresh_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir)

{

	unsigned int caps;



	caps = snd_hda_param_read(codec, nid, dir == HDA_OUTPUT ?

				  AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);

	snd_hda_override_amp_caps(codec, nid, dir, caps);

}



/*

 * Switch between Digital built-in mic and analog mic.

 */

static void ca0132_set_dmic(struct hda_codec *codec, int enable)

{

	struct ca0132_spec *spec = codec->spec;

	unsigned int tmp;

	u8 val;

	unsigned int oldval;



	snd_printdd(KERN_INFO "ca0132_set_dmic: enable=%d\n", enable);



	oldval = stop_mic1(codec);

	ca0132_set_vipsource(codec, 0);

	if (enable) {

		/* set DMic input as 2-ch */

		tmp = FLOAT_TWO;

		dspio_set_uint_param(codec, 0x80, 0x00, tmp);



		val = spec->dmic_ctl;

		val |= 0x80;

		snd_hda_codec_write(codec, spec->input_pins[0], 0,

				    VENDOR_CHIPIO_DMIC_CTL_SET, val);



		if (!(spec->dmic_ctl & 0x20))

			chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 1);

	} else {

		/* set AMic input as mono */

		tmp = FLOAT_ONE;

		dspio_set_uint_param(codec, 0x80, 0x00, tmp);



		val = spec->dmic_ctl;

		/* clear bit7 and bit5 to disable dmic */

		val &= 0x5f;

		snd_hda_codec_write(codec, spec->input_pins[0], 0,

				    VENDOR_CHIPIO_DMIC_CTL_SET, val);



		if (!(spec->dmic_ctl & 0x20))

			chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 0);

	}

	ca0132_set_vipsource(codec, 1);

	resume_mic1(codec, oldval);

}



/*

 * Initialization for Digital Mic.

 */

static void ca0132_init_dmic(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	u8 val;



	/* Setup Digital Mic here, but don't enable.

	 * Enable based on jack detect.

	 */



	/* MCLK uses MPIO1, set to enable.

	 * Bit 2-0: MPIO select

	 * Bit   3: set to disable

	 * Bit 7-4: reserved

	 */

	val = 0x01;

	snd_hda_codec_write(codec, spec->input_pins[0], 0,

			    VENDOR_CHIPIO_DMIC_MCLK_SET, val);



	/* Data1 uses MPIO3. Data2 not use

	 * Bit 2-0: Data1 MPIO select

	 * Bit   3: set disable Data1

	 * Bit 6-4: Data2 MPIO select

	 * Bit   7: set disable Data2

	 */

	val = 0x83;

	snd_hda_codec_write(codec, spec->input_pins[0], 0,

			    VENDOR_CHIPIO_DMIC_PIN_SET, val);



	/* Use Ch-0 and Ch-1. Rate is 48K, mode 1. Disable DMic first.

	 * Bit 3-0: Channel mask

	 * Bit   4: set for 48KHz, clear for 32KHz

	 * Bit   5: mode

	 * Bit   6: set to select Data2, clear for Data1

	 * Bit   7: set to enable DMic, clear for AMic

	 */

	val = 0x23;

	/* keep a copy of dmic ctl val for enable/disable dmic purpuse */

	spec->dmic_ctl = val;

	snd_hda_codec_write(codec, spec->input_pins[0], 0,

			    VENDOR_CHIPIO_DMIC_CTL_SET, val);

}



/*

 * Initialization for Analog Mic 2

 */

static void ca0132_init_analog_mic2(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;



	mutex_lock(&spec->chipio_mutex);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x20);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x2D);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);

	snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,

			    VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);

	mutex_unlock(&spec->chipio_mutex);

}



static void ca0132_refresh_widget_caps(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	int i;

	hda_nid_t nid;



	snd_printdd(KERN_INFO "ca0132_refresh_widget_caps.\n");

	nid = codec->start_nid;

	for (i = 0; i < codec->num_nodes; i++, nid++)

		codec->wcaps[i] = snd_hda_param_read(codec, nid,

						     AC_PAR_AUDIO_WIDGET_CAP);



	for (i = 0; i < spec->multiout.num_dacs; i++)

		refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT);



	for (i = 0; i < spec->num_outputs; i++)

		refresh_amp_caps(codec, spec->out_pins[i], HDA_OUTPUT);



	for (i = 0; i < spec->num_inputs; i++) {

		refresh_amp_caps(codec, spec->adcs[i], HDA_INPUT);

		refresh_amp_caps(codec, spec->input_pins[i], HDA_INPUT);

	}

}



/*

 * Setup default parameters for DSP

 */

static void ca0132_setup_defaults(struct hda_codec *codec)

{

	unsigned int tmp;

	int num_fx;

	int idx, i;



	if (!dspload_is_loaded(codec))

		return;



	/* out, in effects + voicefx */

	num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1;

	for (idx = 0; idx < num_fx; idx++) {

		for (i = 0; i <= ca0132_effects[idx].params; i++) {

			dspio_set_uint_param(codec, ca0132_effects[idx].mid,

					     ca0132_effects[idx].reqs[i],

					     ca0132_effects[idx].def_vals[i]);

		}

	}



	/*remove DSP headroom*/

	tmp = FLOAT_ZERO;

	dspio_set_uint_param(codec, 0x96, 0x3C, tmp);



	/*set speaker EQ bypass attenuation*/

	dspio_set_uint_param(codec, 0x8f, 0x01, tmp);



	/* set AMic1 and AMic2 as mono mic */

	tmp = FLOAT_ONE;

	dspio_set_uint_param(codec, 0x80, 0x00, tmp);

	dspio_set_uint_param(codec, 0x80, 0x01, tmp);



	/* set AMic1 as CrystalVoice input */

	tmp = FLOAT_ONE;

	dspio_set_uint_param(codec, 0x80, 0x05, tmp);



	/* set WUH source */

	tmp = FLOAT_TWO;

	dspio_set_uint_param(codec, 0x31, 0x00, tmp);

}



/*

 * Initialization of flags in chip

 */

static void ca0132_init_flags(struct hda_codec *codec)

{

	chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);

	chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0);

	chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0);

	chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0);

	chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);

	chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1);

}



/*

 * Initialization of parameters in chip

 */

static void ca0132_init_params(struct hda_codec *codec)

{

	chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6);

	chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6);

}



static void ca0132_set_ct_ext(struct hda_codec *codec, int enable)

{
@@ -3038,7 +3585,6 @@ static void ca0132_config(struct hda_codec *codec) 
	struct ca0132_spec *spec = codec->spec;

	struct auto_pin_cfg *cfg = &spec->autocfg;



	codec->pcm_format_first = 1;

	codec->no_sticky_stream = 1;



	/* line-outs */
@@ -3088,16 +3634,115 @@ static void ca0132_config(struct hda_codec *codec) 
	cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;

}



/*

 * Verbs tables.

 */



/* Sends before DSP download. */

static struct hda_verb ca0132_base_init_verbs[] = {

	/*enable ct extension*/

	{0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0x1},

	/*enable DSP node unsol, needed for DSP download*/

	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_DSP},

	{}

};



/* Send at exit. */

static struct hda_verb ca0132_base_exit_verbs[] = {

	/*set afg to D3*/

	{0x01, AC_VERB_SET_POWER_STATE, 0x03},

	/*disable ct extension*/

	{0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0},

	{}

};



/* Other verbs tables.  Sends after DSP download. */

static struct hda_verb ca0132_init_verbs0[] = {

	/* chip init verbs */

	{0x15, 0x70D, 0xF0},

	{0x15, 0x70E, 0xFE},

	{0x15, 0x707, 0x75},

	{0x15, 0x707, 0xD3},

	{0x15, 0x707, 0x09},

	{0x15, 0x707, 0x53},

	{0x15, 0x707, 0xD4},

	{0x15, 0x707, 0xEF},

	{0x15, 0x707, 0x75},

	{0x15, 0x707, 0xD3},

	{0x15, 0x707, 0x09},

	{0x15, 0x707, 0x02},

	{0x15, 0x707, 0x37},

	{0x15, 0x707, 0x78},

	{0x15, 0x53C, 0xCE},

	{0x15, 0x575, 0xC9},

	{0x15, 0x53D, 0xCE},

	{0x15, 0x5B7, 0xC9},

	{0x15, 0x70D, 0xE8},

	{0x15, 0x70E, 0xFE},

	{0x15, 0x707, 0x02},

	{0x15, 0x707, 0x68},

	{0x15, 0x707, 0x62},

	{0x15, 0x53A, 0xCE},

	{0x15, 0x546, 0xC9},

	{0x15, 0x53B, 0xCE},

	{0x15, 0x5E8, 0xC9},

	{0x15, 0x717, 0x0D},

	{0x15, 0x718, 0x20},

	{}

};



static struct hda_verb ca0132_init_verbs1[] = {

	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_HP},

	{0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_AMIC1},

	/* config EAPD */

	{0x0b, 0x78D, 0x00},

	/*{0x0b, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/

	/*{0x10, 0x78D, 0x02},*/

	/*{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/

	{}

};



static void ca0132_init_chip(struct hda_codec *codec)

{

	struct ca0132_spec *spec = codec->spec;

	int num_fx;

	int i;

	unsigned int on;



	mutex_init(&spec->chipio_mutex);



	spec->cur_out_type = SPEAKER_OUT;

	spec->cur_mic_type = DIGITAL_MIC;

	spec->cur_mic_boost = 0;



	for (i = 0; i < VNODES_COUNT; i++) {

		spec->vnode_lvol[i] = 0x5a;

		spec->vnode_rvol[i] = 0x5a;

		spec->vnode_lswitch[i] = 0;

		spec->vnode_rswitch[i] = 0;

	}



	/*

	 * Default states for effects are in ca0132_effects[].

	 */

	num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;

	for (i = 0; i < num_fx; i++) {

		on = (unsigned int)ca0132_effects[i].reqs[0];

		spec->effects_switch[i] = on ? 1 : 0;

	}



	spec->voicefx_val = 0;

	spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID] = 1;

	spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] = 0;



}



static void ca0132_exit_chip(struct hda_codec *codec)

{

	/* put any chip cleanup stuffs here. */



	if (dspload_is_loaded(codec))

		dsp_reset(codec);

}



static void ca0132_set_dsp_msr(struct hda_codec *codec, bool is96k)
@@ -3155,15 +3800,25 @@ static int ca0132_init(struct hda_codec *codec) 
	struct auto_pin_cfg *cfg = &spec->autocfg;

	int i;



	spec->dsp_state = DSP_DOWNLOAD_INIT;

	spec->curr_chip_addx = (unsigned int)INVALID_CHIP_ADDRESS;



	snd_hda_power_up(codec);



	ca0132_init_params(codec);

	ca0132_init_flags(codec);

	snd_hda_sequence_write(codec, spec->base_init_verbs);

#ifdef CONFIG_SND_HDA_DSP_LOADER

	ca0132_download_dsp(codec);

#endif

	ca0132_refresh_widget_caps(codec);

	ca0132_setup_defaults(codec);

	ca0132_init_analog_mic2(codec);

	ca0132_init_dmic(codec);



	for (i = 0; i < spec->num_outputs; i++)

		init_output(codec, spec->out_pins[i], spec->dacs[0]);



	for (i = 0; i < spec->multiout.num_dacs; i++) {

		init_output(codec, spec->out_pins[i],

			    spec->multiout.dac_nids[i]);

	}

	init_output(codec, cfg->hp_pins[0], spec->hp_dac);

	init_output(codec, cfg->dig_out_pins[0], spec->dig_out);



	for (i = 0; i < spec->num_inputs; i++)
@@ -3171,16 +3826,25 @@ static int ca0132_init(struct hda_codec *codec) 


	init_input(codec, cfg->dig_in_pin, spec->dig_in);



	ca0132_set_ct_ext(codec, 1);

	for (i = 0; i < spec->num_init_verbs; i++)

		snd_hda_sequence_write(codec, spec->init_verbs[i]);



	ca0132_select_out(codec);

	ca0132_select_mic(codec);



	snd_hda_power_down(codec);



	return 0;

}





static void ca0132_free(struct hda_codec *codec)

{

	ca0132_set_ct_ext(codec, 0);

	struct ca0132_spec *spec = codec->spec;



	snd_hda_power_up(codec);

	snd_hda_sequence_write(codec, spec->base_exit_verbs);

	ca0132_exit_chip(codec);

	snd_hda_power_down(codec);

	kfree(codec->spec);

}
@@ -3191,8 +3855,6 @@ static struct hda_codec_ops ca0132_patch_ops = { 
	.free = ca0132_free,

};







static int patch_ca0132(struct hda_codec *codec)

{

	struct ca0132_spec *spec;
@@ -3204,6 +3866,12 @@ static int patch_ca0132(struct hda_codec *codec) 
		return -ENOMEM;

	codec->spec = spec;



	spec->base_init_verbs = ca0132_base_init_verbs;

	spec->base_exit_verbs = ca0132_base_exit_verbs;

	spec->init_verbs[0] = ca0132_init_verbs0;

	spec->init_verbs[1] = ca0132_init_verbs1;

	spec->num_init_verbs = 2;



	ca0132_init_chip(codec);



	ca0132_config(codec);

CRA Git | Maintained and supported by SUSTech CRA and CCSE