[mirror_ubuntu-bionic-kernel.git] / sound / pci / hda / alc680_quirks.c

/*
 * ALC680 quirk models
 * included by patch_realtek.c
 */

/* ALC680 models */
enum {
	ALC680_AUTO,
	ALC680_BASE,
	ALC680_MODEL_LAST,
};

#define ALC680_DIGIN_NID	ALC880_DIGIN_NID
#define ALC680_DIGOUT_NID	ALC880_DIGOUT_NID
#define alc680_modes		alc260_modes

static const hda_nid_t alc680_dac_nids[3] = {
	/* Lout1, Lout2, hp */
	0x02, 0x03, 0x04
};

static const hda_nid_t alc680_adc_nids[3] = {
	/* ADC0-2 */
	/* DMIC, MIC, Line-in*/
	0x07, 0x08, 0x09
};

/*
 * Analog capture ADC cgange
 */
static hda_nid_t alc680_get_cur_adc(struct hda_codec *codec)
{
	static hda_nid_t pins[] = {0x18, 0x19};
	static hda_nid_t adcs[] = {0x08, 0x09};
	int i;

	for (i = 0; i < ARRAY_SIZE(pins); i++) {
		if (!is_jack_detectable(codec, pins[i]))
			continue;
		if (snd_hda_jack_detect(codec, pins[i]))
			return adcs[i];
	}
	return 0x07;
}

static void alc680_rec_autoswitch(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t nid = alc680_get_cur_adc(codec);
	if (spec->cur_adc && nid != spec->cur_adc) {
		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
		spec->cur_adc = nid;
		snd_hda_codec_setup_stream(codec, nid,
					   spec->cur_adc_stream_tag, 0,
					   spec->cur_adc_format);
	}
}

static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
				      unsigned int stream_tag,
				      unsigned int format,
				      struct snd_pcm_substream *substream)
{
	struct alc_spec *spec = codec->spec;
	hda_nid_t nid = alc680_get_cur_adc(codec);

	spec->cur_adc = nid;
	spec->cur_adc_stream_tag = stream_tag;
	spec->cur_adc_format = format;
	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
	return 0;
}

static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
				      struct snd_pcm_substream *substream)
{
	struct alc_spec *spec = codec->spec;
	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
	spec->cur_adc = 0;
	return 0;
}

static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
	.substreams = 1, /* can be overridden */
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in alc_build_pcms */
	.ops = {
		.prepare = alc680_capture_pcm_prepare,
		.cleanup = alc680_capture_pcm_cleanup
	},
};

static const struct snd_kcontrol_new alc680_base_mixer[] = {
	/* output mixer control */
	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
	HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
	{ }
};

static const struct hda_bind_ctls alc680_bind_cap_vol = {
	.ops = &snd_hda_bind_vol,
	.values = {
		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
		0
	},
};

static const struct hda_bind_ctls alc680_bind_cap_switch = {
	.ops = &snd_hda_bind_sw,
	.values = {
		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
		0
	},
};

static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
	HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
	HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
	{ } /* end */
};

/*
 * generic initialization of ADC, input mixers and output mixers
 */
static const struct hda_verb alc680_init_verbs[] = {
	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},

	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},

	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},

	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT   | AC_USRSP_EN},
	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT  | AC_USRSP_EN},
	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT  | AC_USRSP_EN},

	{ }
};

/* toggle speaker-output according to the hp-jack state */
static void alc680_base_setup(struct hda_codec *codec)
{
	struct alc_spec *spec = codec->spec;

	spec->autocfg.hp_pins[0] = 0x16;
	spec->autocfg.speaker_pins[0] = 0x14;
	spec->autocfg.speaker_pins[1] = 0x15;
	spec->autocfg.num_inputs = 2;
	spec->autocfg.inputs[0].pin = 0x18;
	spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
	spec->autocfg.inputs[1].pin = 0x19;
	spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
	spec->automute = 1;
	spec->automute_mode = ALC_AUTOMUTE_AMP;
}

static void alc680_unsol_event(struct hda_codec *codec,
					   unsigned int res)
{
	if ((res >> 26) == ALC_HP_EVENT)
		alc_hp_automute(codec);
	if ((res >> 26) == ALC_MIC_EVENT)
		alc680_rec_autoswitch(codec);
}

static void alc680_inithook(struct hda_codec *codec)
{
	alc_hp_automute(codec);
	alc680_rec_autoswitch(codec);
}

/*
 * configuration and preset
 */
static const char * const alc680_models[ALC680_MODEL_LAST] = {
	[ALC680_BASE]		= "base",
	[ALC680_AUTO]		= "auto",
};

static const struct snd_pci_quirk alc680_cfg_tbl[] = {
	SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
	{}
};

static const struct alc_config_preset alc680_presets[] = {
	[ALC680_BASE] = {
		.mixers = { alc680_base_mixer },
		.cap_mixer =  alc680_master_capture_mixer,
		.init_verbs = { alc680_init_verbs },
		.num_dacs = ARRAY_SIZE(alc680_dac_nids),
		.dac_nids = alc680_dac_nids,
		.dig_out_nid = ALC680_DIGOUT_NID,
		.num_channel_mode = ARRAY_SIZE(alc680_modes),
		.channel_mode = alc680_modes,
		.unsol_event = alc680_unsol_event,
		.setup = alc680_base_setup,
		.init_hook = alc680_inithook,

	},
};
Commit	Line	Data
1d045db9 TI	1	/*
	2	* ALC680 quirk models
	3	* included by patch_realtek.c
	4	*/
	5
	6	/* ALC680 models */
	7	enum {
	8	ALC680_AUTO,
	9	ALC680_BASE,
	10	ALC680_MODEL_LAST,
	11	};
	12
	13	#define ALC680_DIGIN_NID ALC880_DIGIN_NID
	14	#define ALC680_DIGOUT_NID ALC880_DIGOUT_NID
	15	#define alc680_modes alc260_modes
	16
	17	static const hda_nid_t alc680_dac_nids[3] = {
	18	/* Lout1, Lout2, hp */
	19	0x02, 0x03, 0x04
	20	};
	21
	22	static const hda_nid_t alc680_adc_nids[3] = {
	23	/* ADC0-2 */
	24	/* DMIC, MIC, Line-in*/
	25	0x07, 0x08, 0x09
	26	};
	27
	28	/*
	29	* Analog capture ADC cgange
	30	*/
	31	static hda_nid_t alc680_get_cur_adc(struct hda_codec *codec)
	32	{
	33	static hda_nid_t pins[] = {0x18, 0x19};
	34	static hda_nid_t adcs[] = {0x08, 0x09};
	35	int i;
	36
	37	for (i = 0; i < ARRAY_SIZE(pins); i++) {
	38	if (!is_jack_detectable(codec, pins[i]))
	39	continue;
	40	if (snd_hda_jack_detect(codec, pins[i]))
	41	return adcs[i];
	42	}
	43	return 0x07;
	44	}
	45
	46	static void alc680_rec_autoswitch(struct hda_codec *codec)
	47	{
	48	struct alc_spec *spec = codec->spec;
	49	hda_nid_t nid = alc680_get_cur_adc(codec);
	50	if (spec->cur_adc && nid != spec->cur_adc) {
	51	__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
	52	spec->cur_adc = nid;
	53	snd_hda_codec_setup_stream(codec, nid,
	54	spec->cur_adc_stream_tag, 0,
	55	spec->cur_adc_format);
	56	}
	57	}
	58
	59	static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
	60	struct hda_codec *codec,
	61	unsigned int stream_tag,
	62	unsigned int format,
	63	struct snd_pcm_substream *substream)
	64	{
65	struct alc_spec *spec = codec->spec;
66	hda_nid_t nid = alc680_get_cur_adc(codec);
67
68	spec->cur_adc = nid;
69	spec->cur_adc_stream_tag = stream_tag;
70	spec->cur_adc_format = format;
71	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
72	return 0;
73	}
74
75	static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
76	struct hda_codec *codec,
77	struct snd_pcm_substream *substream)
78	{
79	struct alc_spec *spec = codec->spec;
80	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
81	spec->cur_adc = 0;
82	return 0;
83	}
84
85	static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
86	.substreams = 1, /* can be overridden */
87	.channels_min = 2,
88	.channels_max = 2,
89	/* NID is set in alc_build_pcms */
90	.ops = {
91	.prepare = alc680_capture_pcm_prepare,
92	.cleanup = alc680_capture_pcm_cleanup
93	},
94	};
95
96	static const struct snd_kcontrol_new alc680_base_mixer[] = {
97	/* output mixer control */
98	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
99	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
100	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
101	HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
102	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
103	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
104	HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
105	{ }
106	};
107
108	static const struct hda_bind_ctls alc680_bind_cap_vol = {
109	.ops = &snd_hda_bind_vol,
110	.values = {
111	HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
112	HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
113	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
114	0
115	},
116	};
117
118	static const struct hda_bind_ctls alc680_bind_cap_switch = {
119	.ops = &snd_hda_bind_sw,
120	.values = {
121	HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
122	HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
123	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
124	0
125	},
126	};
127
128	static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
129	HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
130	HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
131	{ } /* end */
132	};
133
134	/*
135	* generic initialization of ADC, input mixers and output mixers
136	*/
137	static const struct hda_verb alc680_init_verbs[] = {
138	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
139	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
140	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
141
142	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
143	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
144	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
145	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
146	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
147	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
148
149	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
150	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
151	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
152	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
153	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
154
155	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT \| AC_USRSP_EN},
156	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT \| AC_USRSP_EN},
157	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT \| AC_USRSP_EN},
158
159	{ }
160	};
161
162	/* toggle speaker-output according to the hp-jack state */
163	static void alc680_base_setup(struct hda_codec *codec)
164	{
165	struct alc_spec *spec = codec->spec;
166
167	spec->autocfg.hp_pins[0] = 0x16;
168	spec->autocfg.speaker_pins[0] = 0x14;
169	spec->autocfg.speaker_pins[1] = 0x15;
170	spec->autocfg.num_inputs = 2;
171	spec->autocfg.inputs[0].pin = 0x18;
172	spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
173	spec->autocfg.inputs[1].pin = 0x19;
174	spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
175	spec->automute = 1;
176	spec->automute_mode = ALC_AUTOMUTE_AMP;
177	}
178
179	static void alc680_unsol_event(struct hda_codec *codec,
180	unsigned int res)
181	{
182	if ((res >> 26) == ALC_HP_EVENT)
183	alc_hp_automute(codec);
184	if ((res >> 26) == ALC_MIC_EVENT)
185	alc680_rec_autoswitch(codec);
186	}
187
188	static void alc680_inithook(struct hda_codec *codec)
189	{
190	alc_hp_automute(codec);
191	alc680_rec_autoswitch(codec);
192	}
193
194	/*
195	* configuration and preset
196	*/
197	static const char * const alc680_models[ALC680_MODEL_LAST] = {
198	[ALC680_BASE] = "base",
199	[ALC680_AUTO] = "auto",
200	};
201
202	static const struct snd_pci_quirk alc680_cfg_tbl[] = {
203	SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
204	{}
205	};
206
207	static const struct alc_config_preset alc680_presets[] = {
208	[ALC680_BASE] = {
209	.mixers = { alc680_base_mixer },
210	.cap_mixer = alc680_master_capture_mixer,
211	.init_verbs = { alc680_init_verbs },
212	.num_dacs = ARRAY_SIZE(alc680_dac_nids),
213	.dac_nids = alc680_dac_nids,
214	.dig_out_nid = ALC680_DIGOUT_NID,
215	.num_channel_mode = ARRAY_SIZE(alc680_modes),
216	.channel_mode = alc680_modes,
217	.unsol_event = alc680_unsol_event,
218	.setup = alc680_base_setup,
219	.init_hook = alc680_inithook,
220
221	},
222	};