Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* Universal Interface for Intel High Definition Audio Codec

2

* Universal Interface for Intel High Definition Audio Codec

3

*

3

*

4

* HD audio interface patch for Realtek ALC codecs

4

* HD audio interface patch for Realtek ALC codecs

5

*

5

*

6

7

* PeiSen Hou <pshou@realtek.com.tw>

7

* PeiSen Hou <pshou@realtek.com.tw>

8

* Takashi Iwai <tiwai@suse.de>

8

* Takashi Iwai <tiwai@suse.de>

9

* Jonathan Woithe <jwoithe@just42.net>

9

* Jonathan Woithe <jwoithe@just42.net>

10

*

10

*

11

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

11

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

12

* it under the terms of the GNU General Public License as published by

12

* it under the terms of the GNU General Public License as published by

13

* the Free Software Foundation; either version 2 of the License, or

13

* the Free Software Foundation; either version 2 of the License, or

14

* (at your option) any later version.

14

* (at your option) any later version.

15

*

15

*

16

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

16

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

17

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

17

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

18

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

18

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

19

* GNU General Public License for more details.

19

* GNU General Public License for more details.

20

*

20

*

21

* You should have received a copy of the GNU General Public License

21

* You should have received a copy of the GNU General Public License

22

* along with this program; if not, write to the Free Software

22

* along with this program; if not, write to the Free Software

23

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

23

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

24

*/

24

*/

25

26

#include <linux/init.h>

26

#include <linux/init.h>

27

#include <linux/delay.h>

27

#include <linux/delay.h>

28

#include <linux/slab.h>

28

#include <linux/slab.h>

29

#include <linux/pci.h>

29

#include <linux/pci.h>

30

#include <linux/dmi.h>

30

#include <linux/dmi.h>

31

#include <linux/module.h>

31

#include <linux/module.h>

32

#include <sound/core.h>

32

#include <sound/core.h>

33

#include <sound/jack.h>

33

#include <sound/jack.h>

34

#include "hda_codec.h"

34

#include "hda_codec.h"

35

#include "hda_local.h"

35

#include "hda_local.h"

36

#include "hda_auto_parser.h"

36

#include "hda_auto_parser.h"

37

#include "hda_jack.h"

37

#include "hda_jack.h"

38

#include "hda_generic.h"

38

#include "hda_generic.h"

39

40

/* keep halting ALC5505 DSP, for power saving */

40

/* keep halting ALC5505 DSP, for power saving */

41

#define HALT_REALTEK_ALC5505

41

#define HALT_REALTEK_ALC5505

42

43

/* unsol event tags */

43

/* unsol event tags */

44

#define ALC_DCVOL_EVENT 0x08

44

#define ALC_DCVOL_EVENT 0x08

45

46

/* for GPIO Poll */

46

/* for GPIO Poll */

47

#define GPIO_MASK 0x03

47

#define GPIO_MASK 0x03

48

49

/* extra amp-initialization sequence types */

49

/* extra amp-initialization sequence types */

50

enum {

50

enum {

51

ALC_INIT_NONE,

51

ALC_INIT_NONE,

52

ALC_INIT_DEFAULT,

52

ALC_INIT_DEFAULT,

53

ALC_INIT_GPIO1,

53

ALC_INIT_GPIO1,

54

ALC_INIT_GPIO2,

54

ALC_INIT_GPIO2,

55

ALC_INIT_GPIO3,

55

ALC_INIT_GPIO3,

56

};

56

};

57

58

enum {

58

enum {

59

ALC_HEADSET_MODE_UNKNOWN,

59

ALC_HEADSET_MODE_UNKNOWN,

60

ALC_HEADSET_MODE_UNPLUGGED,

60

ALC_HEADSET_MODE_UNPLUGGED,

61

ALC_HEADSET_MODE_HEADSET,

61

ALC_HEADSET_MODE_HEADSET,

62

ALC_HEADSET_MODE_MIC,

62

ALC_HEADSET_MODE_MIC,

63

ALC_HEADSET_MODE_HEADPHONE,

63

ALC_HEADSET_MODE_HEADPHONE,

64

};

64

};

65

66

enum {

66

enum {

67

ALC_HEADSET_TYPE_UNKNOWN,

67

ALC_HEADSET_TYPE_UNKNOWN,

68

ALC_HEADSET_TYPE_CTIA,

68

ALC_HEADSET_TYPE_CTIA,

69

ALC_HEADSET_TYPE_OMTP,

69

ALC_HEADSET_TYPE_OMTP,

70

};

70

};

71

72

struct alc_customize_define {

72

struct alc_customize_define {

73

unsigned int sku_cfg;

73

unsigned int sku_cfg;

74

unsigned char port_connectivity;

74

unsigned char port_connectivity;

75

unsigned char check_sum;

75

unsigned char check_sum;

76

unsigned char customization;

76

unsigned char customization;

77

unsigned char external_amp;

77

unsigned char external_amp;

78

unsigned int enable_pcbeep:1;

78

unsigned int enable_pcbeep:1;

79

unsigned int platform_type:1;

79

unsigned int platform_type:1;

80

unsigned int swap:1;

80

unsigned int swap:1;

81

unsigned int override:1;

81

unsigned int override:1;

82

unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */

82

unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */

83

};

83

};

84

85

struct alc_spec {

85

struct alc_spec {

86

struct hda_gen_spec gen; /* must be at head */

86

struct hda_gen_spec gen; /* must be at head */

87

88

/* codec parameterization */

88

/* codec parameterization */

89

const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */

89

const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */

90

unsigned int num_mixers;

90

unsigned int num_mixers;

91

unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */

91

unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */

92

93

struct alc_customize_define cdefine;

93

struct alc_customize_define cdefine;

94

unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */

94

unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */

95

96

/* inverted dmic fix */

96

/* inverted dmic fix */

97

unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */

97

unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */

98

unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */

98

unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */

99

hda_nid_t inv_dmic_pin;

99

hda_nid_t inv_dmic_pin;

100

101

/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */

101

/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */

102

int mute_led_polarity;

102

int mute_led_polarity;

103

hda_nid_t mute_led_nid;

103

hda_nid_t mute_led_nid;

104

105

unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */

105

unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */

106

107

hda_nid_t headset_mic_pin;

107

hda_nid_t headset_mic_pin;

108

hda_nid_t headphone_mic_pin;

108

hda_nid_t headphone_mic_pin;

109

int current_headset_mode;

109

int current_headset_mode;

110

int current_headset_type;

110

int current_headset_type;

111

112

/* hooks */

112

/* hooks */

113

void (*init_hook)(struct hda_codec *codec);

113

void (*init_hook)(struct hda_codec *codec);

114

#ifdef CONFIG_PM

114

#ifdef CONFIG_PM

115

void (*power_hook)(struct hda_codec *codec);

115

void (*power_hook)(struct hda_codec *codec);

116

#endif

116

#endif

117

void (*shutup)(struct hda_codec *codec);

117

void (*shutup)(struct hda_codec *codec);

118

119

int init_amp;

119

int init_amp;

120

int codec_variant; /* flag for other variants */

120

int codec_variant; /* flag for other variants */

121

unsigned int has_alc5505_dsp:1;

121

unsigned int has_alc5505_dsp:1;

122

unsigned int no_depop_delay:1;

122

unsigned int no_depop_delay:1;

123

124

/* for PLL fix */

124

/* for PLL fix */

125

hda_nid_t pll_nid;

125

hda_nid_t pll_nid;

126

unsigned int pll_coef_idx, pll_coef_bit;

126

unsigned int pll_coef_idx, pll_coef_bit;

127

unsigned int coef0;

127

unsigned int coef0;

128

};

128

};

129

130

/*

130

/*

131

* Append the given mixer and verb elements for the later use

131

* Append the given mixer and verb elements for the later use

132

* The mixer array is referred in build_controls(), and init_verbs are

132

* The mixer array is referred in build_controls(), and init_verbs are

133

* called in init().

133

* called in init().

134

*/

134

*/

135

static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)

135

static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)

136

{

136

{

137

if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))

137

if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))

138

return;

138

return;

139

spec->mixers[spec->num_mixers++] = mix;

139

spec->mixers[spec->num_mixers++] = mix;

140

}

140

}

141

142

/*

142

/*

143

* GPIO setup tables, used in initialization

143

* GPIO setup tables, used in initialization

144

*/

144

*/

145

/* Enable GPIO mask and set output */

145

/* Enable GPIO mask and set output */

146

static const struct hda_verb alc_gpio1_init_verbs[] = {

146

static const struct hda_verb alc_gpio1_init_verbs[] = {

147

{0x01, AC_VERB_SET_GPIO_MASK, 0x01},

147

{0x01, AC_VERB_SET_GPIO_MASK, 0x01},

148

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

148

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

149

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

149

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

150

{ }

150

{ }

151

};

151

};

152

153

static const struct hda_verb alc_gpio2_init_verbs[] = {

153

static const struct hda_verb alc_gpio2_init_verbs[] = {

154

{0x01, AC_VERB_SET_GPIO_MASK, 0x02},

154

{0x01, AC_VERB_SET_GPIO_MASK, 0x02},

155

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},

155

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},

156

{0x01, AC_VERB_SET_GPIO_DATA, 0x02},

156

{0x01, AC_VERB_SET_GPIO_DATA, 0x02},

157

{ }

157

{ }

158

};

158

};

159

160

static const struct hda_verb alc_gpio3_init_verbs[] = {

160

static const struct hda_verb alc_gpio3_init_verbs[] = {

161

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

161

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

162

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},

162

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},

163

{0x01, AC_VERB_SET_GPIO_DATA, 0x03},

163

{0x01, AC_VERB_SET_GPIO_DATA, 0x03},

164

{ }

164

{ }

165

};

165

};

166

167

/*

167

/*

168

* Fix hardware PLL issue

168

* Fix hardware PLL issue

169

* On some codecs, the analog PLL gating control must be off while

169

* On some codecs, the analog PLL gating control must be off while

170

* the default value is 1.

170

* the default value is 1.

171

*/

171

*/

172

static void alc_fix_pll(struct hda_codec *codec)

172

static void alc_fix_pll(struct hda_codec *codec)

173

{

173

{

174

struct alc_spec *spec = codec->spec;

174

struct alc_spec *spec = codec->spec;

175

unsigned int val;

175

unsigned int val;

176

177

if (!spec->pll_nid)

177

if (!spec->pll_nid)

178

return;

178

return;

179

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,

179

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,

180

spec->pll_coef_idx);

180

spec->pll_coef_idx);

181

val = snd_hda_codec_read(codec, spec->pll_nid, 0,

181

val = snd_hda_codec_read(codec, spec->pll_nid, 0,

182

AC_VERB_GET_PROC_COEF, 0);

182

AC_VERB_GET_PROC_COEF, 0);

183

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,

183

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,

184

spec->pll_coef_idx);

184

spec->pll_coef_idx);

185

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,

185

snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,

186

val & ~(1 << spec->pll_coef_bit));

186

val & ~(1 << spec->pll_coef_bit));

187

}

187

}

188

189

static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,

189

static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,

190

unsigned int coef_idx, unsigned int coef_bit)

190

unsigned int coef_idx, unsigned int coef_bit)

191

{

191

{

192

struct alc_spec *spec = codec->spec;

192

struct alc_spec *spec = codec->spec;

193

spec->pll_nid = nid;

193

spec->pll_nid = nid;

194

spec->pll_coef_idx = coef_idx;

194

spec->pll_coef_idx = coef_idx;

195

spec->pll_coef_bit = coef_bit;

195

spec->pll_coef_bit = coef_bit;

196

alc_fix_pll(codec);

196

alc_fix_pll(codec);

197

}

197

}

198

199

/* update the master volume per volume-knob's unsol event */

199

/* update the master volume per volume-knob's unsol event */

200

static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)

200

static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)

201

{

201

{

202

unsigned int val;

202

unsigned int val;

203

struct snd_kcontrol *kctl;

203

struct snd_kcontrol *kctl;

204

struct snd_ctl_elem_value *uctl;

204

struct snd_ctl_elem_value *uctl;

205

206

kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");

206

kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");

207

if (!kctl)

207

if (!kctl)

208

return;

208

return;

209

uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

209

uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

210

if (!uctl)

210

if (!uctl)

211

return;

211

return;

212

val = snd_hda_codec_read(codec, jack->nid, 0,

212

val = snd_hda_codec_read(codec, jack->nid, 0,

213

AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);

213

AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);

214

val &= HDA_AMP_VOLMASK;

214

val &= HDA_AMP_VOLMASK;

215

uctl->value.integer.value[0] = val;

215

uctl->value.integer.value[0] = val;

216

uctl->value.integer.value[1] = val;

216

uctl->value.integer.value[1] = val;

217

kctl->put(kctl, uctl);

217

kctl->put(kctl, uctl);

218

kfree(uctl);

218

kfree(uctl);

219

}

219

}

220

221

static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)

221

static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)

222

{

222

{

223

/* For some reason, the res given from ALC880 is broken.

223

/* For some reason, the res given from ALC880 is broken.

224

Here we adjust it properly. */

224

Here we adjust it properly. */

225

snd_hda_jack_unsol_event(codec, res >> 2);

225

snd_hda_jack_unsol_event(codec, res >> 2);

226

}

226

}

227

228

/* additional initialization for ALC888 variants */

228

/* additional initialization for ALC888 variants */

229

static void alc888_coef_init(struct hda_codec *codec)

229

static void alc888_coef_init(struct hda_codec *codec)

230

{

230

{

231

unsigned int tmp;

231

unsigned int tmp;

232

233

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);

233

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);

234

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

234

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

235

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

235

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

236

if ((tmp & 0xf0) == 0x20)

236

if ((tmp & 0xf0) == 0x20)

237

/* alc888S-VC */

237

/* alc888S-VC */

238

snd_hda_codec_read(codec, 0x20, 0,

238

snd_hda_codec_read(codec, 0x20, 0,

239

AC_VERB_SET_PROC_COEF, 0x830);

239

AC_VERB_SET_PROC_COEF, 0x830);

240

else

240

else

241

/* alc888-VB */

241

/* alc888-VB */

242

snd_hda_codec_read(codec, 0x20, 0,

242

snd_hda_codec_read(codec, 0x20, 0,

243

AC_VERB_SET_PROC_COEF, 0x3030);

243

AC_VERB_SET_PROC_COEF, 0x3030);

244

}

244

}

245

246

/* additional initialization for ALC889 variants */

246

/* additional initialization for ALC889 variants */

247

static void alc889_coef_init(struct hda_codec *codec)

247

static void alc889_coef_init(struct hda_codec *codec)

248

{

248

{

249

unsigned int tmp;

249

unsigned int tmp;

250

251

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

251

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

252

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

252

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

253

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

253

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

254

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);

254

snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);

255

}

255

}

256

257

/* turn on/off EAPD control (only if available) */

257

/* turn on/off EAPD control (only if available) */

258

static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)

258

static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)

259

{

259

{

260

if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)

260

if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)

261

return;

261

return;

262

if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)

262

if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)

263

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,

263

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,

264

on ? 2 : 0);

264

on ? 2 : 0);

265

}

265

}

266

267

/* turn on/off EAPD controls of the codec */

267

/* turn on/off EAPD controls of the codec */

268

static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)

268

static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)

269

{

269

{

270

/* We currently only handle front, HP */

270

/* We currently only handle front, HP */

271

static hda_nid_t pins[] = {

271

static hda_nid_t pins[] = {

272

0x0f, 0x10, 0x14, 0x15, 0

272

0x0f, 0x10, 0x14, 0x15, 0

273

};

273

};

274

hda_nid_t *p;

274

hda_nid_t *p;

275

for (p = pins; *p; p++)

275

for (p = pins; *p; p++)

276

set_eapd(codec, *p, on);

276

set_eapd(codec, *p, on);

277

}

277

}

278

279

/* generic shutup callback;

279

/* generic shutup callback;

280

* just turning off EPAD and a little pause for avoiding pop-noise

280

* just turning off EPAD and a little pause for avoiding pop-noise

281

*/

281

*/

282

static void alc_eapd_shutup(struct hda_codec *codec)

282

static void alc_eapd_shutup(struct hda_codec *codec)

283

{

283

{

284

struct alc_spec *spec = codec->spec;

284

struct alc_spec *spec = codec->spec;

285

286

alc_auto_setup_eapd(codec, false);

286

alc_auto_setup_eapd(codec, false);

287

if (!spec->no_depop_delay)

287

if (!spec->no_depop_delay)

288

msleep(200);

288

msleep(200);

289

snd_hda_shutup_pins(codec);

289

snd_hda_shutup_pins(codec);

290

}

290

}

291

292

/* generic EAPD initialization */

292

/* generic EAPD initialization */

293

static void alc_auto_init_amp(struct hda_codec *codec, int type)

293

static void alc_auto_init_amp(struct hda_codec *codec, int type)

294

{

294

{

295

unsigned int tmp;

295

unsigned int tmp;

296

297

alc_auto_setup_eapd(codec, true);

297

alc_auto_setup_eapd(codec, true);

298

switch (type) {

298

switch (type) {

299

case ALC_INIT_GPIO1:

299

case ALC_INIT_GPIO1:

300

snd_hda_sequence_write(codec, alc_gpio1_init_verbs);

300

snd_hda_sequence_write(codec, alc_gpio1_init_verbs);

301

break;

301

break;

302

case ALC_INIT_GPIO2:

302

case ALC_INIT_GPIO2:

303

snd_hda_sequence_write(codec, alc_gpio2_init_verbs);

303

snd_hda_sequence_write(codec, alc_gpio2_init_verbs);

304

break;

304

break;

305

case ALC_INIT_GPIO3:

305

case ALC_INIT_GPIO3:

306

snd_hda_sequence_write(codec, alc_gpio3_init_verbs);

306

snd_hda_sequence_write(codec, alc_gpio3_init_verbs);

307

break;

307

break;

308

case ALC_INIT_DEFAULT:

308

case ALC_INIT_DEFAULT:

309

switch (codec->vendor_id) {

309

switch (codec->vendor_id) {

310

case 0x10ec0260:

310

case 0x10ec0260:

311

snd_hda_codec_write(codec, 0x1a, 0,

311

snd_hda_codec_write(codec, 0x1a, 0,

312

AC_VERB_SET_COEF_INDEX, 7);

312

AC_VERB_SET_COEF_INDEX, 7);

313

tmp = snd_hda_codec_read(codec, 0x1a, 0,

313

tmp = snd_hda_codec_read(codec, 0x1a, 0,

314

AC_VERB_GET_PROC_COEF, 0);

314

AC_VERB_GET_PROC_COEF, 0);

315

snd_hda_codec_write(codec, 0x1a, 0,

315

snd_hda_codec_write(codec, 0x1a, 0,

316

AC_VERB_SET_COEF_INDEX, 7);

316

AC_VERB_SET_COEF_INDEX, 7);

317

snd_hda_codec_write(codec, 0x1a, 0,

317

snd_hda_codec_write(codec, 0x1a, 0,

318

AC_VERB_SET_PROC_COEF,

318

AC_VERB_SET_PROC_COEF,

319

tmp | 0x2010);

319

tmp | 0x2010);

320

break;

320

break;

321

case 0x10ec0262:

321

case 0x10ec0262:

322

case 0x10ec0880:

322

case 0x10ec0880:

323

case 0x10ec0882:

323

case 0x10ec0882:

324

case 0x10ec0883:

324

case 0x10ec0883:

325

case 0x10ec0885:

325

case 0x10ec0885:

326

case 0x10ec0887:

326

case 0x10ec0887:

327

/*case 0x10ec0889:*/ /* this causes an SPDIF problem */

327

/*case 0x10ec0889:*/ /* this causes an SPDIF problem */

328

alc889_coef_init(codec);

328

alc889_coef_init(codec);

329

break;

329

break;

330

case 0x10ec0888:

330

case 0x10ec0888:

331

alc888_coef_init(codec);

331

alc888_coef_init(codec);

332

break;

332

break;

333

#if 0 /* XXX: This may cause the silent output on speaker on some machines */

333

#if 0 /* XXX: This may cause the silent output on speaker on some machines */

334

case 0x10ec0267:

334

case 0x10ec0267:

335

case 0x10ec0268:

335

case 0x10ec0268:

336

snd_hda_codec_write(codec, 0x20, 0,

336

snd_hda_codec_write(codec, 0x20, 0,

337

AC_VERB_SET_COEF_INDEX, 7);

337

AC_VERB_SET_COEF_INDEX, 7);

338

tmp = snd_hda_codec_read(codec, 0x20, 0,

338

tmp = snd_hda_codec_read(codec, 0x20, 0,

339

AC_VERB_GET_PROC_COEF, 0);

339

AC_VERB_GET_PROC_COEF, 0);

340

snd_hda_codec_write(codec, 0x20, 0,

340

snd_hda_codec_write(codec, 0x20, 0,

341

AC_VERB_SET_COEF_INDEX, 7);

341

AC_VERB_SET_COEF_INDEX, 7);

342

snd_hda_codec_write(codec, 0x20, 0,

342

snd_hda_codec_write(codec, 0x20, 0,

343

AC_VERB_SET_PROC_COEF,

343

AC_VERB_SET_PROC_COEF,

344

tmp | 0x3000);

344

tmp | 0x3000);

345

break;

345

break;

346

#endif /* XXX */

346

#endif /* XXX */

347

}

347

}

348

break;

348

break;

349

}

349

}

350

}

350

}

351

352

353

/*

353

/*

354

* Realtek SSID verification

354

* Realtek SSID verification

355

*/

355

*/

356

357

/* Could be any non-zero and even value. When used as fixup, tells

357

/* Could be any non-zero and even value. When used as fixup, tells

358

* the driver to ignore any present sku defines.

358

* the driver to ignore any present sku defines.

359

*/

359

*/

360

#define ALC_FIXUP_SKU_IGNORE (2)

360

#define ALC_FIXUP_SKU_IGNORE (2)

361

362

static void alc_fixup_sku_ignore(struct hda_codec *codec,

362

static void alc_fixup_sku_ignore(struct hda_codec *codec,

363

const struct hda_fixup *fix, int action)

363

const struct hda_fixup *fix, int action)

364

{

364

{

365

struct alc_spec *spec = codec->spec;

365

struct alc_spec *spec = codec->spec;

366

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

366

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

367

spec->cdefine.fixup = 1;

367

spec->cdefine.fixup = 1;

368

spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;

368

spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;

369

}

369

}

370

}

370

}

371

372

static void alc_fixup_no_depop_delay(struct hda_codec *codec,

372

static void alc_fixup_no_depop_delay(struct hda_codec *codec,

373

const struct hda_fixup *fix, int action)

373

const struct hda_fixup *fix, int action)

374

{

374

{

375

struct alc_spec *spec = codec->spec;

375

struct alc_spec *spec = codec->spec;

376

377

if (action == HDA_FIXUP_ACT_PROBE) {

377

if (action == HDA_FIXUP_ACT_PROBE) {

378

spec->no_depop_delay = 1;

378

spec->no_depop_delay = 1;

379

codec->depop_delay = 0;

379

codec->depop_delay = 0;

380

}

380

}

381

}

381

}

382

383

static int alc_auto_parse_customize_define(struct hda_codec *codec)

383

static int alc_auto_parse_customize_define(struct hda_codec *codec)

384

{

384

{

385

unsigned int ass, tmp, i;

385

unsigned int ass, tmp, i;

386

unsigned nid = 0;

386

unsigned nid = 0;

387

struct alc_spec *spec = codec->spec;

387

struct alc_spec *spec = codec->spec;

388

389

spec->cdefine.enable_pcbeep = 1; /* assume always enabled */

389

spec->cdefine.enable_pcbeep = 1; /* assume always enabled */

390

391

if (spec->cdefine.fixup) {

391

if (spec->cdefine.fixup) {

392

ass = spec->cdefine.sku_cfg;

392

ass = spec->cdefine.sku_cfg;

393

if (ass == ALC_FIXUP_SKU_IGNORE)

393

if (ass == ALC_FIXUP_SKU_IGNORE)

394

return -1;

394

return -1;

395

goto do_sku;

395

goto do_sku;

396

}

396

}

397

398

if (!codec->bus->pci)

398

if (!codec->bus->pci)

399

return -1;

399

return -1;

400

ass = codec->subsystem_id & 0xffff;

400

ass = codec->subsystem_id & 0xffff;

401

if (ass != codec->bus->pci->subsystem_device && (ass & 1))

401

if (ass != codec->bus->pci->subsystem_device && (ass & 1))

402

goto do_sku;

402

goto do_sku;

403

404

nid = 0x1d;

404

nid = 0x1d;

405

if (codec->vendor_id == 0x10ec0260)

405

if (codec->vendor_id == 0x10ec0260)

406

nid = 0x17;

406

nid = 0x17;

407

ass = snd_hda_codec_get_pincfg(codec, nid);

407

ass = snd_hda_codec_get_pincfg(codec, nid);

408

409

if (!(ass & 1)) {

409

if (!(ass & 1)) {

410

codec_info(codec, "%s: SKU not ready 0x%08x\n",

410

codec_info(codec, "%s: SKU not ready 0x%08x\n",

411

codec->chip_name, ass);

411

codec->chip_name, ass);

412

return -1;

412

return -1;

413

}

413

}

414

415

/* check sum */

415

/* check sum */

416

tmp = 0;

416

tmp = 0;

417

for (i = 1; i < 16; i++) {

417

for (i = 1; i < 16; i++) {

418

if ((ass >> i) & 1)

418

if ((ass >> i) & 1)

419

tmp++;

419

tmp++;

420

}

420

}

421

if (((ass >> 16) & 0xf) != tmp)

421

if (((ass >> 16) & 0xf) != tmp)

422

return -1;

422

return -1;

423

424

spec->cdefine.port_connectivity = ass >> 30;

424

spec->cdefine.port_connectivity = ass >> 30;

425

spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;

425

spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;

426

spec->cdefine.check_sum = (ass >> 16) & 0xf;

426

spec->cdefine.check_sum = (ass >> 16) & 0xf;

427

spec->cdefine.customization = ass >> 8;

427

spec->cdefine.customization = ass >> 8;

428

do_sku:

428

do_sku:

429

spec->cdefine.sku_cfg = ass;

429

spec->cdefine.sku_cfg = ass;

430

spec->cdefine.external_amp = (ass & 0x38) >> 3;

430

spec->cdefine.external_amp = (ass & 0x38) >> 3;

431

spec->cdefine.platform_type = (ass & 0x4) >> 2;

431

spec->cdefine.platform_type = (ass & 0x4) >> 2;

432

spec->cdefine.swap = (ass & 0x2) >> 1;

432

spec->cdefine.swap = (ass & 0x2) >> 1;

433

spec->cdefine.override = ass & 0x1;

433

spec->cdefine.override = ass & 0x1;

434

435

codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",

435

codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",

436

nid, spec->cdefine.sku_cfg);

436

nid, spec->cdefine.sku_cfg);

437

codec_dbg(codec, "SKU: port_connectivity=0x%x\n",

437

codec_dbg(codec, "SKU: port_connectivity=0x%x\n",

438

spec->cdefine.port_connectivity);

438

spec->cdefine.port_connectivity);

439

codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);

439

codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);

440

codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);

440

codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);

441

codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);

441

codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);

442

codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);

442

codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);

443

codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);

443

codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);

444

codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);

444

codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);

445

codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);

445

codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);

446

447

return 0;

447

return 0;

448

}

448

}

449

450

/* return the position of NID in the list, or -1 if not found */

450

/* return the position of NID in the list, or -1 if not found */

451

static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)

451

static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)

452

{

452

{

453

int i;

453

int i;

454

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

454

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

455

if (list[i] == nid)

455

if (list[i] == nid)

456

return i;

456

return i;

457

return -1;

457

return -1;

458

}

458

}

459

/* return true if the given NID is found in the list */

459

/* return true if the given NID is found in the list */

460

static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)

460

static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)

461

{

461

{

462

return find_idx_in_nid_list(nid, list, nums) >= 0;

462

return find_idx_in_nid_list(nid, list, nums) >= 0;

463

}

463

}

464

465

/* check subsystem ID and set up device-specific initialization;

465

/* check subsystem ID and set up device-specific initialization;

466

* return 1 if initialized, 0 if invalid SSID

466

* return 1 if initialized, 0 if invalid SSID

467

*/

467

*/

468

/* 32-bit subsystem ID for BIOS loading in HD Audio codec.

468

/* 32-bit subsystem ID for BIOS loading in HD Audio codec.

469

* 31 ~ 16 : Manufacture ID

469

* 31 ~ 16 : Manufacture ID

470

* 15 ~ 8 : SKU ID

470

* 15 ~ 8 : SKU ID

471

* 7 ~ 0 : Assembly ID

471

* 7 ~ 0 : Assembly ID

472

* port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36

472

* port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36

473

*/

473

*/

474

static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)

474

static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)

475

{

475

{

476

unsigned int ass, tmp, i;

476

unsigned int ass, tmp, i;

477

unsigned nid;

477

unsigned nid;

478

struct alc_spec *spec = codec->spec;

478

struct alc_spec *spec = codec->spec;

479

480

if (spec->cdefine.fixup) {

480

if (spec->cdefine.fixup) {

481

ass = spec->cdefine.sku_cfg;

481

ass = spec->cdefine.sku_cfg;

482

if (ass == ALC_FIXUP_SKU_IGNORE)

482

if (ass == ALC_FIXUP_SKU_IGNORE)

483

return 0;

483

return 0;

484

goto do_sku;

484

goto do_sku;

485

}

485

}

486

487

ass = codec->subsystem_id & 0xffff;

487

ass = codec->subsystem_id & 0xffff;

488

if (codec->bus->pci &&

488

if (codec->bus->pci &&

489

ass != codec->bus->pci->subsystem_device && (ass & 1))

489

ass != codec->bus->pci->subsystem_device && (ass & 1))

490

goto do_sku;

490

goto do_sku;

491

492

/* invalid SSID, check the special NID pin defcfg instead */

492

/* invalid SSID, check the special NID pin defcfg instead */

493

/*

493

/*

494

* 31~30 : port connectivity

494

* 31~30 : port connectivity

495

* 29~21 : reserve

495

* 29~21 : reserve

496

* 20 : PCBEEP input

496

* 20 : PCBEEP input

497

* 19~16 : Check sum (15:1)

497

* 19~16 : Check sum (15:1)

498

* 15~1 : Custom

498

* 15~1 : Custom

499

* 0 : override

499

* 0 : override

500

*/

500

*/

501

nid = 0x1d;

501

nid = 0x1d;

502

if (codec->vendor_id == 0x10ec0260)

502

if (codec->vendor_id == 0x10ec0260)

503

nid = 0x17;

503

nid = 0x17;

504

ass = snd_hda_codec_get_pincfg(codec, nid);

504

ass = snd_hda_codec_get_pincfg(codec, nid);

505

codec_dbg(codec,

505

codec_dbg(codec,

506

"realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",

506

"realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",

507

ass, nid);

507

ass, nid);

508

if (!(ass & 1))

508

if (!(ass & 1))

509

return 0;

509

return 0;

510

if ((ass >> 30) != 1) /* no physical connection */

510

if ((ass >> 30) != 1) /* no physical connection */

511

return 0;

511

return 0;

512

513

/* check sum */

513

/* check sum */

514

tmp = 0;

514

tmp = 0;

515

for (i = 1; i < 16; i++) {

515

for (i = 1; i < 16; i++) {

516

if ((ass >> i) & 1)

516

if ((ass >> i) & 1)

517

tmp++;

517

tmp++;

518

}

518

}

519

if (((ass >> 16) & 0xf) != tmp)

519

if (((ass >> 16) & 0xf) != tmp)

520

return 0;

520

return 0;

521

do_sku:

521

do_sku:

522

codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",

522

codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",

523

ass & 0xffff, codec->vendor_id);

523

ass & 0xffff, codec->vendor_id);

524

/*

524

/*

525

* 0 : override

525

* 0 : override

526

* 1 : Swap Jack

526

* 1 : Swap Jack

527

* 2 : 0 --> Desktop, 1 --> Laptop

527

* 2 : 0 --> Desktop, 1 --> Laptop

528

* 3~5 : External Amplifier control

528

* 3~5 : External Amplifier control

529

* 7~6 : Reserved

529

* 7~6 : Reserved

530

*/

530

*/

531

tmp = (ass & 0x38) >> 3; /* external Amp control */

531

tmp = (ass & 0x38) >> 3; /* external Amp control */

532

switch (tmp) {

532

switch (tmp) {

533

case 1:

533

case 1:

534

spec->init_amp = ALC_INIT_GPIO1;

534

spec->init_amp = ALC_INIT_GPIO1;

535

break;

535

break;

536

case 3:

536

case 3:

537

spec->init_amp = ALC_INIT_GPIO2;

537

spec->init_amp = ALC_INIT_GPIO2;

538

break;

538

break;

539

case 7:

539

case 7:

540

spec->init_amp = ALC_INIT_GPIO3;

540

spec->init_amp = ALC_INIT_GPIO3;

541

break;

541

break;

542

case 5:

542

case 5:

543

default:

543

default:

544

spec->init_amp = ALC_INIT_DEFAULT;

544

spec->init_amp = ALC_INIT_DEFAULT;

545

break;

545

break;

546

}

546

}

547

548

/* is laptop or Desktop and enable the function "Mute internal speaker

548

/* is laptop or Desktop and enable the function "Mute internal speaker

549

* when the external headphone out jack is plugged"

549

* when the external headphone out jack is plugged"

550

*/

550

*/

551

if (!(ass & 0x8000))

551

if (!(ass & 0x8000))

552

return 1;

552

return 1;

553

/*

553

/*

554

* 10~8 : Jack location

554

* 10~8 : Jack location

555

* 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered

555

* 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered

556

* 14~13: Resvered

556

* 14~13: Resvered

557

* 15 : 1 --> enable the function "Mute internal speaker

557

* 15 : 1 --> enable the function "Mute internal speaker

558

* when the external headphone out jack is plugged"

558

* when the external headphone out jack is plugged"

559

*/

559

*/

560

if (!spec->gen.autocfg.hp_pins[0] &&

560

if (!spec->gen.autocfg.hp_pins[0] &&

561

!(spec->gen.autocfg.line_out_pins[0] &&

561

!(spec->gen.autocfg.line_out_pins[0] &&

562

spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {

562

spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {

563

hda_nid_t nid;

563

hda_nid_t nid;

564

tmp = (ass >> 11) & 0x3; /* HP to chassis */

564

tmp = (ass >> 11) & 0x3; /* HP to chassis */

565

nid = ports[tmp];

565

nid = ports[tmp];

566

if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,

566

if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,

567

spec->gen.autocfg.line_outs))

567

spec->gen.autocfg.line_outs))

568

return 1;

568

return 1;

569

spec->gen.autocfg.hp_pins[0] = nid;

569

spec->gen.autocfg.hp_pins[0] = nid;

570

}

570

}

571

return 1;

571

return 1;

572

}

572

}

573

574

/* Check the validity of ALC subsystem-id

574

/* Check the validity of ALC subsystem-id

575

* ports contains an array of 4 pin NIDs for port-A, E, D and I */

575

* ports contains an array of 4 pin NIDs for port-A, E, D and I */

576

static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)

576

static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)

577

{

577

{

578

if (!alc_subsystem_id(codec, ports)) {

578

if (!alc_subsystem_id(codec, ports)) {

579

struct alc_spec *spec = codec->spec;

579

struct alc_spec *spec = codec->spec;

580

codec_dbg(codec,

580

codec_dbg(codec,

581

"realtek: Enable default setup for auto mode as fallback\n");

581

"realtek: Enable default setup for auto mode as fallback\n");

582

spec->init_amp = ALC_INIT_DEFAULT;

582

spec->init_amp = ALC_INIT_DEFAULT;

583

}

583

}

584

}

584

}

585

586

/*

586

/*

587

* COEF access helper functions

587

* COEF access helper functions

588

*/

588

*/

589

590

static int alc_read_coefex_idx(struct hda_codec *codec,

590

static int alc_read_coefex_idx(struct hda_codec *codec,

591

hda_nid_t nid,

591

hda_nid_t nid,

592

unsigned int coef_idx)

592

unsigned int coef_idx)

593

{

593

{

594

unsigned int val;

594

unsigned int val;

595

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,

595

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,

596

coef_idx);

596

coef_idx);

597

val = snd_hda_codec_read(codec, nid, 0,

597

val = snd_hda_codec_read(codec, nid, 0,

598

AC_VERB_GET_PROC_COEF, 0);

598

AC_VERB_GET_PROC_COEF, 0);

599

return val;

599

return val;

600

}

600

}

601

602

#define alc_read_coef_idx(codec, coef_idx) \

602

#define alc_read_coef_idx(codec, coef_idx) \

603

alc_read_coefex_idx(codec, 0x20, coef_idx)

603

alc_read_coefex_idx(codec, 0x20, coef_idx)

604

605

static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,

605

static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,

606

unsigned int coef_idx,

606

unsigned int coef_idx,

607

unsigned int coef_val)

607

unsigned int coef_val)

608

{

608

{

609

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,

609

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,

610

coef_idx);

610

coef_idx);

611

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF,

611

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF,

612

coef_val);

612

coef_val);

613

}

613

}

614

615

#define alc_write_coef_idx(codec, coef_idx, coef_val) \

615

#define alc_write_coef_idx(codec, coef_idx, coef_val) \

616

alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)

616

alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)

617

618

/* a special bypass for COEF 0; read the cached value at the second time */

618

/* a special bypass for COEF 0; read the cached value at the second time */

619

static unsigned int alc_get_coef0(struct hda_codec *codec)

619

static unsigned int alc_get_coef0(struct hda_codec *codec)

620

{

620

{

621

struct alc_spec *spec = codec->spec;

621

struct alc_spec *spec = codec->spec;

622

if (!spec->coef0)

622

if (!spec->coef0)

623

spec->coef0 = alc_read_coef_idx(codec, 0);

623

spec->coef0 = alc_read_coef_idx(codec, 0);

624

return spec->coef0;

624

return spec->coef0;

625

}

625

}

626

627

/*

627

/*

628

*/

628

*/

629

630

static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)

630

static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)

631

{

631

{

632

struct hda_gen_spec *spec = codec->spec;

632

struct hda_gen_spec *spec = codec->spec;

633

if (spec->dyn_adc_switch)

633

if (spec->dyn_adc_switch)

634

adc_idx = spec->dyn_adc_idx[imux_idx];

634

adc_idx = spec->dyn_adc_idx[imux_idx];

635

return spec->adc_nids[adc_idx];

635

return spec->adc_nids[adc_idx];

636

}

636

}

637

638

static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)

638

static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)

639

{

639

{

640

struct alc_spec *spec = codec->spec;

640

struct alc_spec *spec = codec->spec;

641

struct hda_input_mux *imux = &spec->gen.input_mux;

641

struct hda_input_mux *imux = &spec->gen.input_mux;

642

struct nid_path *path;

642

struct nid_path *path;

643

hda_nid_t nid;

643

hda_nid_t nid;

644

int i, dir, parm;

644

int i, dir, parm;

645

unsigned int val;

645

unsigned int val;

646

647

for (i = 0; i < imux->num_items; i++) {

647

for (i = 0; i < imux->num_items; i++) {

648

if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)

648

if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)

649

break;

649

break;

650

}

650

}

651

if (i >= imux->num_items)

651

if (i >= imux->num_items)

652

return;

652

return;

653

654

path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,

654

path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,

655

get_adc_nid(codec, adc_idx, i));

655

get_adc_nid(codec, adc_idx, i));

656

val = path->ctls[NID_PATH_MUTE_CTL];

656

val = path->ctls[NID_PATH_MUTE_CTL];

657

if (!val)

657

if (!val)

658

return;

658

return;

659

nid = get_amp_nid_(val);

659

nid = get_amp_nid_(val);

660

dir = get_amp_direction_(val);

660

dir = get_amp_direction_(val);

661

parm = AC_AMP_SET_RIGHT |

661

parm = AC_AMP_SET_RIGHT |

662

(dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);

662

(dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);

663

664

/* flush all cached amps at first */

664

/* flush all cached amps at first */

665

snd_hda_codec_flush_cache(codec);

665

snd_hda_codec_flush_cache(codec);

666

667

/* we care only right channel */

667

/* we care only right channel */

668

val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);

668

val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);

669

if (val & 0x80) /* if already muted, we don't need to touch */

669

if (val & 0x80) /* if already muted, we don't need to touch */

670

return;

670

return;

671

val |= 0x80;

671

val |= 0x80;

672

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,

672

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,

673

parm | val);

673

parm | val);

674

}

674

}

675

676

/*

676

/*

677

* Inverted digital-mic handling

677

* Inverted digital-mic handling

678

*

678

*

679

* First off, it's a bit tricky. The "Inverted Internal Mic Capture Switch"

679

* First off, it's a bit tricky. The "Inverted Internal Mic Capture Switch"

680

* gives the additional mute only to the right channel of the digital mic

680

* gives the additional mute only to the right channel of the digital mic

681

* capture stream. This is a workaround for avoiding the almost silence

681

* capture stream. This is a workaround for avoiding the almost silence

682

* by summing the stereo stream from some (known to be ForteMedia)

682

* by summing the stereo stream from some (known to be ForteMedia)

683

* digital mic unit.

683

* digital mic unit.

684

*

684

*

685

* The logic is to call alc_inv_dmic_sync() after each action (possibly)

685

* The logic is to call alc_inv_dmic_sync() after each action (possibly)

686

* modifying ADC amp. When the mute flag is set, it mutes the R-channel

686

* modifying ADC amp. When the mute flag is set, it mutes the R-channel

687

* without caching so that the cache can still keep the original value.

687

* without caching so that the cache can still keep the original value.

688

* The cached value is then restored when the flag is set off or any other

688

* The cached value is then restored when the flag is set off or any other

689

* than d-mic is used as the current input source.

689

* than d-mic is used as the current input source.

690

*/

690

*/

691

static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)

691

static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)

692

{

692

{

693

struct alc_spec *spec = codec->spec;

693

struct alc_spec *spec = codec->spec;

694

int src, nums;

694

int src, nums;

695

696

if (!spec->inv_dmic_fixup)

696

if (!spec->inv_dmic_fixup)

697

return;

697

return;

698

if (!spec->inv_dmic_muted && !force)

698

if (!spec->inv_dmic_muted && !force)

699

return;

699

return;

700

nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;

700

nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;

701

for (src = 0; src < nums; src++) {

701

for (src = 0; src < nums; src++) {

702

bool dmic_fixup = false;

702

bool dmic_fixup = false;

703

704

if (spec->inv_dmic_muted &&

704

if (spec->inv_dmic_muted &&

705

spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)

705

spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)

706

dmic_fixup = true;

706

dmic_fixup = true;

707

if (!dmic_fixup && !force)

707

if (!dmic_fixup && !force)

708

continue;

708

continue;

709

alc_inv_dmic_sync_adc(codec, src);

709

alc_inv_dmic_sync_adc(codec, src);

710

}

710

}

711

}

711

}

712

713

static void alc_inv_dmic_hook(struct hda_codec *codec,

713

static void alc_inv_dmic_hook(struct hda_codec *codec,

714

struct snd_kcontrol *kcontrol,

714

struct snd_kcontrol *kcontrol,

715

struct snd_ctl_elem_value *ucontrol)

715

struct snd_ctl_elem_value *ucontrol)

716

{

716

{

717

alc_inv_dmic_sync(codec, false);

717

alc_inv_dmic_sync(codec, false);

718

}

718

}

719

720

static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,

720

static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,

721

struct snd_ctl_elem_value *ucontrol)

721

struct snd_ctl_elem_value *ucontrol)

722

{

722

{

723

struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

723

struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

724

struct alc_spec *spec = codec->spec;

724

struct alc_spec *spec = codec->spec;

725

726

ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;

726

ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;

727

return 0;

727

return 0;

728

}

728

}

729

730

static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,

730

static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,

731

struct snd_ctl_elem_value *ucontrol)

731

struct snd_ctl_elem_value *ucontrol)

732

{

732

{

733

struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

733

struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

734

struct alc_spec *spec = codec->spec;

734

struct alc_spec *spec = codec->spec;

735

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

735

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

736

737

if (val == spec->inv_dmic_muted)

737

if (val == spec->inv_dmic_muted)

738

return 0;

738

return 0;

739

spec->inv_dmic_muted = val;

739

spec->inv_dmic_muted = val;

740

alc_inv_dmic_sync(codec, true);

740

alc_inv_dmic_sync(codec, true);

741

return 0;

741

return 0;

742

}

742

}

743

744

static const struct snd_kcontrol_new alc_inv_dmic_sw = {

744

static const struct snd_kcontrol_new alc_inv_dmic_sw = {

745

.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

745

.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

746

.name = "Inverted Internal Mic Capture Switch",

746

.name = "Inverted Internal Mic Capture Switch",

747

.info = snd_ctl_boolean_mono_info,

747

.info = snd_ctl_boolean_mono_info,

748

.get = alc_inv_dmic_sw_get,

748

.get = alc_inv_dmic_sw_get,

749

.put = alc_inv_dmic_sw_put,

749

.put = alc_inv_dmic_sw_put,

750

};

750

};

751

752

static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)

752

static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)

753

{

753

{

754

struct alc_spec *spec = codec->spec;

754

struct alc_spec *spec = codec->spec;

755

756

if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))

756

if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))

757

return -ENOMEM;

757

return -ENOMEM;

758

spec->inv_dmic_fixup = 1;

758

spec->inv_dmic_fixup = 1;

759

spec->inv_dmic_muted = 0;

759

spec->inv_dmic_muted = 0;

760

spec->inv_dmic_pin = nid;

760

spec->inv_dmic_pin = nid;

761

spec->gen.cap_sync_hook = alc_inv_dmic_hook;

761

spec->gen.cap_sync_hook = alc_inv_dmic_hook;

762

return 0;

762

return 0;

763

}

763

}

764

765

/* typically the digital mic is put at node 0x12 */

765

/* typically the digital mic is put at node 0x12 */

766

static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,

766

static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,

767

const struct hda_fixup *fix, int action)

767

const struct hda_fixup *fix, int action)

768

{

768

{

769

if (action == HDA_FIXUP_ACT_PROBE)

769

if (action == HDA_FIXUP_ACT_PROBE)

770

alc_add_inv_dmic_mixer(codec, 0x12);

770

alc_add_inv_dmic_mixer(codec, 0x12);

771

}

771

}

772

773

774

#ifdef CONFIG_SND_HDA_INPUT_BEEP

774

#ifdef CONFIG_SND_HDA_INPUT_BEEP

775

/* additional beep mixers; the actual parameters are overwritten at build */

775

/* additional beep mixers; the actual parameters are overwritten at build */

776

static const struct snd_kcontrol_new alc_beep_mixer[] = {

776

static const struct snd_kcontrol_new alc_beep_mixer[] = {

777

HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),

777

HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),

778

HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),

778

HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),

779

{ } /* end */

779

{ } /* end */

780

};

780

};

781

#endif

781

#endif

782

783

static int alc_build_controls(struct hda_codec *codec)

783

static int alc_build_controls(struct hda_codec *codec)

784

{

784

{

785

struct alc_spec *spec = codec->spec;

785

struct alc_spec *spec = codec->spec;

786

int i, err;

786

int i, err;

787

788

err = snd_hda_gen_build_controls(codec);

788

err = snd_hda_gen_build_controls(codec);

789

if (err < 0)

789

if (err < 0)

790

return err;

790

return err;

791

792

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

792

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

793

err = snd_hda_add_new_ctls(codec, spec->mixers[i]);

793

err = snd_hda_add_new_ctls(codec, spec->mixers[i]);

794

if (err < 0)

794

if (err < 0)

795

return err;

795

return err;

796

}

796

}

797

798

#ifdef CONFIG_SND_HDA_INPUT_BEEP

798

#ifdef CONFIG_SND_HDA_INPUT_BEEP

799

/* create beep controls if needed */

799

/* create beep controls if needed */

800

if (spec->beep_amp) {

800

if (spec->beep_amp) {

801

const struct snd_kcontrol_new *knew;

801

const struct snd_kcontrol_new *knew;

802

for (knew = alc_beep_mixer; knew->name; knew++) {

802

for (knew = alc_beep_mixer; knew->name; knew++) {

803

struct snd_kcontrol *kctl;

803

struct snd_kcontrol *kctl;

804

kctl = snd_ctl_new1(knew, codec);

804

kctl = snd_ctl_new1(knew, codec);

805

if (!kctl)

805

if (!kctl)

806

return -ENOMEM;

806

return -ENOMEM;

807

kctl->private_value = spec->beep_amp;

807

kctl->private_value = spec->beep_amp;

808

err = snd_hda_ctl_add(codec, 0, kctl);

808

err = snd_hda_ctl_add(codec, 0, kctl);

809

if (err < 0)

809

if (err < 0)

810

return err;

810

return err;

811

}

811

}

812

}

812

}

813

#endif

813

#endif

814

815

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);

815

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);

816

return 0;

816

return 0;

817

}

817

}

818

819

820

/*

820

/*

821

* Common callbacks

821

* Common callbacks

822

*/

822

*/

823

824

static int alc_init(struct hda_codec *codec)

824

static int alc_init(struct hda_codec *codec)

825

{

825

{

826

struct alc_spec *spec = codec->spec;

826

struct alc_spec *spec = codec->spec;

827

828

if (spec->init_hook)

828

if (spec->init_hook)

829

spec->init_hook(codec);

829

spec->init_hook(codec);

830

831

alc_fix_pll(codec);

831

alc_fix_pll(codec);

832

alc_auto_init_amp(codec, spec->init_amp);

832

alc_auto_init_amp(codec, spec->init_amp);

833

834

snd_hda_gen_init(codec);

834

snd_hda_gen_init(codec);

835

836

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);

836

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);

837

838

return 0;

838

return 0;

839

}

839

}

840

841

static inline void alc_shutup(struct hda_codec *codec)

841

static inline void alc_shutup(struct hda_codec *codec)

842

{

842

{

843

struct alc_spec *spec = codec->spec;

843

struct alc_spec *spec = codec->spec;

844

845

if (spec && spec->shutup)

845

if (spec && spec->shutup)

846

spec->shutup(codec);

846

spec->shutup(codec);

847

else

847

else

848

snd_hda_shutup_pins(codec);

848

snd_hda_shutup_pins(codec);

849

}

849

}

850

851

#define alc_free snd_hda_gen_free

851

#define alc_free snd_hda_gen_free

852

853

#ifdef CONFIG_PM

853

#ifdef CONFIG_PM

854

static void alc_power_eapd(struct hda_codec *codec)

854

static void alc_power_eapd(struct hda_codec *codec)

855

{

855

{

856

alc_auto_setup_eapd(codec, false);

856

alc_auto_setup_eapd(codec, false);

857

}

857

}

858

859

static int alc_suspend(struct hda_codec *codec)

859

static int alc_suspend(struct hda_codec *codec)

860

{

860

{

861

struct alc_spec *spec = codec->spec;

861

struct alc_spec *spec = codec->spec;

862

alc_shutup(codec);

862

alc_shutup(codec);

863

if (spec && spec->power_hook)

863

if (spec && spec->power_hook)

864

spec->power_hook(codec);

864

spec->power_hook(codec);

865

return 0;

865

return 0;

866

}

866

}

867

#endif

867

#endif

868

869

#ifdef CONFIG_PM

869

#ifdef CONFIG_PM

870

static int alc_resume(struct hda_codec *codec)

870

static int alc_resume(struct hda_codec *codec)

871

{

871

{

872

struct alc_spec *spec = codec->spec;

872

struct alc_spec *spec = codec->spec;

873

874

if (!spec->no_depop_delay)

874

if (!spec->no_depop_delay)

875

msleep(150); /* to avoid pop noise */

875

msleep(150); /* to avoid pop noise */

876

codec->patch_ops.init(codec);

876

codec->patch_ops.init(codec);

877

snd_hda_codec_resume_amp(codec);

877

snd_hda_codec_resume_amp(codec);

878

snd_hda_codec_resume_cache(codec);

878

snd_hda_codec_resume_cache(codec);

879

alc_inv_dmic_sync(codec, true);

879

alc_inv_dmic_sync(codec, true);

880

hda_call_check_power_status(codec, 0x01);

880

hda_call_check_power_status(codec, 0x01);

881

return 0;

881

return 0;

882

}

882

}

883

#endif

883

#endif

884

885

/*

885

/*

886

*/

886

*/

887

static const struct hda_codec_ops alc_patch_ops = {

887

static const struct hda_codec_ops alc_patch_ops = {

888

.build_controls = alc_build_controls,

888

.build_controls = alc_build_controls,

889

.build_pcms = snd_hda_gen_build_pcms,

889

.build_pcms = snd_hda_gen_build_pcms,

890

.init = alc_init,

890

.init = alc_init,

891

.free = alc_free,

891

.free = alc_free,

892

.unsol_event = snd_hda_jack_unsol_event,

892

.unsol_event = snd_hda_jack_unsol_event,

893

#ifdef CONFIG_PM

893

#ifdef CONFIG_PM

894

.resume = alc_resume,

894

.resume = alc_resume,

895

.suspend = alc_suspend,

895

.suspend = alc_suspend,

896

.check_power_status = snd_hda_gen_check_power_status,

896

.check_power_status = snd_hda_gen_check_power_status,

897

#endif

897

#endif

898

.reboot_notify = alc_shutup,

898

.reboot_notify = alc_shutup,

899

};

899

};

900

901

902

/* replace the codec chip_name with the given string */

902

/* replace the codec chip_name with the given string */

903

static int alc_codec_rename(struct hda_codec *codec, const char *name)

903

static int alc_codec_rename(struct hda_codec *codec, const char *name)

904

{

904

{

905

kfree(codec->chip_name);

905

kfree(codec->chip_name);

906

codec->chip_name = kstrdup(name, GFP_KERNEL);

906

codec->chip_name = kstrdup(name, GFP_KERNEL);

907

if (!codec->chip_name) {

907

if (!codec->chip_name) {

908

alc_free(codec);

908

alc_free(codec);

909

return -ENOMEM;

909

return -ENOMEM;

910

}

910

}

911

return 0;

911

return 0;

912

}

912

}

913

914

/*

914

/*

915

* Rename codecs appropriately from COEF value or subvendor id

915

* Rename codecs appropriately from COEF value or subvendor id

916

*/

916

*/

917

struct alc_codec_rename_table {

917

struct alc_codec_rename_table {

918

unsigned int vendor_id;

918

unsigned int vendor_id;

919

unsigned short coef_mask;

919

unsigned short coef_mask;

920

unsigned short coef_bits;

920

unsigned short coef_bits;

921

const char *name;

921

const char *name;

922

};

922

};

923

924

struct alc_codec_rename_pci_table {

924

struct alc_codec_rename_pci_table {

925

unsigned int codec_vendor_id;

925

unsigned int codec_vendor_id;

926

unsigned short pci_subvendor;

926

unsigned short pci_subvendor;

927

unsigned short pci_subdevice;

927

unsigned short pci_subdevice;

928

const char *name;

928

const char *name;

929

};

929

};

930

931

static struct alc_codec_rename_table rename_tbl[] = {

931

static struct alc_codec_rename_table rename_tbl[] = {

932

{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },

932

{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },

933

{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },

933

{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },

934

{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },

934

{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },

935

{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },

935

{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },

936

{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },

936

{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },

937

{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },

937

{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },

938

{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },

938

{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },

939

{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },

939

{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },

940

{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },

940

{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },

941

{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },

941

{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },

942

{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },

942

{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },

943

{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },

943

{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },

944

{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },

944

{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },

945

{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },

945

{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },

946

{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },

946

{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },

947

{ } /* terminator */

947

{ } /* terminator */

948

};

948

};

949

950

static struct alc_codec_rename_pci_table rename_pci_tbl[] = {

950

static struct alc_codec_rename_pci_table rename_pci_tbl[] = {

951

{ 0x10ec0280, 0x1028, 0, "ALC3220" },

951

{ 0x10ec0280, 0x1028, 0, "ALC3220" },

952

{ 0x10ec0282, 0x1028, 0, "ALC3221" },

952

{ 0x10ec0282, 0x1028, 0, "ALC3221" },

953

{ 0x10ec0283, 0x1028, 0, "ALC3223" },

953

{ 0x10ec0283, 0x1028, 0, "ALC3223" },

954

{ 0x10ec0292, 0x1028, 0, "ALC3226" },

954

{ 0x10ec0292, 0x1028, 0, "ALC3226" },

955

{ 0x10ec0255, 0x1028, 0, "ALC3234" },

955

{ 0x10ec0255, 0x1028, 0, "ALC3234" },

956

{ 0x10ec0668, 0x1028, 0, "ALC3661" },

956

{ 0x10ec0668, 0x1028, 0, "ALC3661" },

957

{ } /* terminator */

957

{ } /* terminator */

958

};

958

};

959

960

static int alc_codec_rename_from_preset(struct hda_codec *codec)

960

static int alc_codec_rename_from_preset(struct hda_codec *codec)

961

{

961

{

962

const struct alc_codec_rename_table *p;

962

const struct alc_codec_rename_table *p;

963

const struct alc_codec_rename_pci_table *q;

963

const struct alc_codec_rename_pci_table *q;

964

965

for (p = rename_tbl; p->vendor_id; p++) {

965

for (p = rename_tbl; p->vendor_id; p++) {

966

if (p->vendor_id != codec->vendor_id)

966

if (p->vendor_id != codec->vendor_id)

967

continue;

967

continue;

968

if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)

968

if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)

969

return alc_codec_rename(codec, p->name);

969

return alc_codec_rename(codec, p->name);

970

}

970

}

971

972

if (!codec->bus->pci)

972

if (!codec->bus->pci)

973

return 0;

973

return 0;

974

for (q = rename_pci_tbl; q->codec_vendor_id; q++) {

974

for (q = rename_pci_tbl; q->codec_vendor_id; q++) {

975

if (q->codec_vendor_id != codec->vendor_id)

975

if (q->codec_vendor_id != codec->vendor_id)

976

continue;

976

continue;

977

if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)

977

if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)

978

continue;

978

continue;

979

if (!q->pci_subdevice ||

979

if (!q->pci_subdevice ||

980

q->pci_subdevice == codec->bus->pci->subsystem_device)

980

q->pci_subdevice == codec->bus->pci->subsystem_device)

981

return alc_codec_rename(codec, q->name);

981

return alc_codec_rename(codec, q->name);

982

}

982

}

983

984

return 0;

984

return 0;

985

}

985

}

986

987

988

/*

988

/*

989

* Digital-beep handlers

989

* Digital-beep handlers

990

*/

990

*/

991

#ifdef CONFIG_SND_HDA_INPUT_BEEP

991

#ifdef CONFIG_SND_HDA_INPUT_BEEP

992

#define set_beep_amp(spec, nid, idx, dir) \

992

#define set_beep_amp(spec, nid, idx, dir) \

993

((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))

993

((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))

994

995

static const struct snd_pci_quirk beep_white_list[] = {

995

static const struct snd_pci_quirk beep_white_list[] = {

996

SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),

996

SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),

997

SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),

997

SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),

998

SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),

998

SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),

999

SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),

999

SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),

1000

SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),

1000

SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),

1001

SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),

1001

SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),

1002

SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),

1002

SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),

1003

SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),

1003

SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),

1004

SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),

1004

SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),

1005

{}

1005

{}

1006

};

1006

};

1007

1008

static inline int has_cdefine_beep(struct hda_codec *codec)

1008

static inline int has_cdefine_beep(struct hda_codec *codec)

1009

{

1009

{

1010

struct alc_spec *spec = codec->spec;

1010

struct alc_spec *spec = codec->spec;

1011

const struct snd_pci_quirk *q;

1011

const struct snd_pci_quirk *q;

1012

q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);

1012

q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);

1013

if (q)

1013

if (q)

1014

return q->value;

1014

return q->value;

1015

return spec->cdefine.enable_pcbeep;

1015

return spec->cdefine.enable_pcbeep;

1016

}

1016

}

1017

#else

1017

#else

1018

#define set_beep_amp(spec, nid, idx, dir) /* NOP */

1018

#define set_beep_amp(spec, nid, idx, dir) /* NOP */

1019

#define has_cdefine_beep(codec) 0

1019

#define has_cdefine_beep(codec) 0

1020

#endif

1020

#endif

1021

1022

/* parse the BIOS configuration and set up the alc_spec */

1022

/* parse the BIOS configuration and set up the alc_spec */

1023

/* return 1 if successful, 0 if the proper config is not found,

1023

/* return 1 if successful, 0 if the proper config is not found,

1024

* or a negative error code

1024

* or a negative error code

1025

*/

1025

*/

1026

static int alc_parse_auto_config(struct hda_codec *codec,

1026

static int alc_parse_auto_config(struct hda_codec *codec,

1027

const hda_nid_t *ignore_nids,

1027

const hda_nid_t *ignore_nids,

1028

const hda_nid_t *ssid_nids)

1028

const hda_nid_t *ssid_nids)

1029

{

1029

{

1030

struct alc_spec *spec = codec->spec;

1030

struct alc_spec *spec = codec->spec;

1031

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

1031

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

1032

int err;

1032

int err;

1033

1034

err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,

1034

err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,

1035

spec->parse_flags);

1035

spec->parse_flags);

1036

if (err < 0)

1036

if (err < 0)

1037

return err;

1037

return err;

1038

1039

if (ssid_nids)

1039

if (ssid_nids)

1040

alc_ssid_check(codec, ssid_nids);

1040

alc_ssid_check(codec, ssid_nids);

1041

1042

err = snd_hda_gen_parse_auto_config(codec, cfg);

1042

err = snd_hda_gen_parse_auto_config(codec, cfg);

1043

if (err < 0)

1043

if (err < 0)

1044

return err;

1044

return err;

1045

1046

return 1;

1046

return 1;

1047

}

1047

}

1048

1049

/* common preparation job for alc_spec */

1049

/* common preparation job for alc_spec */

1050

static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)

1050

static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)

1051

{

1051

{

1052

struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);

1052

struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);

1053

int err;

1053

int err;

1054

1055

if (!spec)

1055

if (!spec)

1056

return -ENOMEM;

1056

return -ENOMEM;

1057

codec->spec = spec;

1057

codec->spec = spec;

1058

snd_hda_gen_spec_init(&spec->gen);

1058

snd_hda_gen_spec_init(&spec->gen);

1059

spec->gen.mixer_nid = mixer_nid;

1059

spec->gen.mixer_nid = mixer_nid;

1060

spec->gen.own_eapd_ctl = 1;

1060

spec->gen.own_eapd_ctl = 1;

1061

codec->single_adc_amp = 1;

1061

codec->single_adc_amp = 1;

1062

/* FIXME: do we need this for all Realtek codec models? */

1062

/* FIXME: do we need this for all Realtek codec models? */

1063

codec->spdif_status_reset = 1;

1063

codec->spdif_status_reset = 1;

1064

1065

err = alc_codec_rename_from_preset(codec);

1065

err = alc_codec_rename_from_preset(codec);

1066

if (err < 0) {

1066

if (err < 0) {

1067

kfree(spec);

1067

kfree(spec);

1068

return err;

1068

return err;

1069

}

1069

}

1070

return 0;

1070

return 0;

1071

}

1071

}

1072

1073

static int alc880_parse_auto_config(struct hda_codec *codec)

1073

static int alc880_parse_auto_config(struct hda_codec *codec)

1074

{

1074

{

1075

static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };

1075

static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };

1076

static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };

1076

static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };

1077

return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);

1077

return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);

1078

}

1078

}

1079

1080

/*

1080

/*

1081

* ALC880 fix-ups

1081

* ALC880 fix-ups

1082

*/

1082

*/

1083

enum {

1083

enum {

1084

ALC880_FIXUP_GPIO1,

1084

ALC880_FIXUP_GPIO1,

1085

ALC880_FIXUP_GPIO2,

1085

ALC880_FIXUP_GPIO2,

1086

ALC880_FIXUP_MEDION_RIM,

1086

ALC880_FIXUP_MEDION_RIM,

1087

ALC880_FIXUP_LG,

1087

ALC880_FIXUP_LG,

1088

ALC880_FIXUP_LG_LW25,

1088

ALC880_FIXUP_LG_LW25,

1089

ALC880_FIXUP_W810,

1089

ALC880_FIXUP_W810,

1090

ALC880_FIXUP_EAPD_COEF,

1090

ALC880_FIXUP_EAPD_COEF,

1091

ALC880_FIXUP_TCL_S700,

1091

ALC880_FIXUP_TCL_S700,

1092

ALC880_FIXUP_VOL_KNOB,

1092

ALC880_FIXUP_VOL_KNOB,

1093

ALC880_FIXUP_FUJITSU,

1093

ALC880_FIXUP_FUJITSU,

1094

ALC880_FIXUP_F1734,

1094

ALC880_FIXUP_F1734,

1095

ALC880_FIXUP_UNIWILL,

1095

ALC880_FIXUP_UNIWILL,

1096

ALC880_FIXUP_UNIWILL_DIG,

1096

ALC880_FIXUP_UNIWILL_DIG,

1097

ALC880_FIXUP_Z71V,

1097

ALC880_FIXUP_Z71V,

1098

ALC880_FIXUP_ASUS_W5A,

1098

ALC880_FIXUP_ASUS_W5A,

1099

ALC880_FIXUP_3ST_BASE,

1099

ALC880_FIXUP_3ST_BASE,

1100

ALC880_FIXUP_3ST,

1100

ALC880_FIXUP_3ST,

1101

ALC880_FIXUP_3ST_DIG,

1101

ALC880_FIXUP_3ST_DIG,

1102

ALC880_FIXUP_5ST_BASE,

1102

ALC880_FIXUP_5ST_BASE,

1103

ALC880_FIXUP_5ST,

1103

ALC880_FIXUP_5ST,

1104

ALC880_FIXUP_5ST_DIG,

1104

ALC880_FIXUP_5ST_DIG,

1105

ALC880_FIXUP_6ST_BASE,

1105

ALC880_FIXUP_6ST_BASE,

1106

ALC880_FIXUP_6ST,

1106

ALC880_FIXUP_6ST,

1107

ALC880_FIXUP_6ST_DIG,

1107

ALC880_FIXUP_6ST_DIG,

1108

ALC880_FIXUP_6ST_AUTOMUTE,

1108

ALC880_FIXUP_6ST_AUTOMUTE,

1109

};

1109

};

1110

1111

/* enable the volume-knob widget support on NID 0x21 */

1111

/* enable the volume-knob widget support on NID 0x21 */

1112

static void alc880_fixup_vol_knob(struct hda_codec *codec,

1112

static void alc880_fixup_vol_knob(struct hda_codec *codec,

1113

const struct hda_fixup *fix, int action)

1113

const struct hda_fixup *fix, int action)

1114

{

1114

{

1115

if (action == HDA_FIXUP_ACT_PROBE)

1115

if (action == HDA_FIXUP_ACT_PROBE)

1116

snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);

1116

snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);

1117

}

1117

}

1118

1119

static const struct hda_fixup alc880_fixups[] = {

1119

static const struct hda_fixup alc880_fixups[] = {

1120

[ALC880_FIXUP_GPIO1] = {

1120

[ALC880_FIXUP_GPIO1] = {

1121

.type = HDA_FIXUP_VERBS,

1121

.type = HDA_FIXUP_VERBS,

1122

.v.verbs = alc_gpio1_init_verbs,

1122

.v.verbs = alc_gpio1_init_verbs,

1123

},

1123

},

1124

[ALC880_FIXUP_GPIO2] = {

1124

[ALC880_FIXUP_GPIO2] = {

1125

.type = HDA_FIXUP_VERBS,

1125

.type = HDA_FIXUP_VERBS,

1126

.v.verbs = alc_gpio2_init_verbs,

1126

.v.verbs = alc_gpio2_init_verbs,

1127

},

1127

},

1128

[ALC880_FIXUP_MEDION_RIM] = {

1128

[ALC880_FIXUP_MEDION_RIM] = {

1129

.type = HDA_FIXUP_VERBS,

1129

.type = HDA_FIXUP_VERBS,

1130

.v.verbs = (const struct hda_verb[]) {

1130

.v.verbs = (const struct hda_verb[]) {

1131

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1131

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1132

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1132

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1133

{ }

1133

{ }

1134

},

1134

},

1135

.chained = true,

1135

.chained = true,

1136

.chain_id = ALC880_FIXUP_GPIO2,

1136

.chain_id = ALC880_FIXUP_GPIO2,

1137

},

1137

},

1138

[ALC880_FIXUP_LG] = {

1138

[ALC880_FIXUP_LG] = {

1139

.type = HDA_FIXUP_PINS,

1139

.type = HDA_FIXUP_PINS,

1140

.v.pins = (const struct hda_pintbl[]) {

1140

.v.pins = (const struct hda_pintbl[]) {

1141

/* disable bogus unused pins */

1141

/* disable bogus unused pins */

1142

{ 0x16, 0x411111f0 },

1142

{ 0x16, 0x411111f0 },

1143

{ 0x18, 0x411111f0 },

1143

{ 0x18, 0x411111f0 },

1144

{ 0x1a, 0x411111f0 },

1144

{ 0x1a, 0x411111f0 },

1145

{ }

1145

{ }

1146

}

1146

}

1147

},

1147

},

1148

[ALC880_FIXUP_LG_LW25] = {

1148

[ALC880_FIXUP_LG_LW25] = {

1149

.type = HDA_FIXUP_PINS,

1149

.type = HDA_FIXUP_PINS,

1150

.v.pins = (const struct hda_pintbl[]) {

1150

.v.pins = (const struct hda_pintbl[]) {

1151

{ 0x1a, 0x0181344f }, /* line-in */

1151

{ 0x1a, 0x0181344f }, /* line-in */

1152

{ 0x1b, 0x0321403f }, /* headphone */

1152

{ 0x1b, 0x0321403f }, /* headphone */

1153

{ }

1153

{ }

1154

}

1154

}

1155

},

1155

},

1156

[ALC880_FIXUP_W810] = {

1156

[ALC880_FIXUP_W810] = {

1157

.type = HDA_FIXUP_PINS,

1157

.type = HDA_FIXUP_PINS,

1158

.v.pins = (const struct hda_pintbl[]) {

1158

.v.pins = (const struct hda_pintbl[]) {

1159

/* disable bogus unused pins */

1159

/* disable bogus unused pins */

1160

{ 0x17, 0x411111f0 },

1160

{ 0x17, 0x411111f0 },

1161

{ }

1161

{ }

1162

},

1162

},

1163

.chained = true,

1163

.chained = true,

1164

.chain_id = ALC880_FIXUP_GPIO2,

1164

.chain_id = ALC880_FIXUP_GPIO2,

1165

},

1165

},

1166

[ALC880_FIXUP_EAPD_COEF] = {

1166

[ALC880_FIXUP_EAPD_COEF] = {

1167

.type = HDA_FIXUP_VERBS,

1167

.type = HDA_FIXUP_VERBS,

1168

.v.verbs = (const struct hda_verb[]) {

1168

.v.verbs = (const struct hda_verb[]) {

1169

/* change to EAPD mode */

1169

/* change to EAPD mode */

1170

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1170

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1171

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1171

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1172

{}

1172

{}

1173

},

1173

},

1174

},

1174

},

1175

[ALC880_FIXUP_TCL_S700] = {

1175

[ALC880_FIXUP_TCL_S700] = {

1176

.type = HDA_FIXUP_VERBS,

1176

.type = HDA_FIXUP_VERBS,

1177

.v.verbs = (const struct hda_verb[]) {

1177

.v.verbs = (const struct hda_verb[]) {

1178

/* change to EAPD mode */

1178

/* change to EAPD mode */

1179

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1179

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1180

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

1180

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

1181

{}

1181

{}

1182

},

1182

},

1183

.chained = true,

1183

.chained = true,

1184

.chain_id = ALC880_FIXUP_GPIO2,

1184

.chain_id = ALC880_FIXUP_GPIO2,

1185

},

1185

},

1186

[ALC880_FIXUP_VOL_KNOB] = {

1186

[ALC880_FIXUP_VOL_KNOB] = {

1187

.type = HDA_FIXUP_FUNC,

1187

.type = HDA_FIXUP_FUNC,

1188

.v.func = alc880_fixup_vol_knob,

1188

.v.func = alc880_fixup_vol_knob,

1189

},

1189

},

1190

[ALC880_FIXUP_FUJITSU] = {

1190

[ALC880_FIXUP_FUJITSU] = {

1191

/* override all pins as BIOS on old Amilo is broken */

1191

/* override all pins as BIOS on old Amilo is broken */

1192

.type = HDA_FIXUP_PINS,

1192

.type = HDA_FIXUP_PINS,

1193

.v.pins = (const struct hda_pintbl[]) {

1193

.v.pins = (const struct hda_pintbl[]) {

1194

{ 0x14, 0x0121411f }, /* HP */

1194

{ 0x14, 0x0121411f }, /* HP */

1195

{ 0x15, 0x99030120 }, /* speaker */

1195

{ 0x15, 0x99030120 }, /* speaker */

1196

{ 0x16, 0x99030130 }, /* bass speaker */

1196

{ 0x16, 0x99030130 }, /* bass speaker */

1197

{ 0x17, 0x411111f0 }, /* N/A */

1197

{ 0x17, 0x411111f0 }, /* N/A */

1198

{ 0x18, 0x411111f0 }, /* N/A */

1198

{ 0x18, 0x411111f0 }, /* N/A */

1199

{ 0x19, 0x01a19950 }, /* mic-in */

1199

{ 0x19, 0x01a19950 }, /* mic-in */

1200

{ 0x1a, 0x411111f0 }, /* N/A */

1200

{ 0x1a, 0x411111f0 }, /* N/A */

1201

{ 0x1b, 0x411111f0 }, /* N/A */

1201

{ 0x1b, 0x411111f0 }, /* N/A */

1202

{ 0x1c, 0x411111f0 }, /* N/A */

1202

{ 0x1c, 0x411111f0 }, /* N/A */

1203

{ 0x1d, 0x411111f0 }, /* N/A */

1203

{ 0x1d, 0x411111f0 }, /* N/A */

1204

{ 0x1e, 0x01454140 }, /* SPDIF out */

1204

{ 0x1e, 0x01454140 }, /* SPDIF out */

1205

{ }

1205

{ }

1206

},

1206

},

1207

.chained = true,

1207

.chained = true,

1208

.chain_id = ALC880_FIXUP_VOL_KNOB,

1208

.chain_id = ALC880_FIXUP_VOL_KNOB,

1209

},

1209

},

1210

[ALC880_FIXUP_F1734] = {

1210

[ALC880_FIXUP_F1734] = {

1211

/* almost compatible with FUJITSU, but no bass and SPDIF */

1211

/* almost compatible with FUJITSU, but no bass and SPDIF */

1212

.type = HDA_FIXUP_PINS,

1212

.type = HDA_FIXUP_PINS,

1213

.v.pins = (const struct hda_pintbl[]) {

1213

.v.pins = (const struct hda_pintbl[]) {

1214

{ 0x14, 0x0121411f }, /* HP */

1214

{ 0x14, 0x0121411f }, /* HP */

1215

{ 0x15, 0x99030120 }, /* speaker */

1215

{ 0x15, 0x99030120 }, /* speaker */

1216

{ 0x16, 0x411111f0 }, /* N/A */

1216

{ 0x16, 0x411111f0 }, /* N/A */

1217

{ 0x17, 0x411111f0 }, /* N/A */

1217

{ 0x17, 0x411111f0 }, /* N/A */

1218

{ 0x18, 0x411111f0 }, /* N/A */

1218

{ 0x18, 0x411111f0 }, /* N/A */

1219

{ 0x19, 0x01a19950 }, /* mic-in */

1219

{ 0x19, 0x01a19950 }, /* mic-in */

1220

{ 0x1a, 0x411111f0 }, /* N/A */

1220

{ 0x1a, 0x411111f0 }, /* N/A */

1221

{ 0x1b, 0x411111f0 }, /* N/A */

1221

{ 0x1b, 0x411111f0 }, /* N/A */

1222

{ 0x1c, 0x411111f0 }, /* N/A */

1222

{ 0x1c, 0x411111f0 }, /* N/A */

1223

{ 0x1d, 0x411111f0 }, /* N/A */

1223

{ 0x1d, 0x411111f0 }, /* N/A */

1224

{ 0x1e, 0x411111f0 }, /* N/A */

1224

{ 0x1e, 0x411111f0 }, /* N/A */

1225

{ }

1225

{ }

1226

},

1226

},

1227

.chained = true,

1227

.chained = true,

1228

.chain_id = ALC880_FIXUP_VOL_KNOB,

1228

.chain_id = ALC880_FIXUP_VOL_KNOB,

1229

},

1229

},

1230

[ALC880_FIXUP_UNIWILL] = {

1230

[ALC880_FIXUP_UNIWILL] = {

1231

/* need to fix HP and speaker pins to be parsed correctly */

1231

/* need to fix HP and speaker pins to be parsed correctly */

1232

.type = HDA_FIXUP_PINS,

1232

.type = HDA_FIXUP_PINS,

1233

.v.pins = (const struct hda_pintbl[]) {

1233

.v.pins = (const struct hda_pintbl[]) {

1234

{ 0x14, 0x0121411f }, /* HP */

1234

{ 0x14, 0x0121411f }, /* HP */

1235

{ 0x15, 0x99030120 }, /* speaker */

1235

{ 0x15, 0x99030120 }, /* speaker */

1236

{ 0x16, 0x99030130 }, /* bass speaker */

1236

{ 0x16, 0x99030130 }, /* bass speaker */

1237

{ }

1237

{ }

1238

},

1238

},

1239

},

1239

},

1240

[ALC880_FIXUP_UNIWILL_DIG] = {

1240

[ALC880_FIXUP_UNIWILL_DIG] = {

1241

.type = HDA_FIXUP_PINS,

1241

.type = HDA_FIXUP_PINS,

1242

.v.pins = (const struct hda_pintbl[]) {

1242

.v.pins = (const struct hda_pintbl[]) {

1243

/* disable bogus unused pins */

1243

/* disable bogus unused pins */

1244

{ 0x17, 0x411111f0 },

1244

{ 0x17, 0x411111f0 },

1245

{ 0x19, 0x411111f0 },

1245

{ 0x19, 0x411111f0 },

1246

{ 0x1b, 0x411111f0 },

1246

{ 0x1b, 0x411111f0 },

1247

{ 0x1f, 0x411111f0 },

1247

{ 0x1f, 0x411111f0 },

1248

{ }

1248

{ }

1249

}

1249

}

1250

},

1250

},

1251

[ALC880_FIXUP_Z71V] = {

1251

[ALC880_FIXUP_Z71V] = {

1252

.type = HDA_FIXUP_PINS,

1252

.type = HDA_FIXUP_PINS,

1253

.v.pins = (const struct hda_pintbl[]) {

1253

.v.pins = (const struct hda_pintbl[]) {

1254

/* set up the whole pins as BIOS is utterly broken */

1254

/* set up the whole pins as BIOS is utterly broken */

1255

{ 0x14, 0x99030120 }, /* speaker */

1255

{ 0x14, 0x99030120 }, /* speaker */

1256

{ 0x15, 0x0121411f }, /* HP */

1256

{ 0x15, 0x0121411f }, /* HP */

1257

{ 0x16, 0x411111f0 }, /* N/A */

1257

{ 0x16, 0x411111f0 }, /* N/A */

1258

{ 0x17, 0x411111f0 }, /* N/A */

1258

{ 0x17, 0x411111f0 }, /* N/A */

1259

{ 0x18, 0x01a19950 }, /* mic-in */

1259

{ 0x18, 0x01a19950 }, /* mic-in */

1260

{ 0x19, 0x411111f0 }, /* N/A */

1260

{ 0x19, 0x411111f0 }, /* N/A */

1261

{ 0x1a, 0x01813031 }, /* line-in */

1261

{ 0x1a, 0x01813031 }, /* line-in */

1262

{ 0x1b, 0x411111f0 }, /* N/A */

1262

{ 0x1b, 0x411111f0 }, /* N/A */

1263

{ 0x1c, 0x411111f0 }, /* N/A */

1263

{ 0x1c, 0x411111f0 }, /* N/A */

1264

{ 0x1d, 0x411111f0 }, /* N/A */

1264

{ 0x1d, 0x411111f0 }, /* N/A */

1265

{ 0x1e, 0x0144111e }, /* SPDIF */

1265

{ 0x1e, 0x0144111e }, /* SPDIF */

1266

{ }

1266

{ }

1267

}

1267

}

1268

},

1268

},

1269

[ALC880_FIXUP_ASUS_W5A] = {

1269

[ALC880_FIXUP_ASUS_W5A] = {

1270

.type = HDA_FIXUP_PINS,

1270

.type = HDA_FIXUP_PINS,

1271

.v.pins = (const struct hda_pintbl[]) {

1271

.v.pins = (const struct hda_pintbl[]) {

1272

/* set up the whole pins as BIOS is utterly broken */

1272

/* set up the whole pins as BIOS is utterly broken */

1273

{ 0x14, 0x0121411f }, /* HP */

1273

{ 0x14, 0x0121411f }, /* HP */

1274

{ 0x15, 0x411111f0 }, /* N/A */

1274

{ 0x15, 0x411111f0 }, /* N/A */

1275

{ 0x16, 0x411111f0 }, /* N/A */

1275

{ 0x16, 0x411111f0 }, /* N/A */

1276

{ 0x17, 0x411111f0 }, /* N/A */

1276

{ 0x17, 0x411111f0 }, /* N/A */

1277

{ 0x18, 0x90a60160 }, /* mic */

1277

{ 0x18, 0x90a60160 }, /* mic */

1278

{ 0x19, 0x411111f0 }, /* N/A */

1278

{ 0x19, 0x411111f0 }, /* N/A */

1279

{ 0x1a, 0x411111f0 }, /* N/A */

1279

{ 0x1a, 0x411111f0 }, /* N/A */

1280

{ 0x1b, 0x411111f0 }, /* N/A */

1280

{ 0x1b, 0x411111f0 }, /* N/A */

1281

{ 0x1c, 0x411111f0 }, /* N/A */

1281

{ 0x1c, 0x411111f0 }, /* N/A */

1282

{ 0x1d, 0x411111f0 }, /* N/A */

1282

{ 0x1d, 0x411111f0 }, /* N/A */

1283

{ 0x1e, 0xb743111e }, /* SPDIF out */

1283

{ 0x1e, 0xb743111e }, /* SPDIF out */

1284

{ }

1284

{ }

1285

},

1285

},

1286

.chained = true,

1286

.chained = true,

1287

.chain_id = ALC880_FIXUP_GPIO1,

1287

.chain_id = ALC880_FIXUP_GPIO1,

1288

},

1288

},

1289

[ALC880_FIXUP_3ST_BASE] = {

1289

[ALC880_FIXUP_3ST_BASE] = {

1290

.type = HDA_FIXUP_PINS,

1290

.type = HDA_FIXUP_PINS,

1291

.v.pins = (const struct hda_pintbl[]) {

1291

.v.pins = (const struct hda_pintbl[]) {

1292

{ 0x14, 0x01014010 }, /* line-out */

1292

{ 0x14, 0x01014010 }, /* line-out */

1293

{ 0x15, 0x411111f0 }, /* N/A */

1293

{ 0x15, 0x411111f0 }, /* N/A */

1294

{ 0x16, 0x411111f0 }, /* N/A */

1294

{ 0x16, 0x411111f0 }, /* N/A */

1295

{ 0x17, 0x411111f0 }, /* N/A */

1295

{ 0x17, 0x411111f0 }, /* N/A */

1296

{ 0x18, 0x01a19c30 }, /* mic-in */

1296

{ 0x18, 0x01a19c30 }, /* mic-in */

1297

{ 0x19, 0x0121411f }, /* HP */

1297

{ 0x19, 0x0121411f }, /* HP */

1298

{ 0x1a, 0x01813031 }, /* line-in */

1298

{ 0x1a, 0x01813031 }, /* line-in */

1299

{ 0x1b, 0x02a19c40 }, /* front-mic */

1299

{ 0x1b, 0x02a19c40 }, /* front-mic */

1300

{ 0x1c, 0x411111f0 }, /* N/A */

1300

{ 0x1c, 0x411111f0 }, /* N/A */

1301

{ 0x1d, 0x411111f0 }, /* N/A */

1301

{ 0x1d, 0x411111f0 }, /* N/A */

1302

/* 0x1e is filled in below */

1302

/* 0x1e is filled in below */

1303

{ 0x1f, 0x411111f0 }, /* N/A */

1303

{ 0x1f, 0x411111f0 }, /* N/A */

1304

{ }

1304

{ }

1305

}

1305

}

1306

},

1306

},

1307

[ALC880_FIXUP_3ST] = {

1307

[ALC880_FIXUP_3ST] = {

1308

.type = HDA_FIXUP_PINS,

1308

.type = HDA_FIXUP_PINS,

1309

.v.pins = (const struct hda_pintbl[]) {

1309

.v.pins = (const struct hda_pintbl[]) {

1310

{ 0x1e, 0x411111f0 }, /* N/A */

1310

{ 0x1e, 0x411111f0 }, /* N/A */

1311

{ }

1311

{ }

1312

},

1312

},

1313

.chained = true,

1313

.chained = true,

1314

.chain_id = ALC880_FIXUP_3ST_BASE,

1314

.chain_id = ALC880_FIXUP_3ST_BASE,

1315

},

1315

},

1316

[ALC880_FIXUP_3ST_DIG] = {

1316

[ALC880_FIXUP_3ST_DIG] = {

1317

.type = HDA_FIXUP_PINS,

1317

.type = HDA_FIXUP_PINS,

1318

.v.pins = (const struct hda_pintbl[]) {

1318

.v.pins = (const struct hda_pintbl[]) {

1319

{ 0x1e, 0x0144111e }, /* SPDIF */

1319

{ 0x1e, 0x0144111e }, /* SPDIF */

1320

{ }

1320

{ }

1321

},

1321

},

1322

.chained = true,

1322

.chained = true,

1323

.chain_id = ALC880_FIXUP_3ST_BASE,

1323

.chain_id = ALC880_FIXUP_3ST_BASE,

1324

},

1324

},

1325

[ALC880_FIXUP_5ST_BASE] = {

1325

[ALC880_FIXUP_5ST_BASE] = {

1326

.type = HDA_FIXUP_PINS,

1326

.type = HDA_FIXUP_PINS,

1327

.v.pins = (const struct hda_pintbl[]) {

1327

.v.pins = (const struct hda_pintbl[]) {

1328

{ 0x14, 0x01014010 }, /* front */

1328

{ 0x14, 0x01014010 }, /* front */

1329

{ 0x15, 0x411111f0 }, /* N/A */

1329

{ 0x15, 0x411111f0 }, /* N/A */

1330

{ 0x16, 0x01011411 }, /* CLFE */

1330

{ 0x16, 0x01011411 }, /* CLFE */

1331

{ 0x17, 0x01016412 }, /* surr */

1331

{ 0x17, 0x01016412 }, /* surr */

1332

{ 0x18, 0x01a19c30 }, /* mic-in */

1332

{ 0x18, 0x01a19c30 }, /* mic-in */

1333

{ 0x19, 0x0121411f }, /* HP */

1333

{ 0x19, 0x0121411f }, /* HP */

1334

{ 0x1a, 0x01813031 }, /* line-in */

1334

{ 0x1a, 0x01813031 }, /* line-in */

1335

{ 0x1b, 0x02a19c40 }, /* front-mic */

1335

{ 0x1b, 0x02a19c40 }, /* front-mic */

1336

{ 0x1c, 0x411111f0 }, /* N/A */

1336

{ 0x1c, 0x411111f0 }, /* N/A */

1337

{ 0x1d, 0x411111f0 }, /* N/A */

1337

{ 0x1d, 0x411111f0 }, /* N/A */

1338

/* 0x1e is filled in below */

1338

/* 0x1e is filled in below */

1339

{ 0x1f, 0x411111f0 }, /* N/A */

1339

{ 0x1f, 0x411111f0 }, /* N/A */

1340

{ }

1340

{ }

1341

}

1341

}

1342

},

1342

},

1343

[ALC880_FIXUP_5ST] = {

1343

[ALC880_FIXUP_5ST] = {

1344

.type = HDA_FIXUP_PINS,

1344

.type = HDA_FIXUP_PINS,

1345

.v.pins = (const struct hda_pintbl[]) {

1345

.v.pins = (const struct hda_pintbl[]) {

1346

{ 0x1e, 0x411111f0 }, /* N/A */

1346

{ 0x1e, 0x411111f0 }, /* N/A */

1347

{ }

1347

{ }

1348

},

1348

},

1349

.chained = true,

1349

.chained = true,

1350

.chain_id = ALC880_FIXUP_5ST_BASE,

1350

.chain_id = ALC880_FIXUP_5ST_BASE,

1351

},

1351

},

1352

[ALC880_FIXUP_5ST_DIG] = {

1352

[ALC880_FIXUP_5ST_DIG] = {

1353

.type = HDA_FIXUP_PINS,

1353

.type = HDA_FIXUP_PINS,

1354

.v.pins = (const struct hda_pintbl[]) {

1354

.v.pins = (const struct hda_pintbl[]) {

1355

{ 0x1e, 0x0144111e }, /* SPDIF */

1355

{ 0x1e, 0x0144111e }, /* SPDIF */

1356

{ }

1356

{ }

1357

},

1357

},

1358

.chained = true,

1358

.chained = true,

1359

.chain_id = ALC880_FIXUP_5ST_BASE,

1359

.chain_id = ALC880_FIXUP_5ST_BASE,

1360

},

1360

},

1361

[ALC880_FIXUP_6ST_BASE] = {

1361

[ALC880_FIXUP_6ST_BASE] = {

1362

.type = HDA_FIXUP_PINS,

1362

.type = HDA_FIXUP_PINS,

1363

.v.pins = (const struct hda_pintbl[]) {

1363

.v.pins = (const struct hda_pintbl[]) {

1364

{ 0x14, 0x01014010 }, /* front */

1364

{ 0x14, 0x01014010 }, /* front */

1365

{ 0x15, 0x01016412 }, /* surr */

1365

{ 0x15, 0x01016412 }, /* surr */

1366

{ 0x16, 0x01011411 }, /* CLFE */

1366

{ 0x16, 0x01011411 }, /* CLFE */

1367

{ 0x17, 0x01012414 }, /* side */

1367

{ 0x17, 0x01012414 }, /* side */

1368

{ 0x18, 0x01a19c30 }, /* mic-in */

1368

{ 0x18, 0x01a19c30 }, /* mic-in */

1369

{ 0x19, 0x02a19c40 }, /* front-mic */

1369

{ 0x19, 0x02a19c40 }, /* front-mic */

1370

{ 0x1a, 0x01813031 }, /* line-in */

1370

{ 0x1a, 0x01813031 }, /* line-in */

1371

{ 0x1b, 0x0121411f }, /* HP */

1371

{ 0x1b, 0x0121411f }, /* HP */

1372

{ 0x1c, 0x411111f0 }, /* N/A */

1372

{ 0x1c, 0x411111f0 }, /* N/A */

1373

{ 0x1d, 0x411111f0 }, /* N/A */

1373

{ 0x1d, 0x411111f0 }, /* N/A */

1374

/* 0x1e is filled in below */

1374

/* 0x1e is filled in below */

1375

{ 0x1f, 0x411111f0 }, /* N/A */

1375

{ 0x1f, 0x411111f0 }, /* N/A */

1376

{ }

1376

{ }

1377

}

1377

}

1378

},

1378

},

1379

[ALC880_FIXUP_6ST] = {

1379

[ALC880_FIXUP_6ST] = {

1380

.type = HDA_FIXUP_PINS,

1380

.type = HDA_FIXUP_PINS,

1381

.v.pins = (const struct hda_pintbl[]) {

1381

.v.pins = (const struct hda_pintbl[]) {

1382

{ 0x1e, 0x411111f0 }, /* N/A */

1382

{ 0x1e, 0x411111f0 }, /* N/A */

1383

{ }

1383

{ }

1384

},

1384

},

1385

.chained = true,

1385

.chained = true,

1386

.chain_id = ALC880_FIXUP_6ST_BASE,

1386

.chain_id = ALC880_FIXUP_6ST_BASE,

1387

},

1387

},

1388

[ALC880_FIXUP_6ST_DIG] = {

1388

[ALC880_FIXUP_6ST_DIG] = {

1389

.type = HDA_FIXUP_PINS,

1389

.type = HDA_FIXUP_PINS,

1390

.v.pins = (const struct hda_pintbl[]) {

1390

.v.pins = (const struct hda_pintbl[]) {

1391

{ 0x1e, 0x0144111e }, /* SPDIF */

1391

{ 0x1e, 0x0144111e }, /* SPDIF */

1392

{ }

1392

{ }

1393

},

1393

},

1394

.chained = true,

1394

.chained = true,

1395

.chain_id = ALC880_FIXUP_6ST_BASE,

1395

.chain_id = ALC880_FIXUP_6ST_BASE,

1396

},

1396

},

1397

[ALC880_FIXUP_6ST_AUTOMUTE] = {

1397

[ALC880_FIXUP_6ST_AUTOMUTE] = {

1398

.type = HDA_FIXUP_PINS,

1398

.type = HDA_FIXUP_PINS,

1399

.v.pins = (const struct hda_pintbl[]) {

1399

.v.pins = (const struct hda_pintbl[]) {

1400

{ 0x1b, 0x0121401f }, /* HP with jack detect */

1400

{ 0x1b, 0x0121401f }, /* HP with jack detect */

1401

{ }

1401

{ }

1402

},

1402

},

1403

.chained_before = true,

1403

.chained_before = true,

1404

.chain_id = ALC880_FIXUP_6ST_BASE,

1404

.chain_id = ALC880_FIXUP_6ST_BASE,

1405

},

1405

},

1406

};

1406

};

1407

1408

static const struct snd_pci_quirk alc880_fixup_tbl[] = {

1408

static const struct snd_pci_quirk alc880_fixup_tbl[] = {

1409

SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),

1409

SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),

1410

SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),

1410

SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),

1411

SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),

1411

SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),

1412

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),

1412

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),

1413

SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),

1413

SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),

1414

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),

1414

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),

1415

SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),

1415

SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),

1416

SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),

1416

SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),

1417

SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),

1417

SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),

1418

SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),

1418

SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),

1419

SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),

1419

SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),

1420

SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),

1420

SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),

1421

SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),

1421

SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),

1422

SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),

1422

SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),

1423

SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),

1423

SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),

1424

SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),

1424

SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),

1425

SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),

1425

SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),

1426

SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),

1426

SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),

1427

SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),

1427

SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),

1428

SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),

1428

SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),

1429

SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),

1429

SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),

1430

SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),

1430

SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),

1431

1432

/* Below is the copied entries from alc880_quirks.c.

1432

/* Below is the copied entries from alc880_quirks.c.

1433

* It's not quite sure whether BIOS sets the correct pin-config table

1433

* It's not quite sure whether BIOS sets the correct pin-config table

1434

* on these machines, thus they are kept to be compatible with

1434

* on these machines, thus they are kept to be compatible with

1435

* the old static quirks. Once when it's confirmed to work without

1435

* the old static quirks. Once when it's confirmed to work without

1436

* these overrides, it'd be better to remove.

1436

* these overrides, it'd be better to remove.

1437

*/

1437

*/

1438

SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),

1438

SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),

1439

SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),

1439

SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),

1440

SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),

1440

SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),

1441

SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),

1441

SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),

1442

SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),

1442

SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),

1443

SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),

1443

SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),

1444

SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),

1444

SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),

1445

SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),

1445

SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),

1446

SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),

1446

SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),

1447

SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),

1447

SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),

1448

SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),

1448

SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),

1449

SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),

1449

SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),

1450

SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),

1450

SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),

1451

SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),

1451

SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),

1452

SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),

1452

SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),

1453

SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),

1453

SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),

1454

SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),

1454

SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),

1455

SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),

1455

SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),

1456

SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),

1456

SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),

1457

SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),

1457

SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),

1458

SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),

1458

SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),

1459

SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */

1459

SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */

1460

SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),

1460

SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),

1461

SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1461

SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1462

SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1462

SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1463

SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1463

SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1464

SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1464

SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1465

SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1465

SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1466

SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1466

SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1467

SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1467

SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),

1468

SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1468

SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1469

SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1469

SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1470

SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1470

SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),

1471

/* default Intel */

1471

/* default Intel */

1472

SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),

1472

SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),

1473

SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),

1473

SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),

1474

SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),

1474

SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),

1475

{}

1475

{}

1476

};

1476

};

1477

1478

static const struct hda_model_fixup alc880_fixup_models[] = {

1478

static const struct hda_model_fixup alc880_fixup_models[] = {

1479

{.id = ALC880_FIXUP_3ST, .name = "3stack"},

1479

{.id = ALC880_FIXUP_3ST, .name = "3stack"},

1480

{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},

1480

{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},

1481

{.id = ALC880_FIXUP_5ST, .name = "5stack"},

1481

{.id = ALC880_FIXUP_5ST, .name = "5stack"},

1482

{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},

1482

{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},

1483

{.id = ALC880_FIXUP_6ST, .name = "6stack"},

1483

{.id = ALC880_FIXUP_6ST, .name = "6stack"},

1484

{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},

1484

{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},

1485

{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},

1485

{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},

1486

{}

1486

{}

1487

};

1487

};

1488

1489

1490

/*

1490

/*

1491

* OK, here we have finally the patch for ALC880

1491

* OK, here we have finally the patch for ALC880

1492

*/

1492

*/

1493

static int patch_alc880(struct hda_codec *codec)

1493

static int patch_alc880(struct hda_codec *codec)

1494

{

1494

{

1495

struct alc_spec *spec;

1495

struct alc_spec *spec;

1496

int err;

1496

int err;

1497

1498

err = alc_alloc_spec(codec, 0x0b);

1498

err = alc_alloc_spec(codec, 0x0b);

1499

if (err < 0)

1499

if (err < 0)

1500

return err;

1500

return err;

1501

1502

spec = codec->spec;

1502

spec = codec->spec;

1503

spec->gen.need_dac_fix = 1;

1503

spec->gen.need_dac_fix = 1;

1504

spec->gen.beep_nid = 0x01;

1504

spec->gen.beep_nid = 0x01;

1505

1506

snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,

1506

snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,

1507

alc880_fixups);

1507

alc880_fixups);

1508

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1508

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1509

1510

/* automatic parse from the BIOS config */

1510

/* automatic parse from the BIOS config */

1511

err = alc880_parse_auto_config(codec);

1511

err = alc880_parse_auto_config(codec);

1512

if (err < 0)

1512

if (err < 0)

1513

goto error;

1513

goto error;

1514

1515

if (!spec->gen.no_analog)

1515

if (!spec->gen.no_analog)

1516

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

1516

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

1517

1518

codec->patch_ops = alc_patch_ops;

1518

codec->patch_ops = alc_patch_ops;

1519

codec->patch_ops.unsol_event = alc880_unsol_event;

1519

codec->patch_ops.unsol_event = alc880_unsol_event;

1520

1521

1522

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1522

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1523

1524

return 0;

1524

return 0;

1525

1526

error:

1526

error:

1527

alc_free(codec);

1527

alc_free(codec);

1528

return err;

1528

return err;

1529

}

1529

}

1530

1531

1532

/*

1532

/*

1533

* ALC260 support

1533

* ALC260 support

1534

*/

1534

*/

1535

static int alc260_parse_auto_config(struct hda_codec *codec)

1535

static int alc260_parse_auto_config(struct hda_codec *codec)

1536

{

1536

{

1537

static const hda_nid_t alc260_ignore[] = { 0x17, 0 };

1537

static const hda_nid_t alc260_ignore[] = { 0x17, 0 };

1538

static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };

1538

static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };

1539

return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);

1539

return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);

1540

}

1540

}

1541

1542

/*

1542

/*

1543

* Pin config fixes

1543

* Pin config fixes

1544

*/

1544

*/

1545

enum {

1545

enum {

1546

ALC260_FIXUP_HP_DC5750,

1546

ALC260_FIXUP_HP_DC5750,

1547

ALC260_FIXUP_HP_PIN_0F,

1547

ALC260_FIXUP_HP_PIN_0F,

1548

ALC260_FIXUP_COEF,

1548

ALC260_FIXUP_COEF,

1549

ALC260_FIXUP_GPIO1,

1549

ALC260_FIXUP_GPIO1,

1550

ALC260_FIXUP_GPIO1_TOGGLE,

1550

ALC260_FIXUP_GPIO1_TOGGLE,

1551

ALC260_FIXUP_REPLACER,

1551

ALC260_FIXUP_REPLACER,

1552

ALC260_FIXUP_HP_B1900,

1552

ALC260_FIXUP_HP_B1900,

1553

ALC260_FIXUP_KN1,

1553

ALC260_FIXUP_KN1,

1554

ALC260_FIXUP_FSC_S7020,

1554

ALC260_FIXUP_FSC_S7020,

1555

ALC260_FIXUP_FSC_S7020_JWSE,

1555

ALC260_FIXUP_FSC_S7020_JWSE,

1556

ALC260_FIXUP_VAIO_PINS,

1556

ALC260_FIXUP_VAIO_PINS,

1557

};

1557

};

1558

1559

static void alc260_gpio1_automute(struct hda_codec *codec)

1559

static void alc260_gpio1_automute(struct hda_codec *codec)

1560

{

1560

{

1561

struct alc_spec *spec = codec->spec;

1561

struct alc_spec *spec = codec->spec;

1562

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

1562

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

1563

spec->gen.hp_jack_present);

1563

spec->gen.hp_jack_present);

1564

}

1564

}

1565

1566

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,

1566

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,

1567

const struct hda_fixup *fix, int action)

1567

const struct hda_fixup *fix, int action)

1568

{

1568

{

1569

struct alc_spec *spec = codec->spec;

1569

struct alc_spec *spec = codec->spec;

1570

if (action == HDA_FIXUP_ACT_PROBE) {

1570

if (action == HDA_FIXUP_ACT_PROBE) {

1571

/* although the machine has only one output pin, we need to

1571

/* although the machine has only one output pin, we need to

1572

* toggle GPIO1 according to the jack state

1572

* toggle GPIO1 according to the jack state

1573

*/

1573

*/

1574

spec->gen.automute_hook = alc260_gpio1_automute;

1574

spec->gen.automute_hook = alc260_gpio1_automute;

1575

spec->gen.detect_hp = 1;

1575

spec->gen.detect_hp = 1;

1576

spec->gen.automute_speaker = 1;

1576

spec->gen.automute_speaker = 1;

1577

spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */

1577

spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */

1578

snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,

1578

snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,

1579

snd_hda_gen_hp_automute);

1579

snd_hda_gen_hp_automute);

1580

snd_hda_add_verbs(codec, alc_gpio1_init_verbs);

1580

snd_hda_add_verbs(codec, alc_gpio1_init_verbs);

1581

}

1581

}

1582

}

1582

}

1583

1584

static void alc260_fixup_kn1(struct hda_codec *codec,

1584

static void alc260_fixup_kn1(struct hda_codec *codec,

1585

const struct hda_fixup *fix, int action)

1585

const struct hda_fixup *fix, int action)

1586

{

1586

{

1587

struct alc_spec *spec = codec->spec;

1587

struct alc_spec *spec = codec->spec;

1588

static const struct hda_pintbl pincfgs[] = {

1588

static const struct hda_pintbl pincfgs[] = {

1589

{ 0x0f, 0x02214000 }, /* HP/speaker */

1589

{ 0x0f, 0x02214000 }, /* HP/speaker */

1590

{ 0x12, 0x90a60160 }, /* int mic */

1590

{ 0x12, 0x90a60160 }, /* int mic */

1591

{ 0x13, 0x02a19000 }, /* ext mic */

1591

{ 0x13, 0x02a19000 }, /* ext mic */

1592

{ 0x18, 0x01446000 }, /* SPDIF out */

1592

{ 0x18, 0x01446000 }, /* SPDIF out */

1593

/* disable bogus I/O pins */

1593

/* disable bogus I/O pins */

1594

{ 0x10, 0x411111f0 },

1594

{ 0x10, 0x411111f0 },

1595

{ 0x11, 0x411111f0 },

1595

{ 0x11, 0x411111f0 },

1596

{ 0x14, 0x411111f0 },

1596

{ 0x14, 0x411111f0 },

1597

{ 0x15, 0x411111f0 },

1597

{ 0x15, 0x411111f0 },

1598

{ 0x16, 0x411111f0 },

1598

{ 0x16, 0x411111f0 },

1599

{ 0x17, 0x411111f0 },

1599

{ 0x17, 0x411111f0 },

1600

{ 0x19, 0x411111f0 },

1600

{ 0x19, 0x411111f0 },

1601

{ }

1601

{ }

1602

};

1602

};

1603

1604

switch (action) {

1604

switch (action) {

1605

case HDA_FIXUP_ACT_PRE_PROBE:

1605

case HDA_FIXUP_ACT_PRE_PROBE:

1606

snd_hda_apply_pincfgs(codec, pincfgs);

1606

snd_hda_apply_pincfgs(codec, pincfgs);

1607

break;

1607

break;

1608

case HDA_FIXUP_ACT_PROBE:

1608

case HDA_FIXUP_ACT_PROBE:

1609

spec->init_amp = ALC_INIT_NONE;

1609

spec->init_amp = ALC_INIT_NONE;

1610

break;

1610

break;

1611

}

1611

}

1612

}

1612

}

1613

1614

static void alc260_fixup_fsc_s7020(struct hda_codec *codec,

1614

static void alc260_fixup_fsc_s7020(struct hda_codec *codec,

1615

const struct hda_fixup *fix, int action)

1615

const struct hda_fixup *fix, int action)

1616

{

1616

{

1617

struct alc_spec *spec = codec->spec;

1617

struct alc_spec *spec = codec->spec;

1618

if (action == HDA_FIXUP_ACT_PROBE)

1618

if (action == HDA_FIXUP_ACT_PROBE)

1619

spec->init_amp = ALC_INIT_NONE;

1619

spec->init_amp = ALC_INIT_NONE;

1620

}

1620

}

1621

1622

static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,

1622

static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,

1623

const struct hda_fixup *fix, int action)

1623

const struct hda_fixup *fix, int action)

1624

{

1624

{

1625

struct alc_spec *spec = codec->spec;

1625

struct alc_spec *spec = codec->spec;

1626

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1626

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1627

spec->gen.add_jack_modes = 1;

1627

spec->gen.add_jack_modes = 1;

1628

spec->gen.hp_mic = 1;

1628

spec->gen.hp_mic = 1;

1629

}

1629

}

1630

}

1630

}

1631

1632

static const struct hda_fixup alc260_fixups[] = {

1632

static const struct hda_fixup alc260_fixups[] = {

1633

[ALC260_FIXUP_HP_DC5750] = {

1633

[ALC260_FIXUP_HP_DC5750] = {

1634

.type = HDA_FIXUP_PINS,

1634

.type = HDA_FIXUP_PINS,

1635

.v.pins = (const struct hda_pintbl[]) {

1635

.v.pins = (const struct hda_pintbl[]) {

1636

{ 0x11, 0x90130110 }, /* speaker */

1636

{ 0x11, 0x90130110 }, /* speaker */

1637

{ }

1637

{ }

1638

}

1638

}

1639

},

1639

},

1640

[ALC260_FIXUP_HP_PIN_0F] = {

1640

[ALC260_FIXUP_HP_PIN_0F] = {

1641

.type = HDA_FIXUP_PINS,

1641

.type = HDA_FIXUP_PINS,

1642

.v.pins = (const struct hda_pintbl[]) {

1642

.v.pins = (const struct hda_pintbl[]) {

1643

{ 0x0f, 0x01214000 }, /* HP */

1643

{ 0x0f, 0x01214000 }, /* HP */

1644

{ }

1644

{ }

1645

}

1645

}

1646

},

1646

},

1647

[ALC260_FIXUP_COEF] = {

1647

[ALC260_FIXUP_COEF] = {

1648

.type = HDA_FIXUP_VERBS,

1648

.type = HDA_FIXUP_VERBS,

1649

.v.verbs = (const struct hda_verb[]) {

1649

.v.verbs = (const struct hda_verb[]) {

1650

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1650

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1651

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3040 },

1651

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3040 },

1652

{ }

1652

{ }

1653

},

1653

},

1654

.chained = true,

1654

.chained = true,

1655

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1655

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1656

},

1656

},

1657

[ALC260_FIXUP_GPIO1] = {

1657

[ALC260_FIXUP_GPIO1] = {

1658

.type = HDA_FIXUP_VERBS,

1658

.type = HDA_FIXUP_VERBS,

1659

.v.verbs = alc_gpio1_init_verbs,

1659

.v.verbs = alc_gpio1_init_verbs,

1660

},

1660

},

1661

[ALC260_FIXUP_GPIO1_TOGGLE] = {

1661

[ALC260_FIXUP_GPIO1_TOGGLE] = {

1662

.type = HDA_FIXUP_FUNC,

1662

.type = HDA_FIXUP_FUNC,

1663

.v.func = alc260_fixup_gpio1_toggle,

1663

.v.func = alc260_fixup_gpio1_toggle,

1664

.chained = true,

1664

.chained = true,

1665

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1665

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1666

},

1666

},

1667

[ALC260_FIXUP_REPLACER] = {

1667

[ALC260_FIXUP_REPLACER] = {

1668

.type = HDA_FIXUP_VERBS,

1668

.type = HDA_FIXUP_VERBS,

1669

.v.verbs = (const struct hda_verb[]) {

1669

.v.verbs = (const struct hda_verb[]) {

1670

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1670

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1671

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

1671

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

1672

{ }

1672

{ }

1673

},

1673

},

1674

.chained = true,

1674

.chained = true,

1675

.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,

1675

.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,

1676

},

1676

},

1677

[ALC260_FIXUP_HP_B1900] = {

1677

[ALC260_FIXUP_HP_B1900] = {

1678

.type = HDA_FIXUP_FUNC,

1678

.type = HDA_FIXUP_FUNC,

1679

.v.func = alc260_fixup_gpio1_toggle,

1679

.v.func = alc260_fixup_gpio1_toggle,

1680

.chained = true,

1680

.chained = true,

1681

.chain_id = ALC260_FIXUP_COEF,

1681

.chain_id = ALC260_FIXUP_COEF,

1682

},

1682

},

1683

[ALC260_FIXUP_KN1] = {

1683

[ALC260_FIXUP_KN1] = {

1684

.type = HDA_FIXUP_FUNC,

1684

.type = HDA_FIXUP_FUNC,

1685

.v.func = alc260_fixup_kn1,

1685

.v.func = alc260_fixup_kn1,

1686

},

1686

},

1687

[ALC260_FIXUP_FSC_S7020] = {

1687

[ALC260_FIXUP_FSC_S7020] = {

1688

.type = HDA_FIXUP_FUNC,

1688

.type = HDA_FIXUP_FUNC,

1689

.v.func = alc260_fixup_fsc_s7020,

1689

.v.func = alc260_fixup_fsc_s7020,

1690

},

1690

},

1691

[ALC260_FIXUP_FSC_S7020_JWSE] = {

1691

[ALC260_FIXUP_FSC_S7020_JWSE] = {

1692

.type = HDA_FIXUP_FUNC,

1692

.type = HDA_FIXUP_FUNC,

1693

.v.func = alc260_fixup_fsc_s7020_jwse,

1693

.v.func = alc260_fixup_fsc_s7020_jwse,

1694

.chained = true,

1694

.chained = true,

1695

.chain_id = ALC260_FIXUP_FSC_S7020,

1695

.chain_id = ALC260_FIXUP_FSC_S7020,

1696

},

1696

},

1697

[ALC260_FIXUP_VAIO_PINS] = {

1697

[ALC260_FIXUP_VAIO_PINS] = {

1698

.type = HDA_FIXUP_PINS,

1698

.type = HDA_FIXUP_PINS,

1699

.v.pins = (const struct hda_pintbl[]) {

1699

.v.pins = (const struct hda_pintbl[]) {

1700

/* Pin configs are missing completely on some VAIOs */

1700

/* Pin configs are missing completely on some VAIOs */

1701

{ 0x0f, 0x01211020 },

1701

{ 0x0f, 0x01211020 },

1702

{ 0x10, 0x0001003f },

1702

{ 0x10, 0x0001003f },

1703

{ 0x11, 0x411111f0 },

1703

{ 0x11, 0x411111f0 },

1704

{ 0x12, 0x01a15930 },

1704

{ 0x12, 0x01a15930 },

1705

{ 0x13, 0x411111f0 },

1705

{ 0x13, 0x411111f0 },

1706

{ 0x14, 0x411111f0 },

1706

{ 0x14, 0x411111f0 },

1707

{ 0x15, 0x411111f0 },

1707

{ 0x15, 0x411111f0 },

1708

{ 0x16, 0x411111f0 },

1708

{ 0x16, 0x411111f0 },

1709

{ 0x17, 0x411111f0 },

1709

{ 0x17, 0x411111f0 },

1710

{ 0x18, 0x411111f0 },

1710

{ 0x18, 0x411111f0 },

1711

{ 0x19, 0x411111f0 },

1711

{ 0x19, 0x411111f0 },

1712

{ }

1712

{ }

1713

}

1713

}

1714

},

1714

},

1715

};

1715

};

1716

1717

static const struct snd_pci_quirk alc260_fixup_tbl[] = {

1717

static const struct snd_pci_quirk alc260_fixup_tbl[] = {

1718

SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),

1718

SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),

1719

SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),

1719

SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),

1720

SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),

1720

SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),

1721

SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),

1721

SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),

1722

SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),

1722

SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),

1723

SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),

1723

SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),

1724

SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),

1724

SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),

1725

SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),

1725

SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),

1726

SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),

1726

SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),

1727

SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),

1727

SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),

1728

SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),

1728

SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),

1729

SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),

1729

SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),

1730

{}

1730

{}

1731

};

1731

};

1732

1733

static const struct hda_model_fixup alc260_fixup_models[] = {

1733

static const struct hda_model_fixup alc260_fixup_models[] = {

1734

{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},

1734

{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},

1735

{.id = ALC260_FIXUP_COEF, .name = "coef"},

1735

{.id = ALC260_FIXUP_COEF, .name = "coef"},

1736

{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},

1736

{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},

1737

{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},

1737

{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},

1738

{}

1738

{}

1739

};

1739

};

1740

1741

/*

1741

/*

1742

*/

1742

*/

1743

static int patch_alc260(struct hda_codec *codec)

1743

static int patch_alc260(struct hda_codec *codec)

1744

{

1744

{

1745

struct alc_spec *spec;

1745

struct alc_spec *spec;

1746

int err;

1746

int err;

1747

1748

err = alc_alloc_spec(codec, 0x07);

1748

err = alc_alloc_spec(codec, 0x07);

1749

if (err < 0)

1749

if (err < 0)

1750

return err;

1750

return err;

1751

1752

spec = codec->spec;

1752

spec = codec->spec;

1753

/* as quite a few machines require HP amp for speaker outputs,

1753

/* as quite a few machines require HP amp for speaker outputs,

1754

* it's easier to enable it unconditionally; even if it's unneeded,

1754

* it's easier to enable it unconditionally; even if it's unneeded,

1755

* it's almost harmless.

1755

* it's almost harmless.

1756

*/

1756

*/

1757

spec->gen.prefer_hp_amp = 1;

1757

spec->gen.prefer_hp_amp = 1;

1758

spec->gen.beep_nid = 0x01;

1758

spec->gen.beep_nid = 0x01;

1759

1760

snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,

1760

snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,

1761

alc260_fixups);

1761

alc260_fixups);

1762

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1762

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1763

1764

/* automatic parse from the BIOS config */

1764

/* automatic parse from the BIOS config */

1765

err = alc260_parse_auto_config(codec);

1765

err = alc260_parse_auto_config(codec);

1766

if (err < 0)

1766

if (err < 0)

1767

goto error;

1767

goto error;

1768

1769

if (!spec->gen.no_analog)

1769

if (!spec->gen.no_analog)

1770

set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);

1770

set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);

1771

1772

codec->patch_ops = alc_patch_ops;

1772

codec->patch_ops = alc_patch_ops;

1773

spec->shutup = alc_eapd_shutup;

1773

spec->shutup = alc_eapd_shutup;

1774

1775

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1775

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1776

1777

return 0;

1777

return 0;

1778

1779

error:

1779

error:

1780

alc_free(codec);

1780

alc_free(codec);

1781

return err;

1781

return err;

1782

}

1782

}

1783

1784

1785

/*

1785

/*

1786

* ALC882/883/885/888/889 support

1786

* ALC882/883/885/888/889 support

1787

*

1787

*

1788

* ALC882 is almost identical with ALC880 but has cleaner and more flexible

1788

* ALC882 is almost identical with ALC880 but has cleaner and more flexible

1789

* configuration. Each pin widget can choose any input DACs and a mixer.

1789

* configuration. Each pin widget can choose any input DACs and a mixer.

1790

* Each ADC is connected from a mixer of all inputs. This makes possible

1790

* Each ADC is connected from a mixer of all inputs. This makes possible

1791

* 6-channel independent captures.

1791

* 6-channel independent captures.

1792

*

1792

*

1793

* In addition, an independent DAC for the multi-playback (not used in this

1793

* In addition, an independent DAC for the multi-playback (not used in this

1794

* driver yet).

1794

* driver yet).

1795

*/

1795

*/

1796

1797

/*

1797

/*

1798

* Pin config fixes

1798

* Pin config fixes

1799

*/

1799

*/

1800

enum {

1800

enum {

1801

ALC882_FIXUP_ABIT_AW9D_MAX,

1801

ALC882_FIXUP_ABIT_AW9D_MAX,

1802

ALC882_FIXUP_LENOVO_Y530,

1802

ALC882_FIXUP_LENOVO_Y530,

1803

ALC882_FIXUP_PB_M5210,

1803

ALC882_FIXUP_PB_M5210,

1804

ALC882_FIXUP_ACER_ASPIRE_7736,

1804

ALC882_FIXUP_ACER_ASPIRE_7736,

1805

ALC882_FIXUP_ASUS_W90V,

1805

ALC882_FIXUP_ASUS_W90V,

1806

ALC889_FIXUP_CD,

1806

ALC889_FIXUP_CD,

1807

ALC889_FIXUP_FRONT_HP_NO_PRESENCE,

1807

ALC889_FIXUP_FRONT_HP_NO_PRESENCE,

1808

ALC889_FIXUP_VAIO_TT,

1808

ALC889_FIXUP_VAIO_TT,

1809

ALC888_FIXUP_EEE1601,

1809

ALC888_FIXUP_EEE1601,

1810

ALC882_FIXUP_EAPD,

1810

ALC882_FIXUP_EAPD,

1811

ALC883_FIXUP_EAPD,

1811

ALC883_FIXUP_EAPD,

1812

ALC883_FIXUP_ACER_EAPD,

1812

ALC883_FIXUP_ACER_EAPD,

1813

ALC882_FIXUP_GPIO1,

1813

ALC882_FIXUP_GPIO1,

1814

ALC882_FIXUP_GPIO2,

1814

ALC882_FIXUP_GPIO2,

1815

ALC882_FIXUP_GPIO3,

1815

ALC882_FIXUP_GPIO3,

1816

ALC889_FIXUP_COEF,

1816

ALC889_FIXUP_COEF,

1817

ALC882_FIXUP_ASUS_W2JC,

1817

ALC882_FIXUP_ASUS_W2JC,

1818

ALC882_FIXUP_ACER_ASPIRE_4930G,

1818

ALC882_FIXUP_ACER_ASPIRE_4930G,

1819

ALC882_FIXUP_ACER_ASPIRE_8930G,

1819

ALC882_FIXUP_ACER_ASPIRE_8930G,

1820

ALC882_FIXUP_ASPIRE_8930G_VERBS,

1820

ALC882_FIXUP_ASPIRE_8930G_VERBS,

1821

ALC885_FIXUP_MACPRO_GPIO,

1821

ALC885_FIXUP_MACPRO_GPIO,

1822

ALC889_FIXUP_DAC_ROUTE,

1822

ALC889_FIXUP_DAC_ROUTE,

1823

ALC889_FIXUP_MBP_VREF,

1823

ALC889_FIXUP_MBP_VREF,

1824

ALC889_FIXUP_IMAC91_VREF,

1824

ALC889_FIXUP_IMAC91_VREF,

1825

ALC889_FIXUP_MBA11_VREF,

1825

ALC889_FIXUP_MBA11_VREF,

1826

ALC889_FIXUP_MBA21_VREF,

1826

ALC889_FIXUP_MBA21_VREF,

1827

ALC889_FIXUP_MP11_VREF,

1827

ALC889_FIXUP_MP11_VREF,

1828

ALC882_FIXUP_INV_DMIC,

1828

ALC882_FIXUP_INV_DMIC,

1829

ALC882_FIXUP_NO_PRIMARY_HP,

1829

ALC882_FIXUP_NO_PRIMARY_HP,

1830

ALC887_FIXUP_ASUS_BASS,

1830

ALC887_FIXUP_ASUS_BASS,

1831

ALC887_FIXUP_BASS_CHMAP,

1831

ALC887_FIXUP_BASS_CHMAP,

1832

};

1832

};

1833

1834

static void alc889_fixup_coef(struct hda_codec *codec,

1834

static void alc889_fixup_coef(struct hda_codec *codec,

1835

const struct hda_fixup *fix, int action)

1835

const struct hda_fixup *fix, int action)

1836

{

1836

{

1837

if (action != HDA_FIXUP_ACT_INIT)

1837

if (action != HDA_FIXUP_ACT_INIT)

1838

return;

1838

return;

1839

alc889_coef_init(codec);

1839

alc889_coef_init(codec);

1840

}

1840

}

1841

1842

/* toggle speaker-output according to the hp-jack state */

1842

/* toggle speaker-output according to the hp-jack state */

1843

static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)

1843

static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)

1844

{

1844

{

1845

unsigned int gpiostate, gpiomask, gpiodir;

1845

unsigned int gpiostate, gpiomask, gpiodir;

1846

1847

gpiostate = snd_hda_codec_read(codec, codec->afg, 0,

1847

gpiostate = snd_hda_codec_read(codec, codec->afg, 0,

1848

AC_VERB_GET_GPIO_DATA, 0);

1848

AC_VERB_GET_GPIO_DATA, 0);

1849

1850

if (!muted)

1850

if (!muted)

1851

gpiostate |= (1 << pin);

1851

gpiostate |= (1 << pin);

1852

else

1852

else

1853

gpiostate &= ~(1 << pin);

1853

gpiostate &= ~(1 << pin);

1854

1855

gpiomask = snd_hda_codec_read(codec, codec->afg, 0,

1855

gpiomask = snd_hda_codec_read(codec, codec->afg, 0,

1856

AC_VERB_GET_GPIO_MASK, 0);

1856

AC_VERB_GET_GPIO_MASK, 0);

1857

gpiomask |= (1 << pin);

1857

gpiomask |= (1 << pin);

1858

1859

gpiodir = snd_hda_codec_read(codec, codec->afg, 0,

1859

gpiodir = snd_hda_codec_read(codec, codec->afg, 0,

1860

AC_VERB_GET_GPIO_DIRECTION, 0);

1860

AC_VERB_GET_GPIO_DIRECTION, 0);

1861

gpiodir |= (1 << pin);

1861

gpiodir |= (1 << pin);

1862

1863

1864

snd_hda_codec_write(codec, codec->afg, 0,

1864

snd_hda_codec_write(codec, codec->afg, 0,

1865

AC_VERB_SET_GPIO_MASK, gpiomask);

1865

AC_VERB_SET_GPIO_MASK, gpiomask);

1866

snd_hda_codec_write(codec, codec->afg, 0,

1866

snd_hda_codec_write(codec, codec->afg, 0,

1867

AC_VERB_SET_GPIO_DIRECTION, gpiodir);

1867

AC_VERB_SET_GPIO_DIRECTION, gpiodir);

1868

1869

msleep(1);

1869

msleep(1);

1870

1871

snd_hda_codec_write(codec, codec->afg, 0,

1871

snd_hda_codec_write(codec, codec->afg, 0,

1872

AC_VERB_SET_GPIO_DATA, gpiostate);

1872

AC_VERB_SET_GPIO_DATA, gpiostate);

1873

}

1873

}

1874

1875

/* set up GPIO at initialization */

1875

/* set up GPIO at initialization */

1876

static void alc885_fixup_macpro_gpio(struct hda_codec *codec,

1876

static void alc885_fixup_macpro_gpio(struct hda_codec *codec,

1877

const struct hda_fixup *fix, int action)

1877

const struct hda_fixup *fix, int action)

1878

{

1878

{

1879

if (action != HDA_FIXUP_ACT_INIT)

1879

if (action != HDA_FIXUP_ACT_INIT)

1880

return;

1880

return;

1881

alc882_gpio_mute(codec, 0, 0);

1881

alc882_gpio_mute(codec, 0, 0);

1882

alc882_gpio_mute(codec, 1, 0);

1882

alc882_gpio_mute(codec, 1, 0);

1883

}

1883

}

1884

1885

/* Fix the connection of some pins for ALC889:

1885

/* Fix the connection of some pins for ALC889:

1886

* At least, Acer Aspire 5935 shows the connections to DAC3/4 don't

1886

* At least, Acer Aspire 5935 shows the connections to DAC3/4 don't

1887

* work correctly (bko#42740)

1887

* work correctly (bko#42740)

1888

*/

1888

*/

1889

static void alc889_fixup_dac_route(struct hda_codec *codec,

1889

static void alc889_fixup_dac_route(struct hda_codec *codec,

1890

const struct hda_fixup *fix, int action)

1890

const struct hda_fixup *fix, int action)

1891

{

1891

{

1892

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1892

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1893

/* fake the connections during parsing the tree */

1893

/* fake the connections during parsing the tree */

1894

hda_nid_t conn1[2] = { 0x0c, 0x0d };

1894

hda_nid_t conn1[2] = { 0x0c, 0x0d };

1895

hda_nid_t conn2[2] = { 0x0e, 0x0f };

1895

hda_nid_t conn2[2] = { 0x0e, 0x0f };

1896

snd_hda_override_conn_list(codec, 0x14, 2, conn1);

1896

snd_hda_override_conn_list(codec, 0x14, 2, conn1);

1897

snd_hda_override_conn_list(codec, 0x15, 2, conn1);

1897

snd_hda_override_conn_list(codec, 0x15, 2, conn1);

1898

snd_hda_override_conn_list(codec, 0x18, 2, conn2);

1898

snd_hda_override_conn_list(codec, 0x18, 2, conn2);

1899

snd_hda_override_conn_list(codec, 0x1a, 2, conn2);

1899

snd_hda_override_conn_list(codec, 0x1a, 2, conn2);

1900

} else if (action == HDA_FIXUP_ACT_PROBE) {

1900

} else if (action == HDA_FIXUP_ACT_PROBE) {

1901

/* restore the connections */

1901

/* restore the connections */

1902

hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };

1902

hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };

1903

snd_hda_override_conn_list(codec, 0x14, 5, conn);

1903

snd_hda_override_conn_list(codec, 0x14, 5, conn);

1904

snd_hda_override_conn_list(codec, 0x15, 5, conn);

1904

snd_hda_override_conn_list(codec, 0x15, 5, conn);

1905

snd_hda_override_conn_list(codec, 0x18, 5, conn);

1905

snd_hda_override_conn_list(codec, 0x18, 5, conn);

1906

snd_hda_override_conn_list(codec, 0x1a, 5, conn);

1906

snd_hda_override_conn_list(codec, 0x1a, 5, conn);

1907

}

1907

}

1908

}

1908

}

1909

1910

/* Set VREF on HP pin */

1910

/* Set VREF on HP pin */

1911

static void alc889_fixup_mbp_vref(struct hda_codec *codec,

1911

static void alc889_fixup_mbp_vref(struct hda_codec *codec,

1912

const struct hda_fixup *fix, int action)

1912

const struct hda_fixup *fix, int action)

1913

{

1913

{

1914

struct alc_spec *spec = codec->spec;

1914

struct alc_spec *spec = codec->spec;

1915

static hda_nid_t nids[2] = { 0x14, 0x15 };

1915

static hda_nid_t nids[2] = { 0x14, 0x15 };

1916

int i;

1916

int i;

1917

1918

if (action != HDA_FIXUP_ACT_INIT)

1918

if (action != HDA_FIXUP_ACT_INIT)

1919

return;

1919

return;

1920

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

1920

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

1921

unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);

1921

unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);

1922

if (get_defcfg_device(val) != AC_JACK_HP_OUT)

1922

if (get_defcfg_device(val) != AC_JACK_HP_OUT)

1923

continue;

1923

continue;

1924

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1924

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1925

val |= AC_PINCTL_VREF_80;

1925

val |= AC_PINCTL_VREF_80;

1926

snd_hda_set_pin_ctl(codec, nids[i], val);

1926

snd_hda_set_pin_ctl(codec, nids[i], val);

1927

spec->gen.keep_vref_in_automute = 1;

1927

spec->gen.keep_vref_in_automute = 1;

1928

break;

1928

break;

1929

}

1929

}

1930

}

1930

}

1931

1932

static void alc889_fixup_mac_pins(struct hda_codec *codec,

1932

static void alc889_fixup_mac_pins(struct hda_codec *codec,

1933

const hda_nid_t *nids, int num_nids)

1933

const hda_nid_t *nids, int num_nids)

1934

{

1934

{

1935

struct alc_spec *spec = codec->spec;

1935

struct alc_spec *spec = codec->spec;

1936

int i;

1936

int i;

1937

1938

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

1938

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

1939

unsigned int val;

1939

unsigned int val;

1940

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1940

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1941

val |= AC_PINCTL_VREF_50;

1941

val |= AC_PINCTL_VREF_50;

1942

snd_hda_set_pin_ctl(codec, nids[i], val);

1942

snd_hda_set_pin_ctl(codec, nids[i], val);

1943

}

1943

}

1944

spec->gen.keep_vref_in_automute = 1;

1944

spec->gen.keep_vref_in_automute = 1;

1945

}

1945

}

1946

1947

/* Set VREF on speaker pins on imac91 */

1947

/* Set VREF on speaker pins on imac91 */

1948

static void alc889_fixup_imac91_vref(struct hda_codec *codec,

1948

static void alc889_fixup_imac91_vref(struct hda_codec *codec,

1949

const struct hda_fixup *fix, int action)

1949

const struct hda_fixup *fix, int action)

1950

{

1950

{

1951

static hda_nid_t nids[2] = { 0x18, 0x1a };

1951

static hda_nid_t nids[2] = { 0x18, 0x1a };

1952

1953

if (action == HDA_FIXUP_ACT_INIT)

1953

if (action == HDA_FIXUP_ACT_INIT)

1954

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1954

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1955

}

1955

}

1956

1957

/* Set VREF on speaker pins on mba11 */

1957

/* Set VREF on speaker pins on mba11 */

1958

static void alc889_fixup_mba11_vref(struct hda_codec *codec,

1958

static void alc889_fixup_mba11_vref(struct hda_codec *codec,

1959

const struct hda_fixup *fix, int action)

1959

const struct hda_fixup *fix, int action)

1960

{

1960

{

1961

static hda_nid_t nids[1] = { 0x18 };

1961

static hda_nid_t nids[1] = { 0x18 };

1962

1963

if (action == HDA_FIXUP_ACT_INIT)

1963

if (action == HDA_FIXUP_ACT_INIT)

1964

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1964

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1965

}

1965

}

1966

1967

/* Set VREF on speaker pins on mba21 */

1967

/* Set VREF on speaker pins on mba21 */

1968

static void alc889_fixup_mba21_vref(struct hda_codec *codec,

1968

static void alc889_fixup_mba21_vref(struct hda_codec *codec,

1969

const struct hda_fixup *fix, int action)

1969

const struct hda_fixup *fix, int action)

1970

{

1970

{

1971

static hda_nid_t nids[2] = { 0x18, 0x19 };

1971

static hda_nid_t nids[2] = { 0x18, 0x19 };

1972

1973

if (action == HDA_FIXUP_ACT_INIT)

1973

if (action == HDA_FIXUP_ACT_INIT)

1974

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1974

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1975

}

1975

}

1976

1977

/* Don't take HP output as primary

1977

/* Don't take HP output as primary

1978

* Strangely, the speaker output doesn't work on Vaio Z and some Vaio

1978

* Strangely, the speaker output doesn't work on Vaio Z and some Vaio

1979

* all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05

1979

* all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05

1980

*/

1980

*/

1981

static void alc882_fixup_no_primary_hp(struct hda_codec *codec,

1981

static void alc882_fixup_no_primary_hp(struct hda_codec *codec,

1982

const struct hda_fixup *fix, int action)

1982

const struct hda_fixup *fix, int action)

1983

{

1983

{

1984

struct alc_spec *spec = codec->spec;

1984

struct alc_spec *spec = codec->spec;

1985

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1985

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1986

spec->gen.no_primary_hp = 1;

1986

spec->gen.no_primary_hp = 1;

1987

spec->gen.no_multi_io = 1;

1987

spec->gen.no_multi_io = 1;

1988

}

1988

}

1989

}

1989

}

1990

1991

static void alc_fixup_bass_chmap(struct hda_codec *codec,

1991

static void alc_fixup_bass_chmap(struct hda_codec *codec,

1992

const struct hda_fixup *fix, int action);

1992

const struct hda_fixup *fix, int action);

1993

1994

static const struct hda_fixup alc882_fixups[] = {

1994

static const struct hda_fixup alc882_fixups[] = {

1995

[ALC882_FIXUP_ABIT_AW9D_MAX] = {

1995

[ALC882_FIXUP_ABIT_AW9D_MAX] = {

1996

.type = HDA_FIXUP_PINS,

1996

.type = HDA_FIXUP_PINS,

1997

.v.pins = (const struct hda_pintbl[]) {

1997

.v.pins = (const struct hda_pintbl[]) {

1998

{ 0x15, 0x01080104 }, /* side */

1998

{ 0x15, 0x01080104 }, /* side */

1999

{ 0x16, 0x01011012 }, /* rear */

1999

{ 0x16, 0x01011012 }, /* rear */

2000

{ 0x17, 0x01016011 }, /* clfe */

2000

{ 0x17, 0x01016011 }, /* clfe */

2001

{ }

2001

{ }

2002

}

2002

}

2003

},

2003

},

2004

[ALC882_FIXUP_LENOVO_Y530] = {

2004

[ALC882_FIXUP_LENOVO_Y530] = {

2005

.type = HDA_FIXUP_PINS,

2005

.type = HDA_FIXUP_PINS,

2006

.v.pins = (const struct hda_pintbl[]) {

2006

.v.pins = (const struct hda_pintbl[]) {

2007

{ 0x15, 0x99130112 }, /* rear int speakers */

2007

{ 0x15, 0x99130112 }, /* rear int speakers */

2008

{ 0x16, 0x99130111 }, /* subwoofer */

2008

{ 0x16, 0x99130111 }, /* subwoofer */

2009

{ }

2009

{ }

2010

}

2010

}

2011

},

2011

},

2012

[ALC882_FIXUP_PB_M5210] = {

2012

[ALC882_FIXUP_PB_M5210] = {

2013

.type = HDA_FIXUP_PINCTLS,

2013

.type = HDA_FIXUP_PINCTLS,

2014

.v.pins = (const struct hda_pintbl[]) {

2014

.v.pins = (const struct hda_pintbl[]) {

2015

{ 0x19, PIN_VREF50 },

2015

{ 0x19, PIN_VREF50 },

2016

{}

2016

{}

2017

}

2017

}

2018

},

2018

},

2019

[ALC882_FIXUP_ACER_ASPIRE_7736] = {

2019

[ALC882_FIXUP_ACER_ASPIRE_7736] = {

2020

.type = HDA_FIXUP_FUNC,

2020

.type = HDA_FIXUP_FUNC,

2021

.v.func = alc_fixup_sku_ignore,

2021

.v.func = alc_fixup_sku_ignore,

2022

},

2022

},

2023

[ALC882_FIXUP_ASUS_W90V] = {

2023

[ALC882_FIXUP_ASUS_W90V] = {

2024

.type = HDA_FIXUP_PINS,

2024

.type = HDA_FIXUP_PINS,

2025

.v.pins = (const struct hda_pintbl[]) {

2025

.v.pins = (const struct hda_pintbl[]) {

2026

{ 0x16, 0x99130110 }, /* fix sequence for CLFE */

2026

{ 0x16, 0x99130110 }, /* fix sequence for CLFE */

2027

{ }

2027

{ }

2028

}

2028

}

2029

},

2029

},

2030

[ALC889_FIXUP_CD] = {

2030

[ALC889_FIXUP_CD] = {

2031

.type = HDA_FIXUP_PINS,

2031

.type = HDA_FIXUP_PINS,

2032

.v.pins = (const struct hda_pintbl[]) {

2032

.v.pins = (const struct hda_pintbl[]) {

2033

{ 0x1c, 0x993301f0 }, /* CD */

2033

{ 0x1c, 0x993301f0 }, /* CD */

2034

{ }

2034

{ }

2035

}

2035

}

2036

},

2036

},

2037

[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {

2037

[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {

2038

.type = HDA_FIXUP_PINS,

2038

.type = HDA_FIXUP_PINS,

2039

.v.pins = (const struct hda_pintbl[]) {

2039

.v.pins = (const struct hda_pintbl[]) {

2040

{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */

2040

{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */

2041

{ }

2041

{ }

2042

},

2042

},

2043

.chained = true,

2043

.chained = true,

2044

.chain_id = ALC889_FIXUP_CD,

2044

.chain_id = ALC889_FIXUP_CD,

2045

},

2045

},

2046

[ALC889_FIXUP_VAIO_TT] = {

2046

[ALC889_FIXUP_VAIO_TT] = {

2047

.type = HDA_FIXUP_PINS,

2047

.type = HDA_FIXUP_PINS,

2048

.v.pins = (const struct hda_pintbl[]) {

2048

.v.pins = (const struct hda_pintbl[]) {

2049

{ 0x17, 0x90170111 }, /* hidden surround speaker */

2049

{ 0x17, 0x90170111 }, /* hidden surround speaker */

2050

{ }

2050

{ }

2051

}

2051

}

2052

},

2052

},

2053

[ALC888_FIXUP_EEE1601] = {

2053

[ALC888_FIXUP_EEE1601] = {

2054

.type = HDA_FIXUP_VERBS,

2054

.type = HDA_FIXUP_VERBS,

2055

.v.verbs = (const struct hda_verb[]) {

2055

.v.verbs = (const struct hda_verb[]) {

2056

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2056

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2057

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },

2057

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },

2058

{ }

2058

{ }

2059

}

2059

}

2060

},

2060

},

2061

[ALC882_FIXUP_EAPD] = {

2061

[ALC882_FIXUP_EAPD] = {

2062

.type = HDA_FIXUP_VERBS,

2062

.type = HDA_FIXUP_VERBS,

2063

.v.verbs = (const struct hda_verb[]) {

2063

.v.verbs = (const struct hda_verb[]) {

2064

/* change to EAPD mode */

2064

/* change to EAPD mode */

2065

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2065

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2066

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

2066

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

2067

{ }

2067

{ }

2068

}

2068

}

2069

},

2069

},

2070

[ALC883_FIXUP_EAPD] = {

2070

[ALC883_FIXUP_EAPD] = {

2071

.type = HDA_FIXUP_VERBS,

2071

.type = HDA_FIXUP_VERBS,

2072

.v.verbs = (const struct hda_verb[]) {

2072

.v.verbs = (const struct hda_verb[]) {

2073

/* change to EAPD mode */

2073

/* change to EAPD mode */

2074

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2074

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2075

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2075

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2076

{ }

2076

{ }

2077

}

2077

}

2078

},

2078

},

2079

[ALC883_FIXUP_ACER_EAPD] = {

2079

[ALC883_FIXUP_ACER_EAPD] = {

2080

.type = HDA_FIXUP_VERBS,

2080

.type = HDA_FIXUP_VERBS,

2081

.v.verbs = (const struct hda_verb[]) {

2081

.v.verbs = (const struct hda_verb[]) {

2082

/* eanable EAPD on Acer laptops */

2082

/* eanable EAPD on Acer laptops */

2083

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2083

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2084

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2084

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2085

{ }

2085

{ }

2086

}

2086

}

2087

},

2087

},

2088

[ALC882_FIXUP_GPIO1] = {

2088

[ALC882_FIXUP_GPIO1] = {

2089

.type = HDA_FIXUP_VERBS,

2089

.type = HDA_FIXUP_VERBS,

2090

.v.verbs = alc_gpio1_init_verbs,

2090

.v.verbs = alc_gpio1_init_verbs,

2091

},

2091

},

2092

[ALC882_FIXUP_GPIO2] = {

2092

[ALC882_FIXUP_GPIO2] = {

2093

.type = HDA_FIXUP_VERBS,

2093

.type = HDA_FIXUP_VERBS,

2094

.v.verbs = alc_gpio2_init_verbs,

2094

.v.verbs = alc_gpio2_init_verbs,

2095

},

2095

},

2096

[ALC882_FIXUP_GPIO3] = {

2096

[ALC882_FIXUP_GPIO3] = {

2097

.type = HDA_FIXUP_VERBS,

2097

.type = HDA_FIXUP_VERBS,

2098

.v.verbs = alc_gpio3_init_verbs,

2098

.v.verbs = alc_gpio3_init_verbs,

2099

},

2099

},

2100

[ALC882_FIXUP_ASUS_W2JC] = {

2100

[ALC882_FIXUP_ASUS_W2JC] = {

2101

.type = HDA_FIXUP_VERBS,

2101

.type = HDA_FIXUP_VERBS,

2102

.v.verbs = alc_gpio1_init_verbs,

2102

.v.verbs = alc_gpio1_init_verbs,

2103

.chained = true,

2103

.chained = true,

2104

.chain_id = ALC882_FIXUP_EAPD,

2104

.chain_id = ALC882_FIXUP_EAPD,

2105

},

2105

},

2106

[ALC889_FIXUP_COEF] = {

2106

[ALC889_FIXUP_COEF] = {

2107

.type = HDA_FIXUP_FUNC,

2107

.type = HDA_FIXUP_FUNC,

2108

.v.func = alc889_fixup_coef,

2108

.v.func = alc889_fixup_coef,

2109

},

2109

},

2110

[ALC882_FIXUP_ACER_ASPIRE_4930G] = {

2110

[ALC882_FIXUP_ACER_ASPIRE_4930G] = {

2111

.type = HDA_FIXUP_PINS,

2111

.type = HDA_FIXUP_PINS,

2112

.v.pins = (const struct hda_pintbl[]) {

2112

.v.pins = (const struct hda_pintbl[]) {

2113

{ 0x16, 0x99130111 }, /* CLFE speaker */

2113

{ 0x16, 0x99130111 }, /* CLFE speaker */

2114

{ 0x17, 0x99130112 }, /* surround speaker */

2114

{ 0x17, 0x99130112 }, /* surround speaker */

2115

{ }

2115

{ }

2116

},

2116

},

2117

.chained = true,

2117

.chained = true,

2118

.chain_id = ALC882_FIXUP_GPIO1,

2118

.chain_id = ALC882_FIXUP_GPIO1,

2119

},

2119

},

2120

[ALC882_FIXUP_ACER_ASPIRE_8930G] = {

2120

[ALC882_FIXUP_ACER_ASPIRE_8930G] = {

2121

.type = HDA_FIXUP_PINS,

2121

.type = HDA_FIXUP_PINS,

2122

.v.pins = (const struct hda_pintbl[]) {

2122

.v.pins = (const struct hda_pintbl[]) {

2123

{ 0x16, 0x99130111 }, /* CLFE speaker */

2123

{ 0x16, 0x99130111 }, /* CLFE speaker */

2124

{ 0x1b, 0x99130112 }, /* surround speaker */

2124

{ 0x1b, 0x99130112 }, /* surround speaker */

2125

{ }

2125

{ }

2126

},

2126

},

2127

.chained = true,

2127

.chained = true,

2128

.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,

2128

.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,

2129

},

2129

},

2130

[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {

2130

[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {

2131

/* additional init verbs for Acer Aspire 8930G */

2131

/* additional init verbs for Acer Aspire 8930G */

2132

.type = HDA_FIXUP_VERBS,

2132

.type = HDA_FIXUP_VERBS,

2133

.v.verbs = (const struct hda_verb[]) {

2133

.v.verbs = (const struct hda_verb[]) {

2134

/* Enable all DACs */

2134

/* Enable all DACs */

2135

/* DAC DISABLE/MUTE 1? */

2135

/* DAC DISABLE/MUTE 1? */

2136

/* setting bits 1-5 disables DAC nids 0x02-0x06

2136

/* setting bits 1-5 disables DAC nids 0x02-0x06

2137

* apparently. Init=0x38 */

2137

* apparently. Init=0x38 */

2138

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },

2138

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },

2139

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2139

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2140

/* DAC DISABLE/MUTE 2? */

2140

/* DAC DISABLE/MUTE 2? */

2141

/* some bit here disables the other DACs.

2141

/* some bit here disables the other DACs.

2142

* Init=0x4900 */

2142

* Init=0x4900 */

2143

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },

2143

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },

2144

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2144

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2145

/* DMIC fix

2145

/* DMIC fix

2146

* This laptop has a stereo digital microphone.

2146

* This laptop has a stereo digital microphone.

2147

* The mics are only 1cm apart which makes the stereo

2147

* The mics are only 1cm apart which makes the stereo

2148

* useless. However, either the mic or the ALC889

2148

* useless. However, either the mic or the ALC889

2149

* makes the signal become a difference/sum signal

2149

* makes the signal become a difference/sum signal

2150

* instead of standard stereo, which is annoying.

2150

* instead of standard stereo, which is annoying.

2151

* So instead we flip this bit which makes the

2151

* So instead we flip this bit which makes the

2152

* codec replicate the sum signal to both channels,

2152

* codec replicate the sum signal to both channels,

2153

* turning it into a normal mono mic.

2153

* turning it into a normal mono mic.

2154

*/

2154

*/

2155

/* DMIC_CONTROL? Init value = 0x0001 */

2155

/* DMIC_CONTROL? Init value = 0x0001 */

2156

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2156

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2157

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },

2157

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },

2158

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2158

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2159

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2159

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2160

{ }

2160

{ }

2161

},

2161

},

2162

.chained = true,

2162

.chained = true,

2163

.chain_id = ALC882_FIXUP_GPIO1,

2163

.chain_id = ALC882_FIXUP_GPIO1,

2164

},

2164

},

2165

[ALC885_FIXUP_MACPRO_GPIO] = {

2165

[ALC885_FIXUP_MACPRO_GPIO] = {

2166

.type = HDA_FIXUP_FUNC,

2166

.type = HDA_FIXUP_FUNC,

2167

.v.func = alc885_fixup_macpro_gpio,

2167

.v.func = alc885_fixup_macpro_gpio,

2168

},

2168

},

2169

[ALC889_FIXUP_DAC_ROUTE] = {

2169

[ALC889_FIXUP_DAC_ROUTE] = {

2170

.type = HDA_FIXUP_FUNC,

2170

.type = HDA_FIXUP_FUNC,

2171

.v.func = alc889_fixup_dac_route,

2171

.v.func = alc889_fixup_dac_route,

2172

},

2172

},

2173

[ALC889_FIXUP_MBP_VREF] = {

2173

[ALC889_FIXUP_MBP_VREF] = {

2174

.type = HDA_FIXUP_FUNC,

2174

.type = HDA_FIXUP_FUNC,

2175

.v.func = alc889_fixup_mbp_vref,

2175

.v.func = alc889_fixup_mbp_vref,

2176

.chained = true,

2176

.chained = true,

2177

.chain_id = ALC882_FIXUP_GPIO1,

2177

.chain_id = ALC882_FIXUP_GPIO1,

2178

},

2178

},

2179

[ALC889_FIXUP_IMAC91_VREF] = {

2179

[ALC889_FIXUP_IMAC91_VREF] = {

2180

.type = HDA_FIXUP_FUNC,

2180

.type = HDA_FIXUP_FUNC,

2181

.v.func = alc889_fixup_imac91_vref,

2181

.v.func = alc889_fixup_imac91_vref,

2182

.chained = true,

2182

.chained = true,

2183

.chain_id = ALC882_FIXUP_GPIO1,

2183

.chain_id = ALC882_FIXUP_GPIO1,

2184

},

2184

},

2185

[ALC889_FIXUP_MBA11_VREF] = {

2185

[ALC889_FIXUP_MBA11_VREF] = {

2186

.type = HDA_FIXUP_FUNC,

2186

.type = HDA_FIXUP_FUNC,

2187

.v.func = alc889_fixup_mba11_vref,

2187

.v.func = alc889_fixup_mba11_vref,

2188

.chained = true,

2188

.chained = true,

2189

.chain_id = ALC889_FIXUP_MBP_VREF,

2189

.chain_id = ALC889_FIXUP_MBP_VREF,

2190

},

2190

},

2191

[ALC889_FIXUP_MBA21_VREF] = {

2191

[ALC889_FIXUP_MBA21_VREF] = {

2192

.type = HDA_FIXUP_FUNC,

2192

.type = HDA_FIXUP_FUNC,

2193

.v.func = alc889_fixup_mba21_vref,

2193

.v.func = alc889_fixup_mba21_vref,

2194

.chained = true,

2194

.chained = true,

2195

.chain_id = ALC889_FIXUP_MBP_VREF,

2195

.chain_id = ALC889_FIXUP_MBP_VREF,

2196

},

2196

},

2197

[ALC889_FIXUP_MP11_VREF] = {

2197

[ALC889_FIXUP_MP11_VREF] = {

2198

.type = HDA_FIXUP_FUNC,

2198

.type = HDA_FIXUP_FUNC,

2199

.v.func = alc889_fixup_mba11_vref,

2199

.v.func = alc889_fixup_mba11_vref,

2200

.chained = true,

2200

.chained = true,

2201

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2201

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2202

},

2202

},

2203

[ALC882_FIXUP_INV_DMIC] = {

2203

[ALC882_FIXUP_INV_DMIC] = {

2204

.type = HDA_FIXUP_FUNC,

2204

.type = HDA_FIXUP_FUNC,

2205

.v.func = alc_fixup_inv_dmic_0x12,

2205

.v.func = alc_fixup_inv_dmic_0x12,

2206

},

2206

},

2207

[ALC882_FIXUP_NO_PRIMARY_HP] = {

2207

[ALC882_FIXUP_NO_PRIMARY_HP] = {

2208

.type = HDA_FIXUP_FUNC,

2208

.type = HDA_FIXUP_FUNC,

2209

.v.func = alc882_fixup_no_primary_hp,

2209

.v.func = alc882_fixup_no_primary_hp,

2210

},

2210

},

2211

[ALC887_FIXUP_ASUS_BASS] = {

2211

[ALC887_FIXUP_ASUS_BASS] = {

2212

.type = HDA_FIXUP_PINS,

2212

.type = HDA_FIXUP_PINS,

2213

.v.pins = (const struct hda_pintbl[]) {

2213

.v.pins = (const struct hda_pintbl[]) {

2214

{0x16, 0x99130130}, /* bass speaker */

2214

{0x16, 0x99130130}, /* bass speaker */

2215

{}

2215

{}

2216

},

2216

},

2217

.chained = true,

2217

.chained = true,

2218

.chain_id = ALC887_FIXUP_BASS_CHMAP,

2218

.chain_id = ALC887_FIXUP_BASS_CHMAP,

2219

},

2219

},

2220

[ALC887_FIXUP_BASS_CHMAP] = {

2220

[ALC887_FIXUP_BASS_CHMAP] = {

2221

.type = HDA_FIXUP_FUNC,

2221

.type = HDA_FIXUP_FUNC,

2222

.v.func = alc_fixup_bass_chmap,

2222

.v.func = alc_fixup_bass_chmap,

2223

},

2223

},

2224

};

2224

};

2225

2226

static const struct snd_pci_quirk alc882_fixup_tbl[] = {

2226

static const struct snd_pci_quirk alc882_fixup_tbl[] = {

2227

SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),

2227

SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),

2228

SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2228

SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2229

SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),

2229

SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),

2230

SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2230

SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2231

SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),

2231

SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),

2232

SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),

2232

SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),

2233

SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",

2233

SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",

2234

ALC882_FIXUP_ACER_ASPIRE_4930G),

2234

ALC882_FIXUP_ACER_ASPIRE_4930G),

2235

SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",

2235

SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",

2236

ALC882_FIXUP_ACER_ASPIRE_4930G),

2236

ALC882_FIXUP_ACER_ASPIRE_4930G),

2237

SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",

2237

SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",

2238

ALC882_FIXUP_ACER_ASPIRE_8930G),

2238

ALC882_FIXUP_ACER_ASPIRE_8930G),

2239

SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",

2239

SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",

2240

ALC882_FIXUP_ACER_ASPIRE_8930G),

2240

ALC882_FIXUP_ACER_ASPIRE_8930G),

2241

SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",

2241

SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",

2242

ALC882_FIXUP_ACER_ASPIRE_4930G),

2242

ALC882_FIXUP_ACER_ASPIRE_4930G),

2243

SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",

2243

SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",

2244

ALC882_FIXUP_ACER_ASPIRE_4930G),

2244

ALC882_FIXUP_ACER_ASPIRE_4930G),

2245

SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",

2245

SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",

2246

ALC882_FIXUP_ACER_ASPIRE_4930G),

2246

ALC882_FIXUP_ACER_ASPIRE_4930G),

2247

SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),

2247

SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),

2248

SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",

2248

SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",

2249

ALC882_FIXUP_ACER_ASPIRE_4930G),

2249

ALC882_FIXUP_ACER_ASPIRE_4930G),

2250

SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),

2250

SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),

2251

SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),

2251

SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),

2252

SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),

2252

SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),

2253

SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),

2253

SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),

2254

SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),

2254

SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),

2255

SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),

2255

SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),

2256

SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),

2256

SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),

2257

SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),

2257

SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),

2258

SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),

2258

SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),

2259

SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),

2259

SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),

2260

SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),

2260

SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),

2261

2262

/* All Apple entries are in codec SSIDs */

2262

/* All Apple entries are in codec SSIDs */

2263

SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),

2263

SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),

2264

SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),

2264

SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),

2265

SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2265

SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2266

SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),

2266

SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),

2267

SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),

2267

SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),

2268

SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),

2268

SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),

2269

SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),

2269

SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),

2270

SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),

2270

SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),

2271

SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),

2271

SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),

2272

SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),

2272

SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),

2273

SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),

2273

SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),

2274

SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),

2274

SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),

2275

SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2275

SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2276

SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),

2276

SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),

2277

SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),

2277

SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),

2278

SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),

2278

SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),

2279

SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),

2279

SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),

2280

SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),

2280

SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),

2281

SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),

2281

SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),

2282

SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),

2282

SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),

2283

SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),

2283

SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),

2284

SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),

2284

SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),

2285

2286

SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),

2286

SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),

2287

SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),

2287

SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),

2288

SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),

2288

SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),

2289

SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),

2289

SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),

2290

SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),

2290

SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),

2291

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),

2291

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),

2292

SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),

2292

SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),

2293

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),

2293

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),

2294

SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),

2294

SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),

2295

{}

2295

{}

2296

};

2296

};

2297

2298

static const struct hda_model_fixup alc882_fixup_models[] = {

2298

static const struct hda_model_fixup alc882_fixup_models[] = {

2299

{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},

2299

{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},

2300

{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},

2300

{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},

2301

{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},

2301

{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},

2302

{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},

2302

{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},

2303

{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},

2303

{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},

2304

{}

2304

{}

2305

};

2305

};

2306

2307

/*

2307

/*

2308

* BIOS auto configuration

2308

* BIOS auto configuration

2309

*/

2309

*/

2310

/* almost identical with ALC880 parser... */

2310

/* almost identical with ALC880 parser... */

2311

static int alc882_parse_auto_config(struct hda_codec *codec)

2311

static int alc882_parse_auto_config(struct hda_codec *codec)

2312

{

2312

{

2313

static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };

2313

static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };

2314

static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2314

static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2315

return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);

2315

return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);

2316

}

2316

}

2317

2318

/*

2318

/*

2319

*/

2319

*/

2320

static int patch_alc882(struct hda_codec *codec)

2320

static int patch_alc882(struct hda_codec *codec)

2321

{

2321

{

2322

struct alc_spec *spec;

2322

struct alc_spec *spec;

2323

int err;

2323

int err;

2324

2325

err = alc_alloc_spec(codec, 0x0b);

2325

err = alc_alloc_spec(codec, 0x0b);

2326

if (err < 0)

2326

if (err < 0)

2327

return err;

2327

return err;

2328

2329

spec = codec->spec;

2329

spec = codec->spec;

2330

2331

switch (codec->vendor_id) {

2331

switch (codec->vendor_id) {

2332

case 0x10ec0882:

2332

case 0x10ec0882:

2333

case 0x10ec0885:

2333

case 0x10ec0885:

2334

break;

2334

break;

2335

default:

2335

default:

2336

/* ALC883 and variants */

2336

/* ALC883 and variants */

2337

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2337

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2338

break;

2338

break;

2339

}

2339

}

2340

2341

snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,

2341

snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,

2342

alc882_fixups);

2342

alc882_fixups);

2343

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2343

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2344

2345

alc_auto_parse_customize_define(codec);

2345

alc_auto_parse_customize_define(codec);

2346

2347

if (has_cdefine_beep(codec))

2347

if (has_cdefine_beep(codec))

2348

spec->gen.beep_nid = 0x01;

2348

spec->gen.beep_nid = 0x01;

2349

2350

/* automatic parse from the BIOS config */

2350

/* automatic parse from the BIOS config */

2351

err = alc882_parse_auto_config(codec);

2351

err = alc882_parse_auto_config(codec);

2352

if (err < 0)

2352

if (err < 0)

2353

goto error;

2353

goto error;

2354

2355

if (!spec->gen.no_analog && spec->gen.beep_nid)

2355

if (!spec->gen.no_analog && spec->gen.beep_nid)

2356

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

2356

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

2357

2358

codec->patch_ops = alc_patch_ops;

2358

codec->patch_ops = alc_patch_ops;

2359

2360

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2360

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2361

2362

return 0;

2362

return 0;

2363

2364

error:

2364

error:

2365

alc_free(codec);

2365

alc_free(codec);

2366

return err;

2366

return err;

2367

}

2367

}

2368

2369

2370

/*

2370

/*

2371

* ALC262 support

2371

* ALC262 support

2372

*/

2372

*/

2373

static int alc262_parse_auto_config(struct hda_codec *codec)

2373

static int alc262_parse_auto_config(struct hda_codec *codec)

2374

{

2374

{

2375

static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };

2375

static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };

2376

static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2376

static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2377

return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);

2377

return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);

2378

}

2378

}

2379

2380

/*

2380

/*

2381

* Pin config fixes

2381

* Pin config fixes

2382

*/

2382

*/

2383

enum {

2383

enum {

2384

ALC262_FIXUP_FSC_H270,

2384

ALC262_FIXUP_FSC_H270,

2385

ALC262_FIXUP_FSC_S7110,

2385

ALC262_FIXUP_FSC_S7110,

2386

ALC262_FIXUP_HP_Z200,

2386

ALC262_FIXUP_HP_Z200,

2387

ALC262_FIXUP_TYAN,

2387

ALC262_FIXUP_TYAN,

2388

ALC262_FIXUP_LENOVO_3000,

2388

ALC262_FIXUP_LENOVO_3000,

2389

ALC262_FIXUP_BENQ,

2389

ALC262_FIXUP_BENQ,

2390

ALC262_FIXUP_BENQ_T31,

2390

ALC262_FIXUP_BENQ_T31,

2391

ALC262_FIXUP_INV_DMIC,

2391

ALC262_FIXUP_INV_DMIC,

2392

ALC262_FIXUP_INTEL_BAYLEYBAY,

2392

ALC262_FIXUP_INTEL_BAYLEYBAY,

2393

};

2393

};

2394

2395

static const struct hda_fixup alc262_fixups[] = {

2395

static const struct hda_fixup alc262_fixups[] = {

2396

[ALC262_FIXUP_FSC_H270] = {

2396

[ALC262_FIXUP_FSC_H270] = {

2397

.type = HDA_FIXUP_PINS,

2397

.type = HDA_FIXUP_PINS,

2398

.v.pins = (const struct hda_pintbl[]) {

2398

.v.pins = (const struct hda_pintbl[]) {

2399

{ 0x14, 0x99130110 }, /* speaker */

2399

{ 0x14, 0x99130110 }, /* speaker */

2400

{ 0x15, 0x0221142f }, /* front HP */

2400

{ 0x15, 0x0221142f }, /* front HP */

2401

{ 0x1b, 0x0121141f }, /* rear HP */

2401

{ 0x1b, 0x0121141f }, /* rear HP */

2402

{ }

2402

{ }

2403

}

2403

}

2404

},

2404

},

2405

[ALC262_FIXUP_FSC_S7110] = {

2405

[ALC262_FIXUP_FSC_S7110] = {

2406

.type = HDA_FIXUP_PINS,

2406

.type = HDA_FIXUP_PINS,

2407

.v.pins = (const struct hda_pintbl[]) {

2407

.v.pins = (const struct hda_pintbl[]) {

2408

{ 0x15, 0x90170110 }, /* speaker */

2408

{ 0x15, 0x90170110 }, /* speaker */

2409

{ }

2409

{ }

2410

},

2410

},

2411

.chained = true,

2411

.chained = true,

2412

.chain_id = ALC262_FIXUP_BENQ,

2412

.chain_id = ALC262_FIXUP_BENQ,

2413

},

2413

},

2414

[ALC262_FIXUP_HP_Z200] = {

2414

[ALC262_FIXUP_HP_Z200] = {

2415

.type = HDA_FIXUP_PINS,

2415

.type = HDA_FIXUP_PINS,

2416

.v.pins = (const struct hda_pintbl[]) {

2416

.v.pins = (const struct hda_pintbl[]) {

2417

{ 0x16, 0x99130120 }, /* internal speaker */

2417

{ 0x16, 0x99130120 }, /* internal speaker */

2418

{ }

2418

{ }

2419

}

2419

}

2420

},

2420

},

2421

[ALC262_FIXUP_TYAN] = {

2421

[ALC262_FIXUP_TYAN] = {

2422

.type = HDA_FIXUP_PINS,

2422

.type = HDA_FIXUP_PINS,

2423

.v.pins = (const struct hda_pintbl[]) {

2423

.v.pins = (const struct hda_pintbl[]) {

2424

{ 0x14, 0x1993e1f0 }, /* int AUX */

2424

{ 0x14, 0x1993e1f0 }, /* int AUX */

2425

{ }

2425

{ }

2426

}

2426

}

2427

},

2427

},

2428

[ALC262_FIXUP_LENOVO_3000] = {

2428

[ALC262_FIXUP_LENOVO_3000] = {

2429

.type = HDA_FIXUP_PINCTLS,

2429

.type = HDA_FIXUP_PINCTLS,

2430

.v.pins = (const struct hda_pintbl[]) {

2430

.v.pins = (const struct hda_pintbl[]) {

2431

{ 0x19, PIN_VREF50 },

2431

{ 0x19, PIN_VREF50 },

2432

{}

2432

{}

2433

},

2433

},

2434

.chained = true,

2434

.chained = true,

2435

.chain_id = ALC262_FIXUP_BENQ,

2435

.chain_id = ALC262_FIXUP_BENQ,

2436

},

2436

},

2437

[ALC262_FIXUP_BENQ] = {

2437

[ALC262_FIXUP_BENQ] = {

2438

.type = HDA_FIXUP_VERBS,

2438

.type = HDA_FIXUP_VERBS,

2439

.v.verbs = (const struct hda_verb[]) {

2439

.v.verbs = (const struct hda_verb[]) {

2440

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2440

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2441

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2441

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2442

{}

2442

{}

2443

}

2443

}

2444

},

2444

},

2445

[ALC262_FIXUP_BENQ_T31] = {

2445

[ALC262_FIXUP_BENQ_T31] = {

2446

.type = HDA_FIXUP_VERBS,

2446

.type = HDA_FIXUP_VERBS,

2447

.v.verbs = (const struct hda_verb[]) {

2447

.v.verbs = (const struct hda_verb[]) {

2448

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2448

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2449

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2449

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2450

{}

2450

{}

2451

}

2451

}

2452

},

2452

},

2453

[ALC262_FIXUP_INV_DMIC] = {

2453

[ALC262_FIXUP_INV_DMIC] = {

2454

.type = HDA_FIXUP_FUNC,

2454

.type = HDA_FIXUP_FUNC,

2455

.v.func = alc_fixup_inv_dmic_0x12,

2455

.v.func = alc_fixup_inv_dmic_0x12,

2456

},

2456

},

2457

[ALC262_FIXUP_INTEL_BAYLEYBAY] = {

2457

[ALC262_FIXUP_INTEL_BAYLEYBAY] = {

2458

.type = HDA_FIXUP_FUNC,

2458

.type = HDA_FIXUP_FUNC,

2459

.v.func = alc_fixup_no_depop_delay,

2459

.v.func = alc_fixup_no_depop_delay,

2460

},

2460

},

2461

};

2461

};

2462

2463

static const struct snd_pci_quirk alc262_fixup_tbl[] = {

2463

static const struct snd_pci_quirk alc262_fixup_tbl[] = {

2464

SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),

2464

SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),

2465

SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),

2465

SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),

2466

SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),

2466

SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),

2467

SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),

2467

SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),

2468

SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),

2468

SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),

2469

SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),

2469

SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),

2470

SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),

2470

SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),

2471

SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),

2471

SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),

2472

SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),

2472

SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),

2473

{}

2473

{}

2474

};

2474

};

2475

2476

static const struct hda_model_fixup alc262_fixup_models[] = {

2476

static const struct hda_model_fixup alc262_fixup_models[] = {

2477

{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},

2477

{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},

2478

{}

2478

{}

2479

};

2479

};

2480

2481

/*

2481

/*

2482

*/

2482

*/

2483

static int patch_alc262(struct hda_codec *codec)

2483

static int patch_alc262(struct hda_codec *codec)

2484

{

2484

{

2485

struct alc_spec *spec;

2485

struct alc_spec *spec;

2486

int err;

2486

int err;

2487

2488

err = alc_alloc_spec(codec, 0x0b);

2488

err = alc_alloc_spec(codec, 0x0b);

2489

if (err < 0)

2489

if (err < 0)

2490

return err;

2490

return err;

2491

2492

spec = codec->spec;

2492

spec = codec->spec;

2493

spec->gen.shared_mic_vref_pin = 0x18;

2493

spec->gen.shared_mic_vref_pin = 0x18;

2494

2495

#if 0

2495

#if 0

2496

/* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is

2496

/* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is

2497

* under-run

2497

* under-run

2498

*/

2498

*/

2499

{

2499

{

2500

int tmp;

2500

int tmp;

2501

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);

2501

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);

2502

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

2502

tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);

2503

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);

2503

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);

2504

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);

2504

snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);

2505

}

2505

}

2506

#endif

2506

#endif

2507

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2507

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2508

2509

snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,

2509

snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,

2510

alc262_fixups);

2510

alc262_fixups);

2511

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2511

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2512

2513

alc_auto_parse_customize_define(codec);

2513

alc_auto_parse_customize_define(codec);

2514

2515

if (has_cdefine_beep(codec))

2515

if (has_cdefine_beep(codec))

2516

spec->gen.beep_nid = 0x01;

2516

spec->gen.beep_nid = 0x01;

2517

2518

/* automatic parse from the BIOS config */

2518

/* automatic parse from the BIOS config */

2519

err = alc262_parse_auto_config(codec);

2519

err = alc262_parse_auto_config(codec);

2520

if (err < 0)

2520

if (err < 0)

2521

goto error;

2521

goto error;

2522

2523

if (!spec->gen.no_analog && spec->gen.beep_nid)

2523

if (!spec->gen.no_analog && spec->gen.beep_nid)

2524

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

2524

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

2525

2526

codec->patch_ops = alc_patch_ops;

2526

codec->patch_ops = alc_patch_ops;

2527

spec->shutup = alc_eapd_shutup;

2527

spec->shutup = alc_eapd_shutup;

2528

2529

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2529

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2530

2531

return 0;

2531

return 0;

2532

2533

error:

2533

error:

2534

alc_free(codec);

2534

alc_free(codec);

2535

return err;

2535

return err;

2536

}

2536

}

2537

2538

/*

2538

/*

2539

* ALC268

2539

* ALC268

2540

*/

2540

*/

2541

/* bind Beep switches of both NID 0x0f and 0x10 */

2541

/* bind Beep switches of both NID 0x0f and 0x10 */

2542

static const struct hda_bind_ctls alc268_bind_beep_sw = {

2542

static const struct hda_bind_ctls alc268_bind_beep_sw = {

2543

.ops = &snd_hda_bind_sw,

2543

.ops = &snd_hda_bind_sw,

2544

.values = {

2544

.values = {

2545

HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),

2545

HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),

2546

HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),

2546

HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),

2547

0

2547

0

2548

},

2548

},

2549

};

2549

};

2550

2551

static const struct snd_kcontrol_new alc268_beep_mixer[] = {

2551

static const struct snd_kcontrol_new alc268_beep_mixer[] = {

2552

HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),

2552

HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),

2553

HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),

2553

HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),

2554

{ }

2554

{ }

2555

};

2555

};

2556

2557

/* set PCBEEP vol = 0, mute connections */

2557

/* set PCBEEP vol = 0, mute connections */

2558

static const struct hda_verb alc268_beep_init_verbs[] = {

2558

static const struct hda_verb alc268_beep_init_verbs[] = {

2559

{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},

2559

{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},

2560

{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2560

{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2561

{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2561

{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2562

{ }

2562

{ }

2563

};

2563

};

2564

2565

enum {

2565

enum {

2566

ALC268_FIXUP_INV_DMIC,

2566

ALC268_FIXUP_INV_DMIC,

2567

ALC268_FIXUP_HP_EAPD,

2567

ALC268_FIXUP_HP_EAPD,

2568

ALC268_FIXUP_SPDIF,

2568

ALC268_FIXUP_SPDIF,

2569

};

2569

};

2570

2571

static const struct hda_fixup alc268_fixups[] = {

2571

static const struct hda_fixup alc268_fixups[] = {

2572

[ALC268_FIXUP_INV_DMIC] = {

2572

[ALC268_FIXUP_INV_DMIC] = {

2573

.type = HDA_FIXUP_FUNC,

2573

.type = HDA_FIXUP_FUNC,

2574

.v.func = alc_fixup_inv_dmic_0x12,

2574

.v.func = alc_fixup_inv_dmic_0x12,

2575

},

2575

},

2576

[ALC268_FIXUP_HP_EAPD] = {

2576

[ALC268_FIXUP_HP_EAPD] = {

2577

.type = HDA_FIXUP_VERBS,

2577

.type = HDA_FIXUP_VERBS,

2578

.v.verbs = (const struct hda_verb[]) {

2578

.v.verbs = (const struct hda_verb[]) {

2579

{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},

2579

{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},

2580

{}

2580

{}

2581

}

2581

}

2582

},

2582

},

2583

[ALC268_FIXUP_SPDIF] = {

2583

[ALC268_FIXUP_SPDIF] = {

2584

.type = HDA_FIXUP_PINS,

2584

.type = HDA_FIXUP_PINS,

2585

.v.pins = (const struct hda_pintbl[]) {

2585

.v.pins = (const struct hda_pintbl[]) {

2586

{ 0x1e, 0x014b1180 }, /* enable SPDIF out */

2586

{ 0x1e, 0x014b1180 }, /* enable SPDIF out */

2587

{}

2587

{}

2588

}

2588

}

2589

},

2589

},

2590

};

2590

};

2591

2592

static const struct hda_model_fixup alc268_fixup_models[] = {

2592

static const struct hda_model_fixup alc268_fixup_models[] = {

2593

{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},

2593

{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},

2594

{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},

2594

{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},

2595

{}

2595

{}

2596

};

2596

};

2597

2598

static const struct snd_pci_quirk alc268_fixup_tbl[] = {

2598

static const struct snd_pci_quirk alc268_fixup_tbl[] = {

2599

SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),

2599

SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),

2600

SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),

2600

SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),

2601

/* below is codec SSID since multiple Toshiba laptops have the

2601

/* below is codec SSID since multiple Toshiba laptops have the

2602

* same PCI SSID 1179:ff00

2602

* same PCI SSID 1179:ff00

2603

*/

2603

*/

2604

SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),

2604

SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),

2605

{}

2605

{}

2606

};

2606

};

2607

2608

/*

2608

/*

2609

* BIOS auto configuration

2609

* BIOS auto configuration

2610

*/

2610

*/

2611

static int alc268_parse_auto_config(struct hda_codec *codec)

2611

static int alc268_parse_auto_config(struct hda_codec *codec)

2612

{

2612

{

2613

static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2613

static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2614

return alc_parse_auto_config(codec, NULL, alc268_ssids);

2614

return alc_parse_auto_config(codec, NULL, alc268_ssids);

2615

}

2615

}

2616

2617

/*

2617

/*

2618

*/

2618

*/

2619

static int patch_alc268(struct hda_codec *codec)

2619

static int patch_alc268(struct hda_codec *codec)

2620

{

2620

{

2621

struct alc_spec *spec;

2621

struct alc_spec *spec;

2622

int err;

2622

int err;

2623

2624

/* ALC268 has no aa-loopback mixer */

2624

/* ALC268 has no aa-loopback mixer */

2625

err = alc_alloc_spec(codec, 0);

2625

err = alc_alloc_spec(codec, 0);

2626

if (err < 0)

2626

if (err < 0)

2627

return err;

2627

return err;

2628

2629

spec = codec->spec;

2629

spec = codec->spec;

2630

spec->gen.beep_nid = 0x01;

2630

spec->gen.beep_nid = 0x01;

2631

2632

snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);

2632

snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);

2633

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2633

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2634

2635

/* automatic parse from the BIOS config */

2635

/* automatic parse from the BIOS config */

2636

err = alc268_parse_auto_config(codec);

2636

err = alc268_parse_auto_config(codec);

2637

if (err < 0)

2637

if (err < 0)

2638

goto error;

2638

goto error;

2639

2640

if (err > 0 && !spec->gen.no_analog &&

2640

if (err > 0 && !spec->gen.no_analog &&

2641

spec->gen.autocfg.speaker_pins[0] != 0x1d) {

2641

spec->gen.autocfg.speaker_pins[0] != 0x1d) {

2642

add_mixer(spec, alc268_beep_mixer);

2642

add_mixer(spec, alc268_beep_mixer);

2643

snd_hda_add_verbs(codec, alc268_beep_init_verbs);

2643

snd_hda_add_verbs(codec, alc268_beep_init_verbs);

2644

if (!query_amp_caps(codec, 0x1d, HDA_INPUT))

2644

if (!query_amp_caps(codec, 0x1d, HDA_INPUT))

2645

/* override the amp caps for beep generator */

2645

/* override the amp caps for beep generator */

2646

snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,

2646

snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,

2647

(0x0c << AC_AMPCAP_OFFSET_SHIFT) |

2647

(0x0c << AC_AMPCAP_OFFSET_SHIFT) |

2648

(0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |

2648

(0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |

2649

(0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |

2649

(0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |

2650

(0 << AC_AMPCAP_MUTE_SHIFT));

2650

(0 << AC_AMPCAP_MUTE_SHIFT));

2651

}

2651

}

2652

2653

codec->patch_ops = alc_patch_ops;

2653

codec->patch_ops = alc_patch_ops;

2654

spec->shutup = alc_eapd_shutup;

2654

spec->shutup = alc_eapd_shutup;

2655

2656

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2656

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2657

2658

return 0;

2658

return 0;

2659

2660

error:

2660

error:

2661

alc_free(codec);

2661

alc_free(codec);

2662

return err;

2662

return err;

2663

}

2663

}

2664

2665

/*

2665

/*

2666

* ALC269

2666

* ALC269

2667

*/

2667

*/

2668

2669

static int playback_pcm_open(struct hda_pcm_stream *hinfo,

2669

static int playback_pcm_open(struct hda_pcm_stream *hinfo,

2670

struct hda_codec *codec,

2670

struct hda_codec *codec,

2671

struct snd_pcm_substream *substream)

2671

struct snd_pcm_substream *substream)

2672

{

2672

{

2673

struct hda_gen_spec *spec = codec->spec;

2673

struct hda_gen_spec *spec = codec->spec;

2674

return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,

2674

return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,

2675

hinfo);

2675

hinfo);

2676

}

2676

}

2677

2678

static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,

2678

static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,

2679

struct hda_codec *codec,

2679

struct hda_codec *codec,

2680

unsigned int stream_tag,

2680

unsigned int stream_tag,

2681

unsigned int format,

2681

unsigned int format,

2682

struct snd_pcm_substream *substream)

2682

struct snd_pcm_substream *substream)

2683

{

2683

{

2684

struct hda_gen_spec *spec = codec->spec;

2684

struct hda_gen_spec *spec = codec->spec;

2685

return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,

2685

return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,

2686

stream_tag, format, substream);

2686

stream_tag, format, substream);

2687

}

2687

}

2688

2689

static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,

2689

static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,

2690

struct hda_codec *codec,

2690

struct hda_codec *codec,

2691

struct snd_pcm_substream *substream)

2691

struct snd_pcm_substream *substream)

2692

{

2692

{

2693

struct hda_gen_spec *spec = codec->spec;

2693

struct hda_gen_spec *spec = codec->spec;

2694

return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);

2694

return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);

2695

}

2695

}

2696

2697

static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {

2697

static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {

2698

.substreams = 1,

2698

.substreams = 1,

2699

.channels_min = 2,

2699

.channels_min = 2,

2700

.channels_max = 8,

2700

.channels_max = 8,

2701

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2701

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2702

/* NID is set in alc_build_pcms */

2702

/* NID is set in alc_build_pcms */

2703

.ops = {

2703

.ops = {

2704

.open = playback_pcm_open,

2704

.open = playback_pcm_open,

2705

.prepare = playback_pcm_prepare,

2705

.prepare = playback_pcm_prepare,

2706

.cleanup = playback_pcm_cleanup

2706

.cleanup = playback_pcm_cleanup

2707

},

2707

},

2708

};

2708

};

2709

2710

static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {

2710

static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {

2711

.substreams = 1,

2711

.substreams = 1,

2712

.channels_min = 2,

2712

.channels_min = 2,

2713

.channels_max = 2,

2713

.channels_max = 2,

2714

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2714

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2715

/* NID is set in alc_build_pcms */

2715

/* NID is set in alc_build_pcms */

2716

};

2716

};

2717

2718

/* different alc269-variants */

2718

/* different alc269-variants */

2719

enum {

2719

enum {

2720

ALC269_TYPE_ALC269VA,

2720

ALC269_TYPE_ALC269VA,

2721

ALC269_TYPE_ALC269VB,

2721

ALC269_TYPE_ALC269VB,

2722

ALC269_TYPE_ALC269VC,

2722

ALC269_TYPE_ALC269VC,

2723

ALC269_TYPE_ALC269VD,

2723

ALC269_TYPE_ALC269VD,

2724

ALC269_TYPE_ALC280,

2724

ALC269_TYPE_ALC280,

2725

ALC269_TYPE_ALC282,

2725

ALC269_TYPE_ALC282,

2726

ALC269_TYPE_ALC283,

2726

ALC269_TYPE_ALC283,

2727

ALC269_TYPE_ALC284,

2727

ALC269_TYPE_ALC284,

2728

ALC269_TYPE_ALC285,

2728

ALC269_TYPE_ALC285,

2729

ALC269_TYPE_ALC286,

2729

ALC269_TYPE_ALC286,

2730

ALC269_TYPE_ALC255,

2730

ALC269_TYPE_ALC255,

2731

};

2731

};

2732

2733

/*

2733

/*

2734

* BIOS auto configuration

2734

* BIOS auto configuration

2735

*/

2735

*/

2736

static int alc269_parse_auto_config(struct hda_codec *codec)

2736

static int alc269_parse_auto_config(struct hda_codec *codec)

2737

{

2737

{

2738

static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };

2738

static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };

2739

static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };

2739

static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };

2740

static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2740

static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };

2741

struct alc_spec *spec = codec->spec;

2741

struct alc_spec *spec = codec->spec;

2742

const hda_nid_t *ssids;

2742

const hda_nid_t *ssids;

2743

2744

switch (spec->codec_variant) {

2744

switch (spec->codec_variant) {

2745

case ALC269_TYPE_ALC269VA:

2745

case ALC269_TYPE_ALC269VA:

2746

case ALC269_TYPE_ALC269VC:

2746

case ALC269_TYPE_ALC269VC:

2747

case ALC269_TYPE_ALC280:

2747

case ALC269_TYPE_ALC280:

2748

case ALC269_TYPE_ALC284:

2748

case ALC269_TYPE_ALC284:

2749

case ALC269_TYPE_ALC285:

2749

case ALC269_TYPE_ALC285:

2750

ssids = alc269va_ssids;

2750

ssids = alc269va_ssids;

2751

break;

2751

break;

2752

case ALC269_TYPE_ALC269VB:

2752

case ALC269_TYPE_ALC269VB:

2753

case ALC269_TYPE_ALC269VD:

2753

case ALC269_TYPE_ALC269VD:

2754

case ALC269_TYPE_ALC282:

2754

case ALC269_TYPE_ALC282:

2755

case ALC269_TYPE_ALC283:

2755

case ALC269_TYPE_ALC283:

2756

case ALC269_TYPE_ALC286:

2756

case ALC269_TYPE_ALC286:

2757

case ALC269_TYPE_ALC255:

2757

case ALC269_TYPE_ALC255:

2758

ssids = alc269_ssids;

2758

ssids = alc269_ssids;

2759

break;

2759

break;

2760

default:

2760

default:

2761

ssids = alc269_ssids;

2761

ssids = alc269_ssids;

2762

break;

2762

break;

2763

}

2763

}

2764

2765

return alc_parse_auto_config(codec, alc269_ignore, ssids);

2765

return alc_parse_auto_config(codec, alc269_ignore, ssids);

2766

}

2766

}

2767

2768

static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)

2768

static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)

2769

{

2769

{

2770

int val = alc_read_coef_idx(codec, 0x04);

2770

int val = alc_read_coef_idx(codec, 0x04);

2771

if (power_up)

2771

if (power_up)

2772

val |= 1 << 11;

2772

val |= 1 << 11;

2773

else

2773

else

2774

val &= ~(1 << 11);

2774

val &= ~(1 << 11);

2775

alc_write_coef_idx(codec, 0x04, val);

2775

alc_write_coef_idx(codec, 0x04, val);

2776

}

2776

}

2777

2778

static void alc269_shutup(struct hda_codec *codec)

2778

static void alc269_shutup(struct hda_codec *codec)

2779

{

2779

{

2780

struct alc_spec *spec = codec->spec;

2780

struct alc_spec *spec = codec->spec;

2781

2782

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

2782

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

2783

alc269vb_toggle_power_output(codec, 0);

2783

alc269vb_toggle_power_output(codec, 0);

2784

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

2784

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

2785

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

2785

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

2786

msleep(150);

2786

msleep(150);

2787

}

2787

}

2788

snd_hda_shutup_pins(codec);

2788

snd_hda_shutup_pins(codec);

2789

}

2789

}

2790

2791

static void alc282_restore_default_value(struct hda_codec *codec)

2791

static void alc282_restore_default_value(struct hda_codec *codec)

2792

{

2792

{

2793

int val;

2793

int val;

2794

2795

/* Power Down Control */

2795

/* Power Down Control */

2796

alc_write_coef_idx(codec, 0x03, 0x0002);

2796

alc_write_coef_idx(codec, 0x03, 0x0002);

2797

/* FIFO and filter clock */

2797

/* FIFO and filter clock */

2798

alc_write_coef_idx(codec, 0x05, 0x0700);

2798

alc_write_coef_idx(codec, 0x05, 0x0700);

2799

/* DMIC control */

2799

/* DMIC control */

2800

alc_write_coef_idx(codec, 0x07, 0x0200);

2800

alc_write_coef_idx(codec, 0x07, 0x0200);

2801

/* Analog clock */

2801

/* Analog clock */

2802

val = alc_read_coef_idx(codec, 0x06);

2802

val = alc_read_coef_idx(codec, 0x06);

2803

alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);

2803

alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);

2804

/* JD */

2804

/* JD */

2805

val = alc_read_coef_idx(codec, 0x08);

2805

val = alc_read_coef_idx(codec, 0x08);

2806

alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);

2806

alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);

2807

/* JD offset1 */

2807

/* JD offset1 */

2808

alc_write_coef_idx(codec, 0x0a, 0xcccc);

2808

alc_write_coef_idx(codec, 0x0a, 0xcccc);

2809

/* JD offset2 */

2809

/* JD offset2 */

2810

alc_write_coef_idx(codec, 0x0b, 0xcccc);

2810

alc_write_coef_idx(codec, 0x0b, 0xcccc);

2811

/* LDO1/2/3, DAC/ADC */

2811

/* LDO1/2/3, DAC/ADC */

2812

alc_write_coef_idx(codec, 0x0e, 0x6e00);

2812

alc_write_coef_idx(codec, 0x0e, 0x6e00);

2813

/* JD */

2813

/* JD */

2814

val = alc_read_coef_idx(codec, 0x0f);

2814

val = alc_read_coef_idx(codec, 0x0f);

2815

alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);

2815

alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);

2816

/* Capless */

2816

/* Capless */

2817

val = alc_read_coef_idx(codec, 0x10);

2817

val = alc_read_coef_idx(codec, 0x10);

2818

alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);

2818

alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);

2819

/* Class D test 4 */

2819

/* Class D test 4 */

2820

alc_write_coef_idx(codec, 0x6f, 0x0);

2820

alc_write_coef_idx(codec, 0x6f, 0x0);

2821

/* IO power down directly */

2821

/* IO power down directly */

2822

val = alc_read_coef_idx(codec, 0x0c);

2822

val = alc_read_coef_idx(codec, 0x0c);

2823

alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);

2823

alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);

2824

/* ANC */

2824

/* ANC */

2825

alc_write_coef_idx(codec, 0x34, 0xa0c0);

2825

alc_write_coef_idx(codec, 0x34, 0xa0c0);

2826

/* AGC MUX */

2826

/* AGC MUX */

2827

val = alc_read_coef_idx(codec, 0x16);

2827

val = alc_read_coef_idx(codec, 0x16);

2828

alc_write_coef_idx(codec, 0x16, (val & ~0x0008) | 0x0);

2828

alc_write_coef_idx(codec, 0x16, (val & ~0x0008) | 0x0);

2829

/* DAC simple content protection */

2829

/* DAC simple content protection */

2830

val = alc_read_coef_idx(codec, 0x1d);

2830

val = alc_read_coef_idx(codec, 0x1d);

2831

alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);

2831

alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);

2832

/* ADC simple content protection */

2832

/* ADC simple content protection */

2833

val = alc_read_coef_idx(codec, 0x1f);

2833

val = alc_read_coef_idx(codec, 0x1f);

2834

alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);

2834

alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);

2835

/* DAC ADC Zero Detection */

2835

/* DAC ADC Zero Detection */

2836

alc_write_coef_idx(codec, 0x21, 0x8804);

2836

alc_write_coef_idx(codec, 0x21, 0x8804);

2837

/* PLL */

2837

/* PLL */

2838

alc_write_coef_idx(codec, 0x63, 0x2902);

2838

alc_write_coef_idx(codec, 0x63, 0x2902);

2839

/* capless control 2 */

2839

/* capless control 2 */

2840

alc_write_coef_idx(codec, 0x68, 0xa080);

2840

alc_write_coef_idx(codec, 0x68, 0xa080);

2841

/* capless control 3 */

2841

/* capless control 3 */

2842

alc_write_coef_idx(codec, 0x69, 0x3400);

2842

alc_write_coef_idx(codec, 0x69, 0x3400);

2843

/* capless control 4 */

2843

/* capless control 4 */

2844

alc_write_coef_idx(codec, 0x6a, 0x2f3e);

2844

alc_write_coef_idx(codec, 0x6a, 0x2f3e);

2845

/* capless control 5 */

2845

/* capless control 5 */

2846

alc_write_coef_idx(codec, 0x6b, 0x0);

2846

alc_write_coef_idx(codec, 0x6b, 0x0);

2847

/* class D test 2 */

2847

/* class D test 2 */

2848

val = alc_read_coef_idx(codec, 0x6d);

2848

val = alc_read_coef_idx(codec, 0x6d);

2849

alc_write_coef_idx(codec, 0x6d, (val & ~0x0fff) | 0x0900);

2849

alc_write_coef_idx(codec, 0x6d, (val & ~0x0fff) | 0x0900);

2850

/* class D test 3 */

2850

/* class D test 3 */

2851

alc_write_coef_idx(codec, 0x6e, 0x110a);

2851

alc_write_coef_idx(codec, 0x6e, 0x110a);

2852

/* class D test 5 */

2852

/* class D test 5 */

2853

val = alc_read_coef_idx(codec, 0x70);

2853

val = alc_read_coef_idx(codec, 0x70);

2854

alc_write_coef_idx(codec, 0x70, (val & ~0x00f8) | 0x00d8);

2854

alc_write_coef_idx(codec, 0x70, (val & ~0x00f8) | 0x00d8);

2855

/* class D test 6 */

2855

/* class D test 6 */

2856

alc_write_coef_idx(codec, 0x71, 0x0014);

2856

alc_write_coef_idx(codec, 0x71, 0x0014);

2857

/* classD OCP */

2857

/* classD OCP */

2858

alc_write_coef_idx(codec, 0x72, 0xc2ba);

2858

alc_write_coef_idx(codec, 0x72, 0xc2ba);

2859

/* classD pure DC test */

2859

/* classD pure DC test */

2860

val = alc_read_coef_idx(codec, 0x77);

2860

val = alc_read_coef_idx(codec, 0x77);

2861

alc_write_coef_idx(codec, 0x77, (val & ~0x0f80) | 0x0);

2861

alc_write_coef_idx(codec, 0x77, (val & ~0x0f80) | 0x0);

2862

/* Class D amp control */

2862

/* Class D amp control */

2863

alc_write_coef_idx(codec, 0x6c, 0xfc06);

2863

alc_write_coef_idx(codec, 0x6c, 0xfc06);

2864

}

2864

}

2865

2866

static void alc282_init(struct hda_codec *codec)

2866

static void alc282_init(struct hda_codec *codec)

2867

{

2867

{

2868

struct alc_spec *spec = codec->spec;

2868

struct alc_spec *spec = codec->spec;

2869

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

2869

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

2870

bool hp_pin_sense;

2870

bool hp_pin_sense;

2871

int coef78;

2871

int coef78;

2872

2873

alc282_restore_default_value(codec);

2873

alc282_restore_default_value(codec);

2874

2875

if (!hp_pin)

2875

if (!hp_pin)

2876

return;

2876

return;

2877

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2877

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2878

coef78 = alc_read_coef_idx(codec, 0x78);

2878

coef78 = alc_read_coef_idx(codec, 0x78);

2879

2880

/* Index 0x78 Direct Drive HP AMP LPM Control 1 */

2880

/* Index 0x78 Direct Drive HP AMP LPM Control 1 */

2881

/* Headphone capless set to high power mode */

2881

/* Headphone capless set to high power mode */

2882

alc_write_coef_idx(codec, 0x78, 0x9004);

2882

alc_write_coef_idx(codec, 0x78, 0x9004);

2883

2884

if (hp_pin_sense)

2884

if (hp_pin_sense)

2885

msleep(2);

2885

msleep(2);

2886

2887

snd_hda_codec_write(codec, hp_pin, 0,

2887

snd_hda_codec_write(codec, hp_pin, 0,

2888

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2888

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2889

2890

if (hp_pin_sense)

2890

if (hp_pin_sense)

2891

msleep(85);

2891

msleep(85);

2892

2893

snd_hda_codec_write(codec, hp_pin, 0,

2893

snd_hda_codec_write(codec, hp_pin, 0,

2894

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2894

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2895

2896

if (hp_pin_sense)

2896

if (hp_pin_sense)

2897

msleep(100);

2897

msleep(100);

2898

2899

/* Headphone capless set to normal mode */

2899

/* Headphone capless set to normal mode */

2900

alc_write_coef_idx(codec, 0x78, coef78);

2900

alc_write_coef_idx(codec, 0x78, coef78);

2901

}

2901

}

2902

2903

static void alc282_shutup(struct hda_codec *codec)

2903

static void alc282_shutup(struct hda_codec *codec)

2904

{

2904

{

2905

struct alc_spec *spec = codec->spec;

2905

struct alc_spec *spec = codec->spec;

2906

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

2906

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

2907

bool hp_pin_sense;

2907

bool hp_pin_sense;

2908

int coef78;

2908

int coef78;

2909

2910

if (!hp_pin) {

2910

if (!hp_pin) {

2911

alc269_shutup(codec);

2911

alc269_shutup(codec);

2912

return;

2912

return;

2913

}

2913

}

2914

2915

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2915

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2916

coef78 = alc_read_coef_idx(codec, 0x78);

2916

coef78 = alc_read_coef_idx(codec, 0x78);

2917

alc_write_coef_idx(codec, 0x78, 0x9004);

2917

alc_write_coef_idx(codec, 0x78, 0x9004);

2918

2919

if (hp_pin_sense)

2919

if (hp_pin_sense)

2920

msleep(2);

2920

msleep(2);

2921

2922

snd_hda_codec_write(codec, hp_pin, 0,

2922

snd_hda_codec_write(codec, hp_pin, 0,

2923

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2923

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2924

2925

if (hp_pin_sense)

2925

if (hp_pin_sense)

2926

msleep(85);

2926

msleep(85);

2927

2928

snd_hda_codec_write(codec, hp_pin, 0,

2928

snd_hda_codec_write(codec, hp_pin, 0,

2929

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2929

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2930

2931

if (hp_pin_sense)

2931

if (hp_pin_sense)

2932

msleep(100);

2932

msleep(100);

2933

2934

alc_auto_setup_eapd(codec, false);

2934

alc_auto_setup_eapd(codec, false);

2935

snd_hda_shutup_pins(codec);

2935

snd_hda_shutup_pins(codec);

2936

alc_write_coef_idx(codec, 0x78, coef78);

2936

alc_write_coef_idx(codec, 0x78, coef78);

2937

}

2937

}

2938

2939

static void alc283_restore_default_value(struct hda_codec *codec)

2939

static void alc283_restore_default_value(struct hda_codec *codec)

2940

{

2940

{

2941

int val;

2941

int val;

2942

2943

/* Power Down Control */

2943

/* Power Down Control */

2944

alc_write_coef_idx(codec, 0x03, 0x0002);

2944

alc_write_coef_idx(codec, 0x03, 0x0002);

2945

/* FIFO and filter clock */

2945

/* FIFO and filter clock */

2946

alc_write_coef_idx(codec, 0x05, 0x0700);

2946

alc_write_coef_idx(codec, 0x05, 0x0700);

2947

/* DMIC control */

2947

/* DMIC control */

2948

alc_write_coef_idx(codec, 0x07, 0x0200);

2948

alc_write_coef_idx(codec, 0x07, 0x0200);

2949

/* Analog clock */

2949

/* Analog clock */

2950

val = alc_read_coef_idx(codec, 0x06);

2950

val = alc_read_coef_idx(codec, 0x06);

2951

alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);

2951

alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);

2952

/* JD */

2952

/* JD */

2953

val = alc_read_coef_idx(codec, 0x08);

2953

val = alc_read_coef_idx(codec, 0x08);

2954

alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);

2954

alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);

2955

/* JD offset1 */

2955

/* JD offset1 */

2956

alc_write_coef_idx(codec, 0x0a, 0xcccc);

2956

alc_write_coef_idx(codec, 0x0a, 0xcccc);

2957

/* JD offset2 */

2957

/* JD offset2 */

2958

alc_write_coef_idx(codec, 0x0b, 0xcccc);

2958

alc_write_coef_idx(codec, 0x0b, 0xcccc);

2959

/* LDO1/2/3, DAC/ADC */

2959

/* LDO1/2/3, DAC/ADC */

2960

alc_write_coef_idx(codec, 0x0e, 0x6fc0);

2960

alc_write_coef_idx(codec, 0x0e, 0x6fc0);

2961

/* JD */

2961

/* JD */

2962

val = alc_read_coef_idx(codec, 0x0f);

2962

val = alc_read_coef_idx(codec, 0x0f);

2963

alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);

2963

alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);

2964

/* Capless */

2964

/* Capless */

2965

val = alc_read_coef_idx(codec, 0x10);

2965

val = alc_read_coef_idx(codec, 0x10);

2966

alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);

2966

alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);

2967

/* Class D test 4 */

2967

/* Class D test 4 */

2968

alc_write_coef_idx(codec, 0x3a, 0x0);

2968

alc_write_coef_idx(codec, 0x3a, 0x0);

2969

/* IO power down directly */

2969

/* IO power down directly */

2970

val = alc_read_coef_idx(codec, 0x0c);

2970

val = alc_read_coef_idx(codec, 0x0c);

2971

alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);

2971

alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);

2972

/* ANC */

2972

/* ANC */

2973

alc_write_coef_idx(codec, 0x22, 0xa0c0);

2973

alc_write_coef_idx(codec, 0x22, 0xa0c0);

2974

/* AGC MUX */

2974

/* AGC MUX */

2975

val = alc_read_coefex_idx(codec, 0x53, 0x01);

2975

val = alc_read_coefex_idx(codec, 0x53, 0x01);

2976

alc_write_coefex_idx(codec, 0x53, 0x01, (val & ~0x000f) | 0x0008);

2976

alc_write_coefex_idx(codec, 0x53, 0x01, (val & ~0x000f) | 0x0008);

2977

/* DAC simple content protection */

2977

/* DAC simple content protection */

2978

val = alc_read_coef_idx(codec, 0x1d);

2978

val = alc_read_coef_idx(codec, 0x1d);

2979

alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);

2979

alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);

2980

/* ADC simple content protection */

2980

/* ADC simple content protection */

2981

val = alc_read_coef_idx(codec, 0x1f);

2981

val = alc_read_coef_idx(codec, 0x1f);

2982

alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);

2982

alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);

2983

/* DAC ADC Zero Detection */

2983

/* DAC ADC Zero Detection */

2984

alc_write_coef_idx(codec, 0x21, 0x8804);

2984

alc_write_coef_idx(codec, 0x21, 0x8804);

2985

/* PLL */

2985

/* PLL */

2986

alc_write_coef_idx(codec, 0x2e, 0x2902);

2986

alc_write_coef_idx(codec, 0x2e, 0x2902);

2987

/* capless control 2 */

2987

/* capless control 2 */

2988

alc_write_coef_idx(codec, 0x33, 0xa080);

2988

alc_write_coef_idx(codec, 0x33, 0xa080);

2989

/* capless control 3 */

2989

/* capless control 3 */

2990

alc_write_coef_idx(codec, 0x34, 0x3400);

2990

alc_write_coef_idx(codec, 0x34, 0x3400);

2991

/* capless control 4 */

2991

/* capless control 4 */

2992

alc_write_coef_idx(codec, 0x35, 0x2f3e);

2992

alc_write_coef_idx(codec, 0x35, 0x2f3e);

2993

/* capless control 5 */

2993

/* capless control 5 */

2994

alc_write_coef_idx(codec, 0x36, 0x0);

2994

alc_write_coef_idx(codec, 0x36, 0x0);

2995

/* class D test 2 */

2995

/* class D test 2 */

2996

val = alc_read_coef_idx(codec, 0x38);

2996

val = alc_read_coef_idx(codec, 0x38);

2997

alc_write_coef_idx(codec, 0x38, (val & ~0x0fff) | 0x0900);

2997

alc_write_coef_idx(codec, 0x38, (val & ~0x0fff) | 0x0900);

2998

/* class D test 3 */

2998

/* class D test 3 */

2999

alc_write_coef_idx(codec, 0x39, 0x110a);

2999

alc_write_coef_idx(codec, 0x39, 0x110a);

3000

/* class D test 5 */

3000

/* class D test 5 */

3001

val = alc_read_coef_idx(codec, 0x3b);

3001

val = alc_read_coef_idx(codec, 0x3b);

3002

alc_write_coef_idx(codec, 0x3b, (val & ~0x00f8) | 0x00d8);

3002

alc_write_coef_idx(codec, 0x3b, (val & ~0x00f8) | 0x00d8);

3003

/* class D test 6 */

3003

/* class D test 6 */

3004

alc_write_coef_idx(codec, 0x3c, 0x0014);

3004

alc_write_coef_idx(codec, 0x3c, 0x0014);

3005

/* classD OCP */

3005

/* classD OCP */

3006

alc_write_coef_idx(codec, 0x3d, 0xc2ba);

3006

alc_write_coef_idx(codec, 0x3d, 0xc2ba);

3007

/* classD pure DC test */

3007

/* classD pure DC test */

3008

val = alc_read_coef_idx(codec, 0x42);

3008

val = alc_read_coef_idx(codec, 0x42);

3009

alc_write_coef_idx(codec, 0x42, (val & ~0x0f80) | 0x0);

3009

alc_write_coef_idx(codec, 0x42, (val & ~0x0f80) | 0x0);

3010

/* test mode */

3010

/* test mode */

3011

alc_write_coef_idx(codec, 0x49, 0x0);

3011

alc_write_coef_idx(codec, 0x49, 0x0);

3012

/* Class D DC enable */

3012

/* Class D DC enable */

3013

val = alc_read_coef_idx(codec, 0x40);

3013

val = alc_read_coef_idx(codec, 0x40);

3014

alc_write_coef_idx(codec, 0x40, (val & ~0xf800) | 0x9800);

3014

alc_write_coef_idx(codec, 0x40, (val & ~0xf800) | 0x9800);

3015

/* DC offset */

3015

/* DC offset */

3016

val = alc_read_coef_idx(codec, 0x42);

3016

val = alc_read_coef_idx(codec, 0x42);

3017

alc_write_coef_idx(codec, 0x42, (val & ~0xf000) | 0x2000);

3017

alc_write_coef_idx(codec, 0x42, (val & ~0xf000) | 0x2000);

3018

/* Class D amp control */

3018

/* Class D amp control */

3019

alc_write_coef_idx(codec, 0x37, 0xfc06);

3019

alc_write_coef_idx(codec, 0x37, 0xfc06);

3020

}

3020

}

3021

3022

static void alc283_init(struct hda_codec *codec)

3022

static void alc283_init(struct hda_codec *codec)

3023

{

3023

{

3024

struct alc_spec *spec = codec->spec;

3024

struct alc_spec *spec = codec->spec;

3025

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3025

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3026

bool hp_pin_sense;

3026

bool hp_pin_sense;

3027

int val;

3027

int val;

3028

3029

if (!spec->gen.autocfg.hp_outs) {

3029

if (!spec->gen.autocfg.hp_outs) {

3030

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

3030

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

3031

hp_pin = spec->gen.autocfg.line_out_pins[0];

3031

hp_pin = spec->gen.autocfg.line_out_pins[0];

3032

}

3032

}

3033

3034

alc283_restore_default_value(codec);

3034

alc283_restore_default_value(codec);

3035

3036

if (!hp_pin)

3036

if (!hp_pin)

3037

return;

3037

return;

3038

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

3038

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

3039

3040

/* Index 0x43 Direct Drive HP AMP LPM Control 1 */

3040

/* Index 0x43 Direct Drive HP AMP LPM Control 1 */

3041

/* Headphone capless set to high power mode */

3041

/* Headphone capless set to high power mode */

3042

alc_write_coef_idx(codec, 0x43, 0x9004);

3042

alc_write_coef_idx(codec, 0x43, 0x9004);

3043

3044

snd_hda_codec_write(codec, hp_pin, 0,

3044

snd_hda_codec_write(codec, hp_pin, 0,

3045

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

3045

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

3046

3047

if (hp_pin_sense)

3047

if (hp_pin_sense)

3048

msleep(85);

3048

msleep(85);

3049

3050

snd_hda_codec_write(codec, hp_pin, 0,

3050

snd_hda_codec_write(codec, hp_pin, 0,

3051

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

3051

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

3052

3053

if (hp_pin_sense)

3053

if (hp_pin_sense)

3054

msleep(85);

3054

msleep(85);

3055

/* Index 0x46 Combo jack auto switch control 2 */

3055

/* Index 0x46 Combo jack auto switch control 2 */

3056

/* 3k pull low control for Headset jack. */

3056

/* 3k pull low control for Headset jack. */

3057

val = alc_read_coef_idx(codec, 0x46);

3057

val = alc_read_coef_idx(codec, 0x46);

3058

alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));

3058

alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));

3059

/* Headphone capless set to normal mode */

3059

/* Headphone capless set to normal mode */

3060

alc_write_coef_idx(codec, 0x43, 0x9614);

3060

alc_write_coef_idx(codec, 0x43, 0x9614);

3061

}

3061

}

3062

3063

static void alc283_shutup(struct hda_codec *codec)

3063

static void alc283_shutup(struct hda_codec *codec)

3064

{

3064

{

3065

struct alc_spec *spec = codec->spec;

3065

struct alc_spec *spec = codec->spec;

3066

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3066

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3067

bool hp_pin_sense;

3067

bool hp_pin_sense;

3068

int val;

3068

int val;

3069

3070

if (!spec->gen.autocfg.hp_outs) {

3070

if (!spec->gen.autocfg.hp_outs) {

3071

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

3071

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

3072

hp_pin = spec->gen.autocfg.line_out_pins[0];

3072

hp_pin = spec->gen.autocfg.line_out_pins[0];

3073

}

3073

}

3074

3075

if (!hp_pin) {

3075

if (!hp_pin) {

3076

alc269_shutup(codec);

3076

alc269_shutup(codec);

3077

return;

3077

return;

3078

}

3078

}

3079

3080

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

3080

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

3081

3082

alc_write_coef_idx(codec, 0x43, 0x9004);

3082

alc_write_coef_idx(codec, 0x43, 0x9004);

3083

3084

snd_hda_codec_write(codec, hp_pin, 0,

3084

snd_hda_codec_write(codec, hp_pin, 0,

3085

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

3085

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

3086

3087

if (hp_pin_sense)

3087

if (hp_pin_sense)

3088

msleep(100);

3088

msleep(100);

3089

3090

snd_hda_codec_write(codec, hp_pin, 0,

3090

snd_hda_codec_write(codec, hp_pin, 0,

3091

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

3091

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

3092

3093

val = alc_read_coef_idx(codec, 0x46);

3093

val = alc_read_coef_idx(codec, 0x46);

3094

alc_write_coef_idx(codec, 0x46, val | (3 << 12));

3094

alc_write_coef_idx(codec, 0x46, val | (3 << 12));

3095

3096

if (hp_pin_sense)

3096

if (hp_pin_sense)

3097

msleep(100);

3097

msleep(100);

3098

snd_hda_shutup_pins(codec);

3098

snd_hda_shutup_pins(codec);

3099

alc_write_coef_idx(codec, 0x43, 0x9614);

3099

alc_write_coef_idx(codec, 0x43, 0x9614);

3100

}

3100

}

3101

3102

static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,

3102

static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,

3103

unsigned int val)

3103

unsigned int val)

3104

{

3104

{

3105

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

3105

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

3106

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */

3106

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */

3107

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */

3107

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */

3108

}

3108

}

3109

3110

static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)

3110

static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)

3111

{

3111

{

3112

unsigned int val;

3112

unsigned int val;

3113

3114

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

3114

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

3115

val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

3115

val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

3116

& 0xffff;

3116

& 0xffff;

3117

val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

3117

val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

3118

<< 16;

3118

<< 16;

3119

return val;

3119

return val;

3120

}

3120

}

3121

3122

static void alc5505_dsp_halt(struct hda_codec *codec)

3122

static void alc5505_dsp_halt(struct hda_codec *codec)

3123

{

3123

{

3124

unsigned int val;

3124

unsigned int val;

3125

3126

alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */

3126

alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */

3127

alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */

3127

alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */

3128

alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */

3128

alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */

3129

alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */

3129

alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */

3130

alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */

3130

alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */

3131

alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */

3131

alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */

3132

alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */

3132

alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */

3133

val = alc5505_coef_get(codec, 0x6220);

3133

val = alc5505_coef_get(codec, 0x6220);

3134

alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */

3134

alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */

3135

}

3135

}

3136

3137

static void alc5505_dsp_back_from_halt(struct hda_codec *codec)

3137

static void alc5505_dsp_back_from_halt(struct hda_codec *codec)

3138

{

3138

{

3139

alc5505_coef_set(codec, 0x61b8, 0x04133302);

3139

alc5505_coef_set(codec, 0x61b8, 0x04133302);

3140

alc5505_coef_set(codec, 0x61b0, 0x00005b16);

3140

alc5505_coef_set(codec, 0x61b0, 0x00005b16);

3141

alc5505_coef_set(codec, 0x61b4, 0x040a2b02);

3141

alc5505_coef_set(codec, 0x61b4, 0x040a2b02);

3142

alc5505_coef_set(codec, 0x6230, 0xf80d4011);

3142

alc5505_coef_set(codec, 0x6230, 0xf80d4011);

3143

alc5505_coef_set(codec, 0x6220, 0x2002010f);

3143

alc5505_coef_set(codec, 0x6220, 0x2002010f);

3144

alc5505_coef_set(codec, 0x880c, 0x00000004);

3144

alc5505_coef_set(codec, 0x880c, 0x00000004);

3145

}

3145

}

3146

3147

static void alc5505_dsp_init(struct hda_codec *codec)

3147

static void alc5505_dsp_init(struct hda_codec *codec)

3148

{

3148

{

3149

unsigned int val;

3149

unsigned int val;

3150

3151

alc5505_dsp_halt(codec);

3151

alc5505_dsp_halt(codec);

3152

alc5505_dsp_back_from_halt(codec);

3152

alc5505_dsp_back_from_halt(codec);

3153

alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */

3153

alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */

3154

alc5505_coef_set(codec, 0x61b0, 0x5b16);

3154

alc5505_coef_set(codec, 0x61b0, 0x5b16);

3155

alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */

3155

alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */

3156

alc5505_coef_set(codec, 0x61b4, 0x04132b02);

3156

alc5505_coef_set(codec, 0x61b4, 0x04132b02);

3157

alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/

3157

alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/

3158

alc5505_coef_set(codec, 0x61b8, 0x041f3302);

3158

alc5505_coef_set(codec, 0x61b8, 0x041f3302);

3159

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */

3159

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */

3160

alc5505_coef_set(codec, 0x61b8, 0x041b3302);

3160

alc5505_coef_set(codec, 0x61b8, 0x041b3302);

3161

alc5505_coef_set(codec, 0x61b8, 0x04173302);

3161

alc5505_coef_set(codec, 0x61b8, 0x04173302);

3162

alc5505_coef_set(codec, 0x61b8, 0x04163302);

3162

alc5505_coef_set(codec, 0x61b8, 0x04163302);

3163

alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */

3163

alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */

3164

alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */

3164

alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */

3165

alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */

3165

alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */

3166

3167

val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */

3167

val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */

3168

if (val <= 3)

3168

if (val <= 3)

3169

alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */

3169

alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */

3170

else

3170

else

3171

alc5505_coef_set(codec, 0x6220, 0x6002018f);

3171

alc5505_coef_set(codec, 0x6220, 0x6002018f);

3172

3173

alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/

3173

alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/

3174

alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */

3174

alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */

3175

alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */

3175

alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */

3176

alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */

3176

alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */

3177

alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */

3177

alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */

3178

alc5505_coef_set(codec, 0x880c, 0x00000003);

3178

alc5505_coef_set(codec, 0x880c, 0x00000003);

3179

alc5505_coef_set(codec, 0x880c, 0x00000010);

3179

alc5505_coef_set(codec, 0x880c, 0x00000010);

3180

3181

#ifdef HALT_REALTEK_ALC5505

3181

#ifdef HALT_REALTEK_ALC5505

3182

alc5505_dsp_halt(codec);

3182

alc5505_dsp_halt(codec);

3183

#endif

3183

#endif

3184

}

3184

}

3185

3186

#ifdef HALT_REALTEK_ALC5505

3186

#ifdef HALT_REALTEK_ALC5505

3187

#define alc5505_dsp_suspend(codec) /* NOP */

3187

#define alc5505_dsp_suspend(codec) /* NOP */

3188

#define alc5505_dsp_resume(codec) /* NOP */

3188

#define alc5505_dsp_resume(codec) /* NOP */

3189

#else

3189

#else

3190

#define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)

3190

#define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)

3191

#define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)

3191

#define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)

3192

#endif

3192

#endif

3193

3194

#ifdef CONFIG_PM

3194

#ifdef CONFIG_PM

3195

static int alc269_suspend(struct hda_codec *codec)

3195

static int alc269_suspend(struct hda_codec *codec)

3196

{

3196

{

3197

struct alc_spec *spec = codec->spec;

3197

struct alc_spec *spec = codec->spec;

3198

3199

if (spec->has_alc5505_dsp)

3199

if (spec->has_alc5505_dsp)

3200

alc5505_dsp_suspend(codec);

3200

alc5505_dsp_suspend(codec);

3201

return alc_suspend(codec);

3201

return alc_suspend(codec);

3202

}

3202

}

3203

3204

static int alc269_resume(struct hda_codec *codec)

3204

static int alc269_resume(struct hda_codec *codec)

3205

{

3205

{

3206

struct alc_spec *spec = codec->spec;

3206

struct alc_spec *spec = codec->spec;

3207

3208

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3208

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3209

alc269vb_toggle_power_output(codec, 0);

3209

alc269vb_toggle_power_output(codec, 0);

3210

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3210

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3211

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

3211

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

3212

msleep(150);

3212

msleep(150);

3213

}

3213

}

3214

3215

codec->patch_ops.init(codec);

3215

codec->patch_ops.init(codec);

3216

3217

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3217

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3218

alc269vb_toggle_power_output(codec, 1);

3218

alc269vb_toggle_power_output(codec, 1);

3219

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3219

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3220

(alc_get_coef0(codec) & 0x00ff) == 0x017) {

3220

(alc_get_coef0(codec) & 0x00ff) == 0x017) {

3221

msleep(200);

3221

msleep(200);

3222

}

3222

}

3223

3224

snd_hda_codec_resume_amp(codec);

3224

snd_hda_codec_resume_amp(codec);

3225

snd_hda_codec_resume_cache(codec);

3225

snd_hda_codec_resume_cache(codec);

3226

alc_inv_dmic_sync(codec, true);

3226

alc_inv_dmic_sync(codec, true);

3227

hda_call_check_power_status(codec, 0x01);

3227

hda_call_check_power_status(codec, 0x01);

3228

if (spec->has_alc5505_dsp)

3228

if (spec->has_alc5505_dsp)

3229

alc5505_dsp_resume(codec);

3229

alc5505_dsp_resume(codec);

3230

3231

return 0;

3231

return 0;

3232

}

3232

}

3233

#endif /* CONFIG_PM */

3233

#endif /* CONFIG_PM */

3234

3235

static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,

3235

static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,

3236

const struct hda_fixup *fix, int action)

3236

const struct hda_fixup *fix, int action)

3237

{

3237

{

3238

struct alc_spec *spec = codec->spec;

3238

struct alc_spec *spec = codec->spec;

3239

3240

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3240

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3241

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

3241

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

3242

}

3242

}

3243

3244

static void alc269_fixup_hweq(struct hda_codec *codec,

3244

static void alc269_fixup_hweq(struct hda_codec *codec,

3245

const struct hda_fixup *fix, int action)

3245

const struct hda_fixup *fix, int action)

3246

{

3246

{

3247

int coef;

3247

int coef;

3248

3249

if (action != HDA_FIXUP_ACT_INIT)

3249

if (action != HDA_FIXUP_ACT_INIT)

3250

return;

3250

return;

3251

coef = alc_read_coef_idx(codec, 0x1e);

3251

coef = alc_read_coef_idx(codec, 0x1e);

3252

alc_write_coef_idx(codec, 0x1e, coef | 0x80);

3252

alc_write_coef_idx(codec, 0x1e, coef | 0x80);

3253

}

3253

}

3254

3255

static void alc269_fixup_headset_mic(struct hda_codec *codec,

3255

static void alc269_fixup_headset_mic(struct hda_codec *codec,

3256

const struct hda_fixup *fix, int action)

3256

const struct hda_fixup *fix, int action)

3257

{

3257

{

3258

struct alc_spec *spec = codec->spec;

3258

struct alc_spec *spec = codec->spec;

3259

3260

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3260

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3261

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3261

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3262

}

3262

}

3263

3264

static void alc271_fixup_dmic(struct hda_codec *codec,

3264

static void alc271_fixup_dmic(struct hda_codec *codec,

3265

const struct hda_fixup *fix, int action)

3265

const struct hda_fixup *fix, int action)

3266

{

3266

{

3267

static const struct hda_verb verbs[] = {

3267

static const struct hda_verb verbs[] = {

3268

{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},

3268

{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},

3269

{0x20, AC_VERB_SET_PROC_COEF, 0x4000},

3269

{0x20, AC_VERB_SET_PROC_COEF, 0x4000},

3270

{}

3270

{}

3271

};

3271

};

3272

unsigned int cfg;

3272

unsigned int cfg;

3273

3274

if (strcmp(codec->chip_name, "ALC271X") &&

3274

if (strcmp(codec->chip_name, "ALC271X") &&

3275

strcmp(codec->chip_name, "ALC269VB"))

3275

strcmp(codec->chip_name, "ALC269VB"))

3276

return;

3276

return;

3277

cfg = snd_hda_codec_get_pincfg(codec, 0x12);

3277

cfg = snd_hda_codec_get_pincfg(codec, 0x12);

3278

if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)

3278

if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)

3279

snd_hda_sequence_write(codec, verbs);

3279

snd_hda_sequence_write(codec, verbs);

3280

}

3280

}

3281

3282

static void alc269_fixup_pcm_44k(struct hda_codec *codec,

3282

static void alc269_fixup_pcm_44k(struct hda_codec *codec,

3283

const struct hda_fixup *fix, int action)

3283

const struct hda_fixup *fix, int action)

3284

{

3284

{

3285

struct alc_spec *spec = codec->spec;

3285

struct alc_spec *spec = codec->spec;

3286

3287

if (action != HDA_FIXUP_ACT_PROBE)

3287

if (action != HDA_FIXUP_ACT_PROBE)

3288

return;

3288

return;

3289

3290

/* Due to a hardware problem on Lenovo Ideadpad, we need to

3290

/* Due to a hardware problem on Lenovo Ideadpad, we need to

3291

* fix the sample rate of analog I/O to 44.1kHz

3291

* fix the sample rate of analog I/O to 44.1kHz

3292

*/

3292

*/

3293

spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;

3293

spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;

3294

spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;

3294

spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;

3295

}

3295

}

3296

3297

static void alc269_fixup_stereo_dmic(struct hda_codec *codec,

3297

static void alc269_fixup_stereo_dmic(struct hda_codec *codec,

3298

const struct hda_fixup *fix, int action)

3298

const struct hda_fixup *fix, int action)

3299

{

3299

{

3300

int coef;

3300

int coef;

3301

3302

if (action != HDA_FIXUP_ACT_INIT)

3302

if (action != HDA_FIXUP_ACT_INIT)

3303

return;

3303

return;

3304

/* The digital-mic unit sends PDM (differential signal) instead of

3304

/* The digital-mic unit sends PDM (differential signal) instead of

3305

* the standard PCM, thus you can't record a valid mono stream as is.

3305

* the standard PCM, thus you can't record a valid mono stream as is.

3306

* Below is a workaround specific to ALC269 to control the dmic

3306

* Below is a workaround specific to ALC269 to control the dmic

3307

* signal source as mono.

3307

* signal source as mono.

3308

*/

3308

*/

3309

coef = alc_read_coef_idx(codec, 0x07);

3309

coef = alc_read_coef_idx(codec, 0x07);

3310

alc_write_coef_idx(codec, 0x07, coef | 0x80);

3310

alc_write_coef_idx(codec, 0x07, coef | 0x80);

3311

}

3311

}

3312

3313

static void alc269_quanta_automute(struct hda_codec *codec)

3313

static void alc269_quanta_automute(struct hda_codec *codec)

3314

{

3314

{

3315

snd_hda_gen_update_outputs(codec);

3315

snd_hda_gen_update_outputs(codec);

3316

3317

snd_hda_codec_write(codec, 0x20, 0,

3317

snd_hda_codec_write(codec, 0x20, 0,

3318

AC_VERB_SET_COEF_INDEX, 0x0c);

3318

AC_VERB_SET_COEF_INDEX, 0x0c);

3319

snd_hda_codec_write(codec, 0x20, 0,

3319

snd_hda_codec_write(codec, 0x20, 0,

3320

AC_VERB_SET_PROC_COEF, 0x680);

3320

AC_VERB_SET_PROC_COEF, 0x680);

3321

3322

snd_hda_codec_write(codec, 0x20, 0,

3322

snd_hda_codec_write(codec, 0x20, 0,

3323

AC_VERB_SET_COEF_INDEX, 0x0c);

3323

AC_VERB_SET_COEF_INDEX, 0x0c);

3324

snd_hda_codec_write(codec, 0x20, 0,

3324

snd_hda_codec_write(codec, 0x20, 0,

3325

AC_VERB_SET_PROC_COEF, 0x480);

3325

AC_VERB_SET_PROC_COEF, 0x480);

3326

}

3326

}

3327

3328

static void alc269_fixup_quanta_mute(struct hda_codec *codec,

3328

static void alc269_fixup_quanta_mute(struct hda_codec *codec,

3329

const struct hda_fixup *fix, int action)

3329

const struct hda_fixup *fix, int action)

3330

{

3330

{

3331

struct alc_spec *spec = codec->spec;

3331

struct alc_spec *spec = codec->spec;

3332

if (action != HDA_FIXUP_ACT_PROBE)

3332

if (action != HDA_FIXUP_ACT_PROBE)

3333

return;

3333

return;

3334

spec->gen.automute_hook = alc269_quanta_automute;

3334

spec->gen.automute_hook = alc269_quanta_automute;

3335

}

3335

}

3336

3337

static void alc269_x101_hp_automute_hook(struct hda_codec *codec,

3337

static void alc269_x101_hp_automute_hook(struct hda_codec *codec,

3338

struct hda_jack_tbl *jack)

3338

struct hda_jack_tbl *jack)

3339

{

3339

{

3340

struct alc_spec *spec = codec->spec;

3340

struct alc_spec *spec = codec->spec;

3341

int vref;

3341

int vref;

3342

msleep(200);

3342

msleep(200);

3343

snd_hda_gen_hp_automute(codec, jack);

3343

snd_hda_gen_hp_automute(codec, jack);

3344

3345

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3345

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3346

msleep(100);

3346

msleep(100);

3347

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3347

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3348

vref);

3348

vref);

3349

msleep(500);

3349

msleep(500);

3350

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3350

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3351

vref);

3351

vref);

3352

}

3352

}

3353

3354

static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,

3354

static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,

3355

const struct hda_fixup *fix, int action)

3355

const struct hda_fixup *fix, int action)

3356

{

3356

{

3357

struct alc_spec *spec = codec->spec;

3357

struct alc_spec *spec = codec->spec;

3358

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3358

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3359

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3359

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3360

spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;

3360

spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;

3361

}

3361

}

3362

}

3362

}

3363

3364

3365

/* update mute-LED according to the speaker mute state via mic VREF pin */

3365

/* update mute-LED according to the speaker mute state via mic VREF pin */

3366

static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)

3366

static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)

3367

{

3367

{

3368

struct hda_codec *codec = private_data;

3368

struct hda_codec *codec = private_data;

3369

struct alc_spec *spec = codec->spec;

3369

struct alc_spec *spec = codec->spec;

3370

unsigned int pinval;

3370

unsigned int pinval;

3371

3372

if (spec->mute_led_polarity)

3372

if (spec->mute_led_polarity)

3373

enabled = !enabled;

3373

enabled = !enabled;

3374

pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);

3374

pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);

3375

pinval &= ~AC_PINCTL_VREFEN;

3375

pinval &= ~AC_PINCTL_VREFEN;

3376

pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;

3376

pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;

3377

if (spec->mute_led_nid)

3377

if (spec->mute_led_nid)

3378

snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);

3378

snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);

3379

}

3379

}

3380

3381

/* Make sure the led works even in runtime suspend */

3381

/* Make sure the led works even in runtime suspend */

3382

static unsigned int led_power_filter(struct hda_codec *codec,

3382

static unsigned int led_power_filter(struct hda_codec *codec,

3383

hda_nid_t nid,

3383

hda_nid_t nid,

3384

unsigned int power_state)

3384

unsigned int power_state)

3385

{

3385

{

3386

struct alc_spec *spec = codec->spec;

3386

struct alc_spec *spec = codec->spec;

3387

3388

if (power_state != AC_PWRST_D3 || nid != spec->mute_led_nid)

3388

if (power_state != AC_PWRST_D3 || nid != spec->mute_led_nid)

3389

return power_state;

3389

return power_state;

3390

3391

/* Set pin ctl again, it might have just been set to 0 */

3391

/* Set pin ctl again, it might have just been set to 0 */

3392

snd_hda_set_pin_ctl(codec, nid,

3392

snd_hda_set_pin_ctl(codec, nid,

3393

snd_hda_codec_get_pin_target(codec, nid));

3393

snd_hda_codec_get_pin_target(codec, nid));

3394

3395

return AC_PWRST_D0;

3395

return AC_PWRST_D0;

3396

}

3396

}

3397

3398

static void alc269_fixup_hp_mute_led(struct hda_codec *codec,

3398

static void alc269_fixup_hp_mute_led(struct hda_codec *codec,

3399

const struct hda_fixup *fix, int action)

3399

const struct hda_fixup *fix, int action)

3400

{

3400

{

3401

struct alc_spec *spec = codec->spec;

3401

struct alc_spec *spec = codec->spec;

3402

const struct dmi_device *dev = NULL;

3402

const struct dmi_device *dev = NULL;

3403

3404

if (action != HDA_FIXUP_ACT_PRE_PROBE)

3404

if (action != HDA_FIXUP_ACT_PRE_PROBE)

3405

return;

3405

return;

3406

3407

while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {

3407

while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {

3408

int pol, pin;

3408

int pol, pin;

3409

if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)

3409

if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)

3410

continue;

3410

continue;

3411

if (pin < 0x0a || pin >= 0x10)

3411

if (pin < 0x0a || pin >= 0x10)

3412

break;

3412

break;

3413

spec->mute_led_polarity = pol;

3413

spec->mute_led_polarity = pol;

3414

spec->mute_led_nid = pin - 0x0a + 0x18;

3414

spec->mute_led_nid = pin - 0x0a + 0x18;

3415

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3415

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3416

spec->gen.vmaster_mute_enum = 1;

3416

spec->gen.vmaster_mute_enum = 1;

3417

codec->power_filter = led_power_filter;

3417

codec->power_filter = led_power_filter;

3418

codec_dbg(codec,

3418

codec_dbg(codec,

3419

"Detected mute LED for %x:%d\n", spec->mute_led_nid,

3419

"Detected mute LED for %x:%d\n", spec->mute_led_nid,

3420

spec->mute_led_polarity);

3420

spec->mute_led_polarity);

3421

break;

3421

break;

3422

}

3422

}

3423

}

3423

}

3424

3425

static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,

3425

static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,

3426

const struct hda_fixup *fix, int action)

3426

const struct hda_fixup *fix, int action)

3427

{

3427

{

3428

struct alc_spec *spec = codec->spec;

3428

struct alc_spec *spec = codec->spec;

3429

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3429

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3430

spec->mute_led_polarity = 0;

3430

spec->mute_led_polarity = 0;

3431

spec->mute_led_nid = 0x18;

3431

spec->mute_led_nid = 0x18;

3432

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3432

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3433

spec->gen.vmaster_mute_enum = 1;

3433

spec->gen.vmaster_mute_enum = 1;

3434

codec->power_filter = led_power_filter;

3434

codec->power_filter = led_power_filter;

3435

}

3435

}

3436

}

3436

}

3437

3438

static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,

3438

static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,

3439

const struct hda_fixup *fix, int action)

3439

const struct hda_fixup *fix, int action)

3440

{

3440

{

3441

struct alc_spec *spec = codec->spec;

3441

struct alc_spec *spec = codec->spec;

3442

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3442

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3443

spec->mute_led_polarity = 0;

3443

spec->mute_led_polarity = 0;

3444

spec->mute_led_nid = 0x19;

3444

spec->mute_led_nid = 0x19;

3445

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3445

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3446

spec->gen.vmaster_mute_enum = 1;

3446

spec->gen.vmaster_mute_enum = 1;

3447

codec->power_filter = led_power_filter;

3447

codec->power_filter = led_power_filter;

3448

}

3448

}

3449

}

3449

}

3450

3451

/* turn on/off mute LED per vmaster hook */

3451

/* turn on/off mute LED per vmaster hook */

3452

static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)

3452

static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)

3453

{

3453

{

3454

struct hda_codec *codec = private_data;

3454

struct hda_codec *codec = private_data;

3455

struct alc_spec *spec = codec->spec;

3455

struct alc_spec *spec = codec->spec;

3456

unsigned int oldval = spec->gpio_led;

3456

unsigned int oldval = spec->gpio_led;

3457

3458

if (enabled)

3458

if (enabled)

3459

spec->gpio_led &= ~0x08;

3459

spec->gpio_led &= ~0x08;

3460

else

3460

else

3461

spec->gpio_led |= 0x08;

3461

spec->gpio_led |= 0x08;

3462

if (spec->gpio_led != oldval)

3462

if (spec->gpio_led != oldval)

3463

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3463

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3464

spec->gpio_led);

3464

spec->gpio_led);

3465

}

3465

}

3466

3467

/* turn on/off mic-mute LED per capture hook */

3467

/* turn on/off mic-mute LED per capture hook */

3468

static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,

3468

static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,

3469

struct snd_kcontrol *kcontrol,

3469

struct snd_kcontrol *kcontrol,

3470

struct snd_ctl_elem_value *ucontrol)

3470

struct snd_ctl_elem_value *ucontrol)

3471

{

3471

{

3472

struct alc_spec *spec = codec->spec;

3472

struct alc_spec *spec = codec->spec;

3473

unsigned int oldval = spec->gpio_led;

3473

unsigned int oldval = spec->gpio_led;

3474

3475

if (!ucontrol)

3475

if (!ucontrol)

3476

return;

3476

return;

3477

3478

if (ucontrol->value.integer.value[0] ||

3478

if (ucontrol->value.integer.value[0] ||

3479

ucontrol->value.integer.value[1])

3479

ucontrol->value.integer.value[1])

3480

spec->gpio_led &= ~0x10;

3480

spec->gpio_led &= ~0x10;

3481

else

3481

else

3482

spec->gpio_led |= 0x10;

3482

spec->gpio_led |= 0x10;

3483

if (spec->gpio_led != oldval)

3483

if (spec->gpio_led != oldval)

3484

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3484

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3485

spec->gpio_led);

3485

spec->gpio_led);

3486

}

3486

}

3487

3488

static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,

3488

static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,

3489

const struct hda_fixup *fix, int action)

3489

const struct hda_fixup *fix, int action)

3490

{

3490

{

3491

struct alc_spec *spec = codec->spec;

3491

struct alc_spec *spec = codec->spec;

3492

static const struct hda_verb gpio_init[] = {

3492

static const struct hda_verb gpio_init[] = {

3493

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3493

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3494

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3494

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3495

{}

3495

{}

3496

};

3496

};

3497

3498

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3498

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3499

spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;

3499

spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;

3500

spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;

3500

spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;

3501

spec->gpio_led = 0;

3501

spec->gpio_led = 0;

3502

snd_hda_add_verbs(codec, gpio_init);

3502

snd_hda_add_verbs(codec, gpio_init);

3503

}

3503

}

3504

}

3504

}

3505

3506

static void alc_headset_mode_unplugged(struct hda_codec *codec)

3506

static void alc_headset_mode_unplugged(struct hda_codec *codec)

3507

{

3507

{

3508

int val;

3508

int val;

3509

3510

switch (codec->vendor_id) {

3510

switch (codec->vendor_id) {

3511

case 0x10ec0255:

3511

case 0x10ec0255:

3512

/* LDO and MISC control */

3512

/* LDO and MISC control */

3513

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3513

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3514

/* UAJ function set to menual mode */

3514

/* UAJ function set to menual mode */

3515

alc_write_coef_idx(codec, 0x45, 0xd089);

3515

alc_write_coef_idx(codec, 0x45, 0xd089);

3516

/* Direct Drive HP Amp control(Set to verb control)*/

3516

/* Direct Drive HP Amp control(Set to verb control)*/

3517

val = alc_read_coefex_idx(codec, 0x57, 0x05);

3517

val = alc_read_coefex_idx(codec, 0x57, 0x05);

3518

alc_write_coefex_idx(codec, 0x57, 0x05, val & ~(1<<14));

3518

alc_write_coefex_idx(codec, 0x57, 0x05, val & ~(1<<14));

3519

/* Set MIC2 Vref gate with HP */

3519

/* Set MIC2 Vref gate with HP */

3520

alc_write_coef_idx(codec, 0x06, 0x6104);

3520

alc_write_coef_idx(codec, 0x06, 0x6104);

3521

/* Direct Drive HP Amp control */

3521

/* Direct Drive HP Amp control */

3522

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);

3522

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);

3523

break;

3523

break;

3524

case 0x10ec0283:

3524

case 0x10ec0283:

3525

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3525

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3526

alc_write_coef_idx(codec, 0x45, 0xc429);

3526

alc_write_coef_idx(codec, 0x45, 0xc429);

3527

val = alc_read_coef_idx(codec, 0x35);

3527

val = alc_read_coef_idx(codec, 0x35);

3528

alc_write_coef_idx(codec, 0x35, val & 0xbfff);

3528

alc_write_coef_idx(codec, 0x35, val & 0xbfff);

3529

alc_write_coef_idx(codec, 0x06, 0x2104);

3529

alc_write_coef_idx(codec, 0x06, 0x2104);

3530

alc_write_coef_idx(codec, 0x1a, 0x0001);

3530

alc_write_coef_idx(codec, 0x1a, 0x0001);

3531

alc_write_coef_idx(codec, 0x26, 0x0004);

3531

alc_write_coef_idx(codec, 0x26, 0x0004);

3532

alc_write_coef_idx(codec, 0x32, 0x42a3);

3532

alc_write_coef_idx(codec, 0x32, 0x42a3);

3533

break;

3533

break;

3534

case 0x10ec0292:

3534

case 0x10ec0292:

3535

alc_write_coef_idx(codec, 0x76, 0x000e);

3535

alc_write_coef_idx(codec, 0x76, 0x000e);

3536

alc_write_coef_idx(codec, 0x6c, 0x2400);

3536

alc_write_coef_idx(codec, 0x6c, 0x2400);

3537

alc_write_coef_idx(codec, 0x18, 0x7308);

3537

alc_write_coef_idx(codec, 0x18, 0x7308);

3538

alc_write_coef_idx(codec, 0x6b, 0xc429);

3538

alc_write_coef_idx(codec, 0x6b, 0xc429);

3539

break;

3539

break;

3540

case 0x10ec0668:

3540

case 0x10ec0668:

3541

alc_write_coef_idx(codec, 0x15, 0x0d40);

3541

alc_write_coef_idx(codec, 0x15, 0x0d40);

3542

alc_write_coef_idx(codec, 0xb7, 0x802b);

3542

alc_write_coef_idx(codec, 0xb7, 0x802b);

3543

break;

3543

break;

3544

}

3544

}

3545

codec_dbg(codec, "Headset jack set to unplugged mode.\n");

3545

codec_dbg(codec, "Headset jack set to unplugged mode.\n");

3546

}

3546

}

3547

3548

3549

static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,

3549

static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,

3550

hda_nid_t mic_pin)

3550

hda_nid_t mic_pin)

3551

{

3551

{

3552

int val;

3552

int val;

3553

3554

switch (codec->vendor_id) {

3554

switch (codec->vendor_id) {

3555

case 0x10ec0255:

3555

case 0x10ec0255:

3556

alc_write_coef_idx(codec, 0x45, 0xc489);

3556

alc_write_coef_idx(codec, 0x45, 0xc489);

3557

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3557

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3558

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);

3558

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);

3559

/* Set MIC2 Vref gate to normal */

3559

/* Set MIC2 Vref gate to normal */

3560

alc_write_coef_idx(codec, 0x06, 0x6100);

3560

alc_write_coef_idx(codec, 0x06, 0x6100);

3561

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3561

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3562

break;

3562

break;

3563

case 0x10ec0283:

3563

case 0x10ec0283:

3564

alc_write_coef_idx(codec, 0x45, 0xc429);

3564

alc_write_coef_idx(codec, 0x45, 0xc429);

3565

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3565

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3566

val = alc_read_coef_idx(codec, 0x35);

3566

val = alc_read_coef_idx(codec, 0x35);

3567

alc_write_coef_idx(codec, 0x35, val | 1<<14);

3567

alc_write_coef_idx(codec, 0x35, val | 1<<14);

3568

alc_write_coef_idx(codec, 0x06, 0x2100);

3568

alc_write_coef_idx(codec, 0x06, 0x2100);

3569

alc_write_coef_idx(codec, 0x1a, 0x0021);

3569

alc_write_coef_idx(codec, 0x1a, 0x0021);

3570

alc_write_coef_idx(codec, 0x26, 0x008c);

3570

alc_write_coef_idx(codec, 0x26, 0x008c);

3571

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3571

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3572

break;

3572

break;

3573

case 0x10ec0292:

3573

case 0x10ec0292:

3574

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3574

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3575

alc_write_coef_idx(codec, 0x19, 0xa208);

3575

alc_write_coef_idx(codec, 0x19, 0xa208);

3576

alc_write_coef_idx(codec, 0x2e, 0xacf0);

3576

alc_write_coef_idx(codec, 0x2e, 0xacf0);

3577

break;

3577

break;

3578

case 0x10ec0668:

3578

case 0x10ec0668:

3579

alc_write_coef_idx(codec, 0x11, 0x0001);

3579

alc_write_coef_idx(codec, 0x11, 0x0001);

3580

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3580

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3581

alc_write_coef_idx(codec, 0xb7, 0x802b);

3581

alc_write_coef_idx(codec, 0xb7, 0x802b);

3582

alc_write_coef_idx(codec, 0xb5, 0x1040);

3582

alc_write_coef_idx(codec, 0xb5, 0x1040);

3583

val = alc_read_coef_idx(codec, 0xc3);

3583

val = alc_read_coef_idx(codec, 0xc3);

3584

alc_write_coef_idx(codec, 0xc3, val | 1<<12);

3584

alc_write_coef_idx(codec, 0xc3, val | 1<<12);

3585

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3585

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3586

break;

3586

break;

3587

}

3587

}

3588

codec_dbg(codec, "Headset jack set to mic-in mode.\n");

3588

codec_dbg(codec, "Headset jack set to mic-in mode.\n");

3589

}

3589

}

3590

3591

static void alc_headset_mode_default(struct hda_codec *codec)

3591

static void alc_headset_mode_default(struct hda_codec *codec)

3592

{

3592

{

3593

switch (codec->vendor_id) {

3593

switch (codec->vendor_id) {

3594

case 0x10ec0255:

3594

case 0x10ec0255:

3595

alc_write_coef_idx(codec, 0x45, 0xc089);

3595

alc_write_coef_idx(codec, 0x45, 0xc089);

3596

alc_write_coef_idx(codec, 0x45, 0xc489);

3596

alc_write_coef_idx(codec, 0x45, 0xc489);

3597

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3597

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3598

alc_write_coef_idx(codec, 0x49, 0x0049);

3598

alc_write_coef_idx(codec, 0x49, 0x0049);

3599

break;

3599

break;

3600

case 0x10ec0283:

3600

case 0x10ec0283:

3601

alc_write_coef_idx(codec, 0x06, 0x2100);

3601

alc_write_coef_idx(codec, 0x06, 0x2100);

3602

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3602

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3603

break;

3603

break;

3604

case 0x10ec0292:

3604

case 0x10ec0292:

3605

alc_write_coef_idx(codec, 0x76, 0x000e);

3605

alc_write_coef_idx(codec, 0x76, 0x000e);

3606

alc_write_coef_idx(codec, 0x6c, 0x2400);

3606

alc_write_coef_idx(codec, 0x6c, 0x2400);

3607

alc_write_coef_idx(codec, 0x6b, 0xc429);

3607

alc_write_coef_idx(codec, 0x6b, 0xc429);

3608

alc_write_coef_idx(codec, 0x18, 0x7308);

3608

alc_write_coef_idx(codec, 0x18, 0x7308);

3609

break;

3609

break;

3610

case 0x10ec0668:

3610

case 0x10ec0668:

3611

alc_write_coef_idx(codec, 0x11, 0x0041);

3611

alc_write_coef_idx(codec, 0x11, 0x0041);

3612

alc_write_coef_idx(codec, 0x15, 0x0d40);

3612

alc_write_coef_idx(codec, 0x15, 0x0d40);

3613

alc_write_coef_idx(codec, 0xb7, 0x802b);

3613

alc_write_coef_idx(codec, 0xb7, 0x802b);

3614

break;

3614

break;

3615

}

3615

}

3616

codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");

3616

codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");

3617

}

3617

}

3618

3619

/* Iphone type */

3619

/* Iphone type */

3620

static void alc_headset_mode_ctia(struct hda_codec *codec)

3620

static void alc_headset_mode_ctia(struct hda_codec *codec)

3621

{

3621

{

3622

switch (codec->vendor_id) {

3622

switch (codec->vendor_id) {

3623

case 0x10ec0255:

3623

case 0x10ec0255:

3624

/* Set to CTIA type */

3624

/* Set to CTIA type */

3625

alc_write_coef_idx(codec, 0x45, 0xd489);

3625

alc_write_coef_idx(codec, 0x45, 0xd489);

3626

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3626

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3627

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3627

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3628

break;

3628

break;

3629

case 0x10ec0283:

3629

case 0x10ec0283:

3630

alc_write_coef_idx(codec, 0x45, 0xd429);

3630

alc_write_coef_idx(codec, 0x45, 0xd429);

3631

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3631

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3632

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3632

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3633

break;

3633

break;

3634

case 0x10ec0292:

3634

case 0x10ec0292:

3635

alc_write_coef_idx(codec, 0x6b, 0xd429);

3635

alc_write_coef_idx(codec, 0x6b, 0xd429);

3636

alc_write_coef_idx(codec, 0x76, 0x0008);

3636

alc_write_coef_idx(codec, 0x76, 0x0008);

3637

alc_write_coef_idx(codec, 0x18, 0x7388);

3637

alc_write_coef_idx(codec, 0x18, 0x7388);

3638

break;

3638

break;

3639

case 0x10ec0668:

3639

case 0x10ec0668:

3640

alc_write_coef_idx(codec, 0x11, 0x0001);

3640

alc_write_coef_idx(codec, 0x11, 0x0001);

3641

alc_write_coef_idx(codec, 0x15, 0x0d60);

3641

alc_write_coef_idx(codec, 0x15, 0x0d60);

3642

alc_write_coef_idx(codec, 0xc3, 0x0000);

3642

alc_write_coef_idx(codec, 0xc3, 0x0000);

3643

break;

3643

break;

3644

}

3644

}

3645

codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");

3645

codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");

3646

}

3646

}

3647

3648

/* Nokia type */

3648

/* Nokia type */

3649

static void alc_headset_mode_omtp(struct hda_codec *codec)

3649

static void alc_headset_mode_omtp(struct hda_codec *codec)

3650

{

3650

{

3651

switch (codec->vendor_id) {

3651

switch (codec->vendor_id) {

3652

case 0x10ec0255:

3652

case 0x10ec0255:

3653

/* Set to OMTP Type */

3653

/* Set to OMTP Type */

3654

alc_write_coef_idx(codec, 0x45, 0xe489);

3654

alc_write_coef_idx(codec, 0x45, 0xe489);

3655

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3655

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3656

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3656

alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);

3657

break;

3657

break;

3658

case 0x10ec0283:

3658

case 0x10ec0283:

3659

alc_write_coef_idx(codec, 0x45, 0xe429);

3659

alc_write_coef_idx(codec, 0x45, 0xe429);

3660

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3660

alc_write_coef_idx(codec, 0x1b, 0x0c2b);

3661

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3661

alc_write_coef_idx(codec, 0x32, 0x4ea3);

3662

break;

3662

break;

3663

case 0x10ec0292:

3663

case 0x10ec0292:

3664

alc_write_coef_idx(codec, 0x6b, 0xe429);

3664

alc_write_coef_idx(codec, 0x6b, 0xe429);

3665

alc_write_coef_idx(codec, 0x76, 0x0008);

3665

alc_write_coef_idx(codec, 0x76, 0x0008);

3666

alc_write_coef_idx(codec, 0x18, 0x7388);

3666

alc_write_coef_idx(codec, 0x18, 0x7388);

3667

break;

3667

break;

3668

case 0x10ec0668:

3668

case 0x10ec0668:

3669

alc_write_coef_idx(codec, 0x11, 0x0001);

3669

alc_write_coef_idx(codec, 0x11, 0x0001);

3670

alc_write_coef_idx(codec, 0x15, 0x0d50);

3670

alc_write_coef_idx(codec, 0x15, 0x0d50);

3671

alc_write_coef_idx(codec, 0xc3, 0x0000);

3671

alc_write_coef_idx(codec, 0xc3, 0x0000);

3672

break;

3672

break;

3673

}

3673

}

3674

codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");

3674

codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");

3675

}

3675

}

3676

3677

static void alc_determine_headset_type(struct hda_codec *codec)

3677

static void alc_determine_headset_type(struct hda_codec *codec)

3678

{

3678

{

3679

int val;

3679

int val;

3680

bool is_ctia = false;

3680

bool is_ctia = false;

3681

struct alc_spec *spec = codec->spec;

3681

struct alc_spec *spec = codec->spec;

3682

3683

switch (codec->vendor_id) {

3683

switch (codec->vendor_id) {

3684

case 0x10ec0255:

3684

case 0x10ec0255:

3685

/* combo jack auto switch control(Check type)*/

3685

/* combo jack auto switch control(Check type)*/

3686

alc_write_coef_idx(codec, 0x45, 0xd089);

3686

alc_write_coef_idx(codec, 0x45, 0xd089);

3687

/* combo jack auto switch control(Vref conteol) */

3687

/* combo jack auto switch control(Vref conteol) */

3688

alc_write_coef_idx(codec, 0x49, 0x0149);

3688

alc_write_coef_idx(codec, 0x49, 0x0149);

3689

msleep(300);

3689

msleep(300);

3690

val = alc_read_coef_idx(codec, 0x46);

3690

val = alc_read_coef_idx(codec, 0x46);

3691

is_ctia = (val & 0x0070) == 0x0070;

3691

is_ctia = (val & 0x0070) == 0x0070;

3692

break;

3692

break;

3693

case 0x10ec0283:

3693

case 0x10ec0283:

3694

alc_write_coef_idx(codec, 0x45, 0xd029);

3694

alc_write_coef_idx(codec, 0x45, 0xd029);

3695

msleep(300);

3695

msleep(300);

3696

val = alc_read_coef_idx(codec, 0x46);

3696

val = alc_read_coef_idx(codec, 0x46);

3697

is_ctia = (val & 0x0070) == 0x0070;

3697

is_ctia = (val & 0x0070) == 0x0070;

3698

break;

3698

break;

3699

case 0x10ec0292:

3699

case 0x10ec0292:

3700

alc_write_coef_idx(codec, 0x6b, 0xd429);

3700

alc_write_coef_idx(codec, 0x6b, 0xd429);

3701

msleep(300);

3701

msleep(300);

3702

val = alc_read_coef_idx(codec, 0x6c);

3702

val = alc_read_coef_idx(codec, 0x6c);

3703

is_ctia = (val & 0x001c) == 0x001c;

3703

is_ctia = (val & 0x001c) == 0x001c;

3704

break;

3704

break;

3705

case 0x10ec0668:

3705

case 0x10ec0668:

3706

alc_write_coef_idx(codec, 0x11, 0x0001);

3706

alc_write_coef_idx(codec, 0x11, 0x0001);

3707

alc_write_coef_idx(codec, 0xb7, 0x802b);

3707

alc_write_coef_idx(codec, 0xb7, 0x802b);

3708

alc_write_coef_idx(codec, 0x15, 0x0d60);

3708

alc_write_coef_idx(codec, 0x15, 0x0d60);

3709

alc_write_coef_idx(codec, 0xc3, 0x0c00);

3709

alc_write_coef_idx(codec, 0xc3, 0x0c00);

3710

msleep(300);

3710

msleep(300);

3711

val = alc_read_coef_idx(codec, 0xbe);

3711

val = alc_read_coef_idx(codec, 0xbe);

3712

is_ctia = (val & 0x1c02) == 0x1c02;

3712

is_ctia = (val & 0x1c02) == 0x1c02;

3713

break;

3713

break;

3714

}

3714

}

3715

3716

codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",

3716

codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",

3717

is_ctia ? "yes" : "no");

3717

is_ctia ? "yes" : "no");

3718

spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;

3718

spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;

3719

}

3719

}

3720

3721

static void alc_update_headset_mode(struct hda_codec *codec)

3721

static void alc_update_headset_mode(struct hda_codec *codec)

3722

{

3722

{

3723

struct alc_spec *spec = codec->spec;

3723

struct alc_spec *spec = codec->spec;

3724

3725

hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];

3725

hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];

3726

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3726

hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];

3727

3728

int new_headset_mode;

3728

int new_headset_mode;

3729

3730

if (!snd_hda_jack_detect(codec, hp_pin))

3730

if (!snd_hda_jack_detect(codec, hp_pin))

3731

new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;

3731

new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;

3732

else if (mux_pin == spec->headset_mic_pin)

3732

else if (mux_pin == spec->headset_mic_pin)

3733

new_headset_mode = ALC_HEADSET_MODE_HEADSET;

3733

new_headset_mode = ALC_HEADSET_MODE_HEADSET;

3734

else if (mux_pin == spec->headphone_mic_pin)

3734

else if (mux_pin == spec->headphone_mic_pin)

3735

new_headset_mode = ALC_HEADSET_MODE_MIC;

3735

new_headset_mode = ALC_HEADSET_MODE_MIC;

3736

else

3736

else

3737

new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;

3737

new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;

3738

3739

if (new_headset_mode == spec->current_headset_mode) {

3739

if (new_headset_mode == spec->current_headset_mode) {

3740

snd_hda_gen_update_outputs(codec);

3740

snd_hda_gen_update_outputs(codec);

3741

return;

3741

return;

3742

}

3742

}

3743

3744

switch (new_headset_mode) {

3744

switch (new_headset_mode) {

3745

case ALC_HEADSET_MODE_UNPLUGGED:

3745

case ALC_HEADSET_MODE_UNPLUGGED:

3746

alc_headset_mode_unplugged(codec);

3746

alc_headset_mode_unplugged(codec);

3747

spec->gen.hp_jack_present = false;

3747

spec->gen.hp_jack_present = false;

3748

break;

3748

break;

3749

case ALC_HEADSET_MODE_HEADSET:

3749

case ALC_HEADSET_MODE_HEADSET:

3750

if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)

3750

if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)

3751

alc_determine_headset_type(codec);

3751

alc_determine_headset_type(codec);

3752

if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)

3752

if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)

3753

alc_headset_mode_ctia(codec);

3753

alc_headset_mode_ctia(codec);

3754

else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)

3754

else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)

3755

alc_headset_mode_omtp(codec);

3755

alc_headset_mode_omtp(codec);

3756

spec->gen.hp_jack_present = true;

3756

spec->gen.hp_jack_present = true;

3757

break;

3757

break;

3758

case ALC_HEADSET_MODE_MIC:

3758

case ALC_HEADSET_MODE_MIC:

3759

alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);

3759

alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);

3760

spec->gen.hp_jack_present = false;

3760

spec->gen.hp_jack_present = false;

3761

break;

3761

break;

3762

case ALC_HEADSET_MODE_HEADPHONE:

3762

case ALC_HEADSET_MODE_HEADPHONE:

3763

alc_headset_mode_default(codec);

3763

alc_headset_mode_default(codec);

3764

spec->gen.hp_jack_present = true;

3764

spec->gen.hp_jack_present = true;

3765

break;

3765

break;

3766

}

3766

}

3767

if (new_headset_mode != ALC_HEADSET_MODE_MIC) {

3767

if (new_headset_mode != ALC_HEADSET_MODE_MIC) {

3768

snd_hda_set_pin_ctl_cache(codec, hp_pin,

3768

snd_hda_set_pin_ctl_cache(codec, hp_pin,

3769

AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);

3769

AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);

3770

if (spec->headphone_mic_pin)

3770

if (spec->headphone_mic_pin)

3771

snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,

3771

snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,

3772

PIN_VREFHIZ);

3772

PIN_VREFHIZ);

3773

}

3773

}

3774

spec->current_headset_mode = new_headset_mode;

3774

spec->current_headset_mode = new_headset_mode;

3775

3776

snd_hda_gen_update_outputs(codec);

3776

snd_hda_gen_update_outputs(codec);

3777

}

3777

}

3778

3779

static void alc_update_headset_mode_hook(struct hda_codec *codec,

3779

static void alc_update_headset_mode_hook(struct hda_codec *codec,

3780

struct snd_kcontrol *kcontrol,

3780

struct snd_kcontrol *kcontrol,

3781

struct snd_ctl_elem_value *ucontrol)

3781

struct snd_ctl_elem_value *ucontrol)

3782

{

3782

{

3783

alc_update_headset_mode(codec);

3783

alc_update_headset_mode(codec);

3784

}

3784

}

3785

3786

static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)

3786

static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)

3787

{

3787

{

3788

struct alc_spec *spec = codec->spec;

3788

struct alc_spec *spec = codec->spec;

3789

spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;

3789

spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;

3790

snd_hda_gen_hp_automute(codec, jack);

3790

snd_hda_gen_hp_automute(codec, jack);

3791

}

3791

}

3792

3793

static void alc_probe_headset_mode(struct hda_codec *codec)

3793

static void alc_probe_headset_mode(struct hda_codec *codec)

3794

{

3794

{

3795

int i;

3795

int i;

3796

struct alc_spec *spec = codec->spec;

3796

struct alc_spec *spec = codec->spec;

3797

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3797

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3798

3799

/* Find mic pins */

3799

/* Find mic pins */

3800

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

3800

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

3801

if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)

3801

if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)

3802

spec->headset_mic_pin = cfg->inputs[i].pin;

3802

spec->headset_mic_pin = cfg->inputs[i].pin;

3803

if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)

3803

if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)

3804

spec->headphone_mic_pin = cfg->inputs[i].pin;

3804

spec->headphone_mic_pin = cfg->inputs[i].pin;

3805

}

3805

}

3806

3807

spec->gen.cap_sync_hook = alc_update_headset_mode_hook;

3807

spec->gen.cap_sync_hook = alc_update_headset_mode_hook;

3808

spec->gen.automute_hook = alc_update_headset_mode;

3808

spec->gen.automute_hook = alc_update_headset_mode;

3809

spec->gen.hp_automute_hook = alc_update_headset_jack_cb;

3809

spec->gen.hp_automute_hook = alc_update_headset_jack_cb;

3810

}

3810

}

3811

3812

static void alc_fixup_headset_mode(struct hda_codec *codec,

3812

static void alc_fixup_headset_mode(struct hda_codec *codec,

3813

const struct hda_fixup *fix, int action)

3813

const struct hda_fixup *fix, int action)

3814

{

3814

{

3815

struct alc_spec *spec = codec->spec;

3815

struct alc_spec *spec = codec->spec;

3816

3817

switch (action) {

3817

switch (action) {

3818

case HDA_FIXUP_ACT_PRE_PROBE:

3818

case HDA_FIXUP_ACT_PRE_PROBE:

3819

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;

3819

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;

3820

break;

3820

break;

3821

case HDA_FIXUP_ACT_PROBE:

3821

case HDA_FIXUP_ACT_PROBE:

3822

alc_probe_headset_mode(codec);

3822

alc_probe_headset_mode(codec);

3823

break;

3823

break;

3824

case HDA_FIXUP_ACT_INIT:

3824

case HDA_FIXUP_ACT_INIT:

3825

spec->current_headset_mode = 0;

3825

spec->current_headset_mode = 0;

3826

alc_update_headset_mode(codec);

3826

alc_update_headset_mode(codec);

3827

break;

3827

break;

3828

}

3828

}

3829

}

3829

}

3830

3831

static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,

3831

static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,

3832

const struct hda_fixup *fix, int action)

3832

const struct hda_fixup *fix, int action)

3833

{

3833

{

3834

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3834

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3835

struct alc_spec *spec = codec->spec;

3835

struct alc_spec *spec = codec->spec;

3836

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3836

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3837

}

3837

}

3838

else

3838

else

3839

alc_fixup_headset_mode(codec, fix, action);

3839

alc_fixup_headset_mode(codec, fix, action);

3840

}

3840

}

3841

3842

static void alc255_set_default_jack_type(struct hda_codec *codec)

3842

static void alc255_set_default_jack_type(struct hda_codec *codec)

3843

{

3843

{

3844

/* Set to iphone type */

3844

/* Set to iphone type */

3845

alc_write_coef_idx(codec, 0x1b, 0x880b);

3845

alc_write_coef_idx(codec, 0x1b, 0x880b);

3846

alc_write_coef_idx(codec, 0x45, 0xd089);

3846

alc_write_coef_idx(codec, 0x45, 0xd089);

3847

alc_write_coef_idx(codec, 0x1b, 0x080b);

3847

alc_write_coef_idx(codec, 0x1b, 0x080b);

3848

alc_write_coef_idx(codec, 0x46, 0x0004);

3848

alc_write_coef_idx(codec, 0x46, 0x0004);

3849

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3849

alc_write_coef_idx(codec, 0x1b, 0x0c0b);

3850

msleep(30);

3850

msleep(30);

3851

}

3851

}

3852

3853

static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,

3853

static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,

3854

const struct hda_fixup *fix, int action)

3854

const struct hda_fixup *fix, int action)

3855

{

3855

{

3856

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3856

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3857

alc255_set_default_jack_type(codec);

3857

alc255_set_default_jack_type(codec);

3858

}

3858

}

3859

alc_fixup_headset_mode(codec, fix, action);

3859

alc_fixup_headset_mode(codec, fix, action);

3860

}

3860

}

3861

3862

static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,

3862

static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,

3863

const struct hda_fixup *fix, int action)

3863

const struct hda_fixup *fix, int action)

3864

{

3864

{

3865

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3865

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3866

struct alc_spec *spec = codec->spec;

3866

struct alc_spec *spec = codec->spec;

3867

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3867

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3868

alc255_set_default_jack_type(codec);

3868

alc255_set_default_jack_type(codec);

3869

}

3869

}

3870

else

3870

else

3871

alc_fixup_headset_mode(codec, fix, action);

3871

alc_fixup_headset_mode(codec, fix, action);

3872

}

3872

}

3873

3874

static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,

3874

static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,

3875

const struct hda_fixup *fix, int action)

3875

const struct hda_fixup *fix, int action)

3876

{

3876

{

3877

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3877

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3878

struct alc_spec *spec = codec->spec;

3878

struct alc_spec *spec = codec->spec;

3879

spec->gen.auto_mute_via_amp = 1;

3879

spec->gen.auto_mute_via_amp = 1;

3880

}

3880

}

3881

}

3881

}

3882

3883

static void alc_no_shutup(struct hda_codec *codec)

3883

static void alc_no_shutup(struct hda_codec *codec)

3884

{

3884

{

3885

}

3885

}

3886

3887

static void alc_fixup_no_shutup(struct hda_codec *codec,

3887

static void alc_fixup_no_shutup(struct hda_codec *codec,

3888

const struct hda_fixup *fix, int action)

3888

const struct hda_fixup *fix, int action)

3889

{

3889

{

3890

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3890

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3891

struct alc_spec *spec = codec->spec;

3891

struct alc_spec *spec = codec->spec;

3892

spec->shutup = alc_no_shutup;

3892

spec->shutup = alc_no_shutup;

3893

}

3893

}

3894

}

3894

}

3895

3896

static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,

3896

static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,

3897

const struct hda_fixup *fix, int action)

3897

const struct hda_fixup *fix, int action)

3898

{

3898

{

3899

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3899

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3900

int val;

3900

int val;

3901

alc_write_coef_idx(codec, 0xc4, 0x8000);

3901

alc_write_coef_idx(codec, 0xc4, 0x8000);

3902

val = alc_read_coef_idx(codec, 0xc2);

3902

val = alc_read_coef_idx(codec, 0xc2);

3903

alc_write_coef_idx(codec, 0xc2, val & 0xfe);

3903

alc_write_coef_idx(codec, 0xc2, val & 0xfe);

3904

snd_hda_set_pin_ctl_cache(codec, 0x18, 0);

3904

snd_hda_set_pin_ctl_cache(codec, 0x18, 0);

3905

}

3905

}

3906

alc_fixup_headset_mode(codec, fix, action);

3906

alc_fixup_headset_mode(codec, fix, action);

3907

}

3907

}

3908

3909

/* Returns the nid of the external mic input pin, or 0 if it cannot be found. */

3909

/* Returns the nid of the external mic input pin, or 0 if it cannot be found. */

3910

static int find_ext_mic_pin(struct hda_codec *codec)

3910

static int find_ext_mic_pin(struct hda_codec *codec)

3911

{

3911

{

3912

struct alc_spec *spec = codec->spec;

3912

struct alc_spec *spec = codec->spec;

3913

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3913

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3914

hda_nid_t nid;

3914

hda_nid_t nid;

3915

unsigned int defcfg;

3915

unsigned int defcfg;

3916

int i;

3916

int i;

3917

3918

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

3918

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

3919

if (cfg->inputs[i].type != AUTO_PIN_MIC)

3919

if (cfg->inputs[i].type != AUTO_PIN_MIC)

3920

continue;

3920

continue;

3921

nid = cfg->inputs[i].pin;

3921

nid = cfg->inputs[i].pin;

3922

defcfg = snd_hda_codec_get_pincfg(codec, nid);

3922

defcfg = snd_hda_codec_get_pincfg(codec, nid);

3923

if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)

3923

if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)

3924

continue;

3924

continue;

3925

return nid;

3925

return nid;

3926

}

3926

}

3927

3928

return 0;

3928

return 0;

3929

}

3929

}

3930

3931

static void alc271_hp_gate_mic_jack(struct hda_codec *codec,

3931

static void alc271_hp_gate_mic_jack(struct hda_codec *codec,

3932

const struct hda_fixup *fix,

3932

const struct hda_fixup *fix,

3933

int action)

3933

int action)

3934

{

3934

{

3935

struct alc_spec *spec = codec->spec;

3935

struct alc_spec *spec = codec->spec;

3936

3937

if (action == HDA_FIXUP_ACT_PROBE) {

3937

if (action == HDA_FIXUP_ACT_PROBE) {

3938

int mic_pin = find_ext_mic_pin(codec);

3938

int mic_pin = find_ext_mic_pin(codec);

3939

int hp_pin = spec->gen.autocfg.hp_pins[0];

3939

int hp_pin = spec->gen.autocfg.hp_pins[0];

3940

3941

if (snd_BUG_ON(!mic_pin || !hp_pin))

3941

if (snd_BUG_ON(!mic_pin || !hp_pin))

3942

return;

3942

return;

3943

snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);

3943

snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);

3944

}

3944

}

3945

}

3945

}

3946

3947

static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,

3947

static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,

3948

const struct hda_fixup *fix,

3948

const struct hda_fixup *fix,

3949

int action)

3949

int action)

3950

{

3950

{

3951

struct alc_spec *spec = codec->spec;

3951

struct alc_spec *spec = codec->spec;

3952

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3952

struct auto_pin_cfg *cfg = &spec->gen.autocfg;

3953

int i;

3953

int i;

3954

3955

/* The mic boosts on level 2 and 3 are too noisy

3955

/* The mic boosts on level 2 and 3 are too noisy

3956

on the internal mic input.

3956

on the internal mic input.

3957

Therefore limit the boost to 0 or 1. */

3957

Therefore limit the boost to 0 or 1. */

3958

3959

if (action != HDA_FIXUP_ACT_PROBE)

3959

if (action != HDA_FIXUP_ACT_PROBE)

3960

return;

3960

return;

3961

3962

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

3962

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

3963

hda_nid_t nid = cfg->inputs[i].pin;

3963

hda_nid_t nid = cfg->inputs[i].pin;

3964

unsigned int defcfg;

3964

unsigned int defcfg;

3965

if (cfg->inputs[i].type != AUTO_PIN_MIC)

3965

if (cfg->inputs[i].type != AUTO_PIN_MIC)

3966

continue;

3966

continue;

3967

defcfg = snd_hda_codec_get_pincfg(codec, nid);

3967

defcfg = snd_hda_codec_get_pincfg(codec, nid);

3968

if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)

3968

if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)

3969

continue;

3969

continue;

3970

3971

snd_hda_override_amp_caps(codec, nid, HDA_INPUT,

3971

snd_hda_override_amp_caps(codec, nid, HDA_INPUT,

3972

(0x00 << AC_AMPCAP_OFFSET_SHIFT) |

3972

(0x00 << AC_AMPCAP_OFFSET_SHIFT) |

3973

(0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |

3973

(0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |

3974

(0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |

3974

(0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |

3975

(0 << AC_AMPCAP_MUTE_SHIFT));

3975

(0 << AC_AMPCAP_MUTE_SHIFT));

3976

}

3976

}

3977

}

3977

}

3978

3979

static void alc283_hp_automute_hook(struct hda_codec *codec,

3979

static void alc283_hp_automute_hook(struct hda_codec *codec,

3980

struct hda_jack_tbl *jack)

3980

struct hda_jack_tbl *jack)

3981

{

3981

{

3982

struct alc_spec *spec = codec->spec;

3982

struct alc_spec *spec = codec->spec;

3983

int vref;

3983

int vref;

3984

3985

msleep(200);

3985

msleep(200);

3986

snd_hda_gen_hp_automute(codec, jack);

3986

snd_hda_gen_hp_automute(codec, jack);

3987

3988

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3988

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3989

3990

msleep(600);

3990

msleep(600);

3991

snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3991

snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3992

vref);

3992

vref);

3993

}

3993

}

3994

3995

static void alc283_fixup_chromebook(struct hda_codec *codec,

3995

static void alc283_fixup_chromebook(struct hda_codec *codec,

3996

const struct hda_fixup *fix, int action)

3996

const struct hda_fixup *fix, int action)

3997

{

3997

{

3998

struct alc_spec *spec = codec->spec;

3998

struct alc_spec *spec = codec->spec;

3999

int val;

3999

int val;

4000

4001

switch (action) {

4001

switch (action) {

4002

case HDA_FIXUP_ACT_PRE_PROBE:

4002

case HDA_FIXUP_ACT_PRE_PROBE:

4003

snd_hda_override_wcaps(codec, 0x03, 0);

4003

snd_hda_override_wcaps(codec, 0x03, 0);

4004

/* Disable AA-loopback as it causes white noise */

4004

/* Disable AA-loopback as it causes white noise */

4005

spec->gen.mixer_nid = 0;

4005

spec->gen.mixer_nid = 0;

4006

break;

4006

break;

4007

case HDA_FIXUP_ACT_INIT:

4007

case HDA_FIXUP_ACT_INIT:

4008

/* MIC2-VREF control */

4009

/* Set to manual mode */

4010

val = alc_read_coef_idx(codec, 0x06);

4011

alc_write_coef_idx(codec, 0x06, val & ~0x000c);

4008

/* Enable Line1 input control by verb */

4012

/* Enable Line1 input control by verb */

4009

val = alc_read_coef_idx(codec, 0x1a);

4013

val = alc_read_coef_idx(codec, 0x1a);

4010

alc_write_coef_idx(codec, 0x1a, val | (1 << 4));

4014

alc_write_coef_idx(codec, 0x1a, val | (1 << 4));

4011

break;

4015

break;

4012

}

4016

}

4013

}

4017

}

4014

4018

4015

static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,

4019

static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,

4016

const struct hda_fixup *fix, int action)

4020

const struct hda_fixup *fix, int action)

4017

{

4021

{

4018

struct alc_spec *spec = codec->spec;

4022

struct alc_spec *spec = codec->spec;

4019

int val;

4023

int val;

4020

4024

4021

switch (action) {

4025

switch (action) {

4022

case HDA_FIXUP_ACT_PRE_PROBE:

4026

case HDA_FIXUP_ACT_PRE_PROBE:

4023

spec->gen.hp_automute_hook = alc283_hp_automute_hook;

4027

spec->gen.hp_automute_hook = alc283_hp_automute_hook;

4024

break;

4028

break;

4025

case HDA_FIXUP_ACT_INIT:

4029

case HDA_FIXUP_ACT_INIT:

4026

/* MIC2-VREF control */

4030

/* MIC2-VREF control */

4027

/* Set to manual mode */

4031

/* Set to manual mode */

4028

val = alc_read_coef_idx(codec, 0x06);

4032

val = alc_read_coef_idx(codec, 0x06);

4029

alc_write_coef_idx(codec, 0x06, val & ~0x000c);

4033

alc_write_coef_idx(codec, 0x06, val & ~0x000c);

4030

break;

4034

break;

4031

}

4035

}

4032

}

4036

}

4033

4037

4034

/* mute tablet speaker pin (0x14) via dock plugging in addition */

4038

/* mute tablet speaker pin (0x14) via dock plugging in addition */

4035

static void asus_tx300_automute(struct hda_codec *codec)

4039

static void asus_tx300_automute(struct hda_codec *codec)

4036

{

4040

{

4037

struct alc_spec *spec = codec->spec;

4041

struct alc_spec *spec = codec->spec;

4038

snd_hda_gen_update_outputs(codec);

4042

snd_hda_gen_update_outputs(codec);

4039

if (snd_hda_jack_detect(codec, 0x1b))

4043

if (snd_hda_jack_detect(codec, 0x1b))

4040

spec->gen.mute_bits |= (1ULL << 0x14);

4044

spec->gen.mute_bits |= (1ULL << 0x14);

4041

}

4045

}

4042

4046

4043

static void alc282_fixup_asus_tx300(struct hda_codec *codec,

4047

static void alc282_fixup_asus_tx300(struct hda_codec *codec,

4044

const struct hda_fixup *fix, int action)

4048

const struct hda_fixup *fix, int action)

4045

{

4049

{

4046

struct alc_spec *spec = codec->spec;

4050

struct alc_spec *spec = codec->spec;

4047

/* TX300 needs to set up GPIO2 for the speaker amp */

4051

/* TX300 needs to set up GPIO2 for the speaker amp */

4048

static const struct hda_verb gpio2_verbs[] = {

4052

static const struct hda_verb gpio2_verbs[] = {

4049

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

4053

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

4050

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

4054

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

4051

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },

4055

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },

4052

{}

4056

{}

4053

};

4057

};

4054

static const struct hda_pintbl dock_pins[] = {

4058

static const struct hda_pintbl dock_pins[] = {

4055

{ 0x1b, 0x21114000 }, /* dock speaker pin */

4059

{ 0x1b, 0x21114000 }, /* dock speaker pin */

4056

{}

4060

{}

4057

};

4061

};

4058

struct snd_kcontrol *kctl;

4062

struct snd_kcontrol *kctl;

4059

4063

4060

switch (action) {

4064

switch (action) {

4061

case HDA_FIXUP_ACT_PRE_PROBE:

4065

case HDA_FIXUP_ACT_PRE_PROBE:

4062

snd_hda_add_verbs(codec, gpio2_verbs);

4066

snd_hda_add_verbs(codec, gpio2_verbs);

4063

snd_hda_apply_pincfgs(codec, dock_pins);

4067

snd_hda_apply_pincfgs(codec, dock_pins);

4064

spec->gen.auto_mute_via_amp = 1;

4068

spec->gen.auto_mute_via_amp = 1;

4065

spec->gen.automute_hook = asus_tx300_automute;

4069

spec->gen.automute_hook = asus_tx300_automute;

4066

snd_hda_jack_detect_enable_callback(codec, 0x1b,

4070

snd_hda_jack_detect_enable_callback(codec, 0x1b,

4067

HDA_GEN_HP_EVENT,

4071

HDA_GEN_HP_EVENT,

4068

snd_hda_gen_hp_automute);

4072

snd_hda_gen_hp_automute);

4069

break;

4073

break;

4070

case HDA_FIXUP_ACT_BUILD:

4074

case HDA_FIXUP_ACT_BUILD:

4071

/* this is a bit tricky; give more sane names for the main

4075

/* this is a bit tricky; give more sane names for the main

4072

* (tablet) speaker and the dock speaker, respectively

4076

* (tablet) speaker and the dock speaker, respectively

4073

*/

4077

*/

4074

kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");

4078

kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");

4075

if (kctl)

4079

if (kctl)

4076

strcpy(kctl->id.name, "Dock Speaker Playback Switch");

4080

strcpy(kctl->id.name, "Dock Speaker Playback Switch");

4077

kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");

4081

kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");

4078

if (kctl)

4082

if (kctl)

4079

strcpy(kctl->id.name, "Speaker Playback Switch");

4083

strcpy(kctl->id.name, "Speaker Playback Switch");

4080

break;

4084

break;

4081

}

4085

}

4082

}

4086

}

4083

4087

4084

static void alc290_fixup_mono_speakers(struct hda_codec *codec,

4088

static void alc290_fixup_mono_speakers(struct hda_codec *codec,

4085

const struct hda_fixup *fix, int action)

4089

const struct hda_fixup *fix, int action)

4086

{

4090

{

4087

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4091

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4088

/* DAC node 0x03 is giving mono output. We therefore want to

4092

/* DAC node 0x03 is giving mono output. We therefore want to

4089

make sure 0x14 (front speaker) and 0x15 (headphones) use the

4093

make sure 0x14 (front speaker) and 0x15 (headphones) use the

4090

stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */

4094

stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */

4091

hda_nid_t conn1[2] = { 0x0c };

4095

hda_nid_t conn1[2] = { 0x0c };

4092

snd_hda_override_conn_list(codec, 0x14, 1, conn1);

4096

snd_hda_override_conn_list(codec, 0x14, 1, conn1);

4093

snd_hda_override_conn_list(codec, 0x15, 1, conn1);

4097

snd_hda_override_conn_list(codec, 0x15, 1, conn1);

4094

}

4098

}

4095

}

4099

}

4096

4100

4097

/* for hda_fixup_thinkpad_acpi() */

4101

/* for hda_fixup_thinkpad_acpi() */

4098

#include "thinkpad_helper.c"

4102

#include "thinkpad_helper.c"

4099

4103

4100

enum {

4104

enum {

4101

ALC269_FIXUP_SONY_VAIO,

4105

ALC269_FIXUP_SONY_VAIO,

4102

ALC275_FIXUP_SONY_VAIO_GPIO2,

4106

ALC275_FIXUP_SONY_VAIO_GPIO2,

4103

ALC269_FIXUP_DELL_M101Z,

4107

ALC269_FIXUP_DELL_M101Z,

4104

ALC269_FIXUP_SKU_IGNORE,

4108

ALC269_FIXUP_SKU_IGNORE,

4105

ALC269_FIXUP_ASUS_G73JW,

4109

ALC269_FIXUP_ASUS_G73JW,

4106

ALC269_FIXUP_LENOVO_EAPD,

4110

ALC269_FIXUP_LENOVO_EAPD,

4107

ALC275_FIXUP_SONY_HWEQ,

4111

ALC275_FIXUP_SONY_HWEQ,

4108

ALC271_FIXUP_DMIC,

4112

ALC271_FIXUP_DMIC,

4109

ALC269_FIXUP_PCM_44K,

4113

ALC269_FIXUP_PCM_44K,

4110

ALC269_FIXUP_STEREO_DMIC,

4114

ALC269_FIXUP_STEREO_DMIC,

4111

ALC269_FIXUP_HEADSET_MIC,

4115

ALC269_FIXUP_HEADSET_MIC,

4112

ALC269_FIXUP_QUANTA_MUTE,

4116

ALC269_FIXUP_QUANTA_MUTE,

4113

ALC269_FIXUP_LIFEBOOK,

4117

ALC269_FIXUP_LIFEBOOK,

4114

ALC269_FIXUP_AMIC,

4118

ALC269_FIXUP_AMIC,

4115

ALC269_FIXUP_DMIC,

4119

ALC269_FIXUP_DMIC,

4116

ALC269VB_FIXUP_AMIC,

4120

ALC269VB_FIXUP_AMIC,

4117

ALC269VB_FIXUP_DMIC,

4121

ALC269VB_FIXUP_DMIC,

4118

ALC269_FIXUP_HP_MUTE_LED,

4122

ALC269_FIXUP_HP_MUTE_LED,

4119

ALC269_FIXUP_HP_MUTE_LED_MIC1,

4123

ALC269_FIXUP_HP_MUTE_LED_MIC1,

4120

ALC269_FIXUP_HP_MUTE_LED_MIC2,

4124

ALC269_FIXUP_HP_MUTE_LED_MIC2,

4121

ALC269_FIXUP_HP_GPIO_LED,

4125

ALC269_FIXUP_HP_GPIO_LED,

4122

ALC269_FIXUP_INV_DMIC,

4126

ALC269_FIXUP_INV_DMIC,

4123

ALC269_FIXUP_LENOVO_DOCK,

4127

ALC269_FIXUP_LENOVO_DOCK,

4124

ALC269_FIXUP_NO_SHUTUP,

4128

ALC269_FIXUP_NO_SHUTUP,

4125

ALC286_FIXUP_SONY_MIC_NO_PRESENCE,

4129

ALC286_FIXUP_SONY_MIC_NO_PRESENCE,

4126

ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,

4130

ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,

4127

ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

4131

ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

4128

ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

4132

ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

4129

ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4133

ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4130

ALC269_FIXUP_HEADSET_MODE,

4134

ALC269_FIXUP_HEADSET_MODE,

4131

ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,

4135

ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,

4132

ALC269_FIXUP_ASUS_X101_FUNC,

4136

ALC269_FIXUP_ASUS_X101_FUNC,

4133

ALC269_FIXUP_ASUS_X101_VERB,

4137

ALC269_FIXUP_ASUS_X101_VERB,

4134

ALC269_FIXUP_ASUS_X101,

4138

ALC269_FIXUP_ASUS_X101,

4135

ALC271_FIXUP_AMIC_MIC2,

4139

ALC271_FIXUP_AMIC_MIC2,

4136

ALC271_FIXUP_HP_GATE_MIC_JACK,

4140

ALC271_FIXUP_HP_GATE_MIC_JACK,

4137

ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,

4141

ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,

4138

ALC269_FIXUP_ACER_AC700,

4142

ALC269_FIXUP_ACER_AC700,

4139

ALC269_FIXUP_LIMIT_INT_MIC_BOOST,

4143

ALC269_FIXUP_LIMIT_INT_MIC_BOOST,

4140

ALC269VB_FIXUP_ASUS_ZENBOOK,

4144

ALC269VB_FIXUP_ASUS_ZENBOOK,

4141

ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,

4145

ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,

4142

ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,

4146

ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,

4143

ALC269VB_FIXUP_ORDISSIMO_EVE2,

4147

ALC269VB_FIXUP_ORDISSIMO_EVE2,

4144

ALC283_FIXUP_CHROME_BOOK,

4148

ALC283_FIXUP_CHROME_BOOK,

4145

ALC283_FIXUP_SENSE_COMBO_JACK,

4149

ALC283_FIXUP_SENSE_COMBO_JACK,

4146

ALC282_FIXUP_ASUS_TX300,

4150

ALC282_FIXUP_ASUS_TX300,

4147

ALC283_FIXUP_INT_MIC,

4151

ALC283_FIXUP_INT_MIC,

4148

ALC290_FIXUP_MONO_SPEAKERS,

4152

ALC290_FIXUP_MONO_SPEAKERS,

4149

ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4153

ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4150

ALC290_FIXUP_SUBWOOFER,

4154

ALC290_FIXUP_SUBWOOFER,

4151

ALC290_FIXUP_SUBWOOFER_HSJACK,

4155

ALC290_FIXUP_SUBWOOFER_HSJACK,

4152

ALC269_FIXUP_THINKPAD_ACPI,

4156

ALC269_FIXUP_THINKPAD_ACPI,

4153

ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

4157

ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

4154

ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

4158

ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

4155

ALC255_FIXUP_HEADSET_MODE,

4159

ALC255_FIXUP_HEADSET_MODE,

4156

ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,

4160

ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,

4157

};

4161

};

4158

4162

4159

static const struct hda_fixup alc269_fixups[] = {

4163

static const struct hda_fixup alc269_fixups[] = {

4160

[ALC269_FIXUP_SONY_VAIO] = {

4164

[ALC269_FIXUP_SONY_VAIO] = {

4161

.type = HDA_FIXUP_PINCTLS,

4165

.type = HDA_FIXUP_PINCTLS,

4162

.v.pins = (const struct hda_pintbl[]) {

4166

.v.pins = (const struct hda_pintbl[]) {

4163

{0x19, PIN_VREFGRD},

4167

{0x19, PIN_VREFGRD},

4164

{}

4168

{}

4165

}

4169

}

4166

},

4170

},

4167

[ALC275_FIXUP_SONY_VAIO_GPIO2] = {

4171

[ALC275_FIXUP_SONY_VAIO_GPIO2] = {

4168

.type = HDA_FIXUP_VERBS,

4172

.type = HDA_FIXUP_VERBS,

4169

.v.verbs = (const struct hda_verb[]) {

4173

.v.verbs = (const struct hda_verb[]) {

4170

{0x01, AC_VERB_SET_GPIO_MASK, 0x04},

4174

{0x01, AC_VERB_SET_GPIO_MASK, 0x04},

4171

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},

4175

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},

4172

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

4176

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

4173

{ }

4177

{ }

4174

},

4178

},

4175

.chained = true,

4179

.chained = true,

4176

.chain_id = ALC269_FIXUP_SONY_VAIO

4180

.chain_id = ALC269_FIXUP_SONY_VAIO

4177

},

4181

},

4178

[ALC269_FIXUP_DELL_M101Z] = {

4182

[ALC269_FIXUP_DELL_M101Z] = {

4179

.type = HDA_FIXUP_VERBS,

4183

.type = HDA_FIXUP_VERBS,

4180

.v.verbs = (const struct hda_verb[]) {

4184

.v.verbs = (const struct hda_verb[]) {

4181

/* Enables internal speaker */

4185

/* Enables internal speaker */

4182

{0x20, AC_VERB_SET_COEF_INDEX, 13},

4186

{0x20, AC_VERB_SET_COEF_INDEX, 13},

4183

{0x20, AC_VERB_SET_PROC_COEF, 0x4040},

4187

{0x20, AC_VERB_SET_PROC_COEF, 0x4040},

4184

{}

4188

{}

4185

}

4189

}

4186

},

4190

},

4187

[ALC269_FIXUP_SKU_IGNORE] = {

4191

[ALC269_FIXUP_SKU_IGNORE] = {

4188

.type = HDA_FIXUP_FUNC,

4192

.type = HDA_FIXUP_FUNC,

4189

.v.func = alc_fixup_sku_ignore,

4193

.v.func = alc_fixup_sku_ignore,

4190

},

4194

},

4191

[ALC269_FIXUP_ASUS_G73JW] = {

4195

[ALC269_FIXUP_ASUS_G73JW] = {

4192

.type = HDA_FIXUP_PINS,

4196

.type = HDA_FIXUP_PINS,

4193

.v.pins = (const struct hda_pintbl[]) {

4197

.v.pins = (const struct hda_pintbl[]) {

4194

{ 0x17, 0x99130111 }, /* subwoofer */

4198

{ 0x17, 0x99130111 }, /* subwoofer */

4195

{ }

4199

{ }

4196

}

4200

}

4197

},

4201

},

4198

[ALC269_FIXUP_LENOVO_EAPD] = {

4202

[ALC269_FIXUP_LENOVO_EAPD] = {

4199

.type = HDA_FIXUP_VERBS,

4203

.type = HDA_FIXUP_VERBS,

4200

.v.verbs = (const struct hda_verb[]) {

4204

.v.verbs = (const struct hda_verb[]) {

4201

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

4205

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

4202

{}

4206

{}

4203

}

4207

}

4204

},

4208

},

4205

[ALC275_FIXUP_SONY_HWEQ] = {

4209

[ALC275_FIXUP_SONY_HWEQ] = {

4206

.type = HDA_FIXUP_FUNC,

4210

.type = HDA_FIXUP_FUNC,

4207

.v.func = alc269_fixup_hweq,

4211

.v.func = alc269_fixup_hweq,

4208

.chained = true,

4212

.chained = true,

4209

.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2

4213

.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2

4210

},

4214

},

4211

[ALC271_FIXUP_DMIC] = {

4215

[ALC271_FIXUP_DMIC] = {

4212

.type = HDA_FIXUP_FUNC,

4216

.type = HDA_FIXUP_FUNC,

4213

.v.func = alc271_fixup_dmic,

4217

.v.func = alc271_fixup_dmic,

4214

},

4218

},

4215

[ALC269_FIXUP_PCM_44K] = {

4219

[ALC269_FIXUP_PCM_44K] = {

4216

.type = HDA_FIXUP_FUNC,

4220

.type = HDA_FIXUP_FUNC,

4217

.v.func = alc269_fixup_pcm_44k,

4221

.v.func = alc269_fixup_pcm_44k,

4218

.chained = true,

4222

.chained = true,

4219

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4223

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4220

},

4224

},

4221

[ALC269_FIXUP_STEREO_DMIC] = {

4225

[ALC269_FIXUP_STEREO_DMIC] = {

4222

.type = HDA_FIXUP_FUNC,

4226

.type = HDA_FIXUP_FUNC,

4223

.v.func = alc269_fixup_stereo_dmic,

4227

.v.func = alc269_fixup_stereo_dmic,

4224

},

4228

},

4225

[ALC269_FIXUP_HEADSET_MIC] = {

4229

[ALC269_FIXUP_HEADSET_MIC] = {

4226

.type = HDA_FIXUP_FUNC,

4230

.type = HDA_FIXUP_FUNC,

4227

.v.func = alc269_fixup_headset_mic,

4231

.v.func = alc269_fixup_headset_mic,

4228

},

4232

},

4229

[ALC269_FIXUP_QUANTA_MUTE] = {

4233

[ALC269_FIXUP_QUANTA_MUTE] = {

4230

.type = HDA_FIXUP_FUNC,

4234

.type = HDA_FIXUP_FUNC,

4231

.v.func = alc269_fixup_quanta_mute,

4235

.v.func = alc269_fixup_quanta_mute,

4232

},

4236

},

4233

[ALC269_FIXUP_LIFEBOOK] = {

4237

[ALC269_FIXUP_LIFEBOOK] = {

4234

.type = HDA_FIXUP_PINS,

4238

.type = HDA_FIXUP_PINS,

4235

.v.pins = (const struct hda_pintbl[]) {

4239

.v.pins = (const struct hda_pintbl[]) {

4236

{ 0x1a, 0x2101103f }, /* dock line-out */

4240

{ 0x1a, 0x2101103f }, /* dock line-out */

4237

{ 0x1b, 0x23a11040 }, /* dock mic-in */

4241

{ 0x1b, 0x23a11040 }, /* dock mic-in */

4238

{ }

4242

{ }

4239

},

4243

},

4240

.chained = true,

4244

.chained = true,

4241

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4245

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4242

},

4246

},

4243

[ALC269_FIXUP_AMIC] = {

4247

[ALC269_FIXUP_AMIC] = {

4244

.type = HDA_FIXUP_PINS,

4248

.type = HDA_FIXUP_PINS,

4245

.v.pins = (const struct hda_pintbl[]) {

4249

.v.pins = (const struct hda_pintbl[]) {

4246

{ 0x14, 0x99130110 }, /* speaker */

4250

{ 0x14, 0x99130110 }, /* speaker */

4247

{ 0x15, 0x0121401f }, /* HP out */

4251

{ 0x15, 0x0121401f }, /* HP out */

4248

{ 0x18, 0x01a19c20 }, /* mic */

4252

{ 0x18, 0x01a19c20 }, /* mic */

4249

{ 0x19, 0x99a3092f }, /* int-mic */

4253

{ 0x19, 0x99a3092f }, /* int-mic */

4250

{ }

4254

{ }

4251

},

4255

},

4252

},

4256

},

4253

[ALC269_FIXUP_DMIC] = {

4257

[ALC269_FIXUP_DMIC] = {

4254

.type = HDA_FIXUP_PINS,

4258

.type = HDA_FIXUP_PINS,

4255

.v.pins = (const struct hda_pintbl[]) {

4259

.v.pins = (const struct hda_pintbl[]) {

4256

{ 0x12, 0x99a3092f }, /* int-mic */

4260

{ 0x12, 0x99a3092f }, /* int-mic */

4257

{ 0x14, 0x99130110 }, /* speaker */

4261

{ 0x14, 0x99130110 }, /* speaker */

4258

{ 0x15, 0x0121401f }, /* HP out */

4262

{ 0x15, 0x0121401f }, /* HP out */

4259

{ 0x18, 0x01a19c20 }, /* mic */

4263

{ 0x18, 0x01a19c20 }, /* mic */

4260

{ }

4264

{ }

4261

},

4265

},

4262

},

4266

},

4263

[ALC269VB_FIXUP_AMIC] = {

4267

[ALC269VB_FIXUP_AMIC] = {

4264

.type = HDA_FIXUP_PINS,

4268

.type = HDA_FIXUP_PINS,

4265

.v.pins = (const struct hda_pintbl[]) {

4269

.v.pins = (const struct hda_pintbl[]) {

4266

{ 0x14, 0x99130110 }, /* speaker */

4270

{ 0x14, 0x99130110 }, /* speaker */

4267

{ 0x18, 0x01a19c20 }, /* mic */

4271

{ 0x18, 0x01a19c20 }, /* mic */

4268

{ 0x19, 0x99a3092f }, /* int-mic */

4272

{ 0x19, 0x99a3092f }, /* int-mic */

4269

{ 0x21, 0x0121401f }, /* HP out */

4273

{ 0x21, 0x0121401f }, /* HP out */

4270

{ }

4274

{ }

4271

},

4275

},

4272

},

4276

},

4273

[ALC269VB_FIXUP_DMIC] = {

4277

[ALC269VB_FIXUP_DMIC] = {

4274

.type = HDA_FIXUP_PINS,

4278

.type = HDA_FIXUP_PINS,

4275

.v.pins = (const struct hda_pintbl[]) {

4279

.v.pins = (const struct hda_pintbl[]) {

4276

{ 0x12, 0x99a3092f }, /* int-mic */

4280

{ 0x12, 0x99a3092f }, /* int-mic */

4277

{ 0x14, 0x99130110 }, /* speaker */

4281

{ 0x14, 0x99130110 }, /* speaker */

4278

{ 0x18, 0x01a19c20 }, /* mic */

4282

{ 0x18, 0x01a19c20 }, /* mic */

4279

{ 0x21, 0x0121401f }, /* HP out */

4283

{ 0x21, 0x0121401f }, /* HP out */

4280

{ }

4284

{ }

4281

},

4285

},

4282

},

4286

},

4283

[ALC269_FIXUP_HP_MUTE_LED] = {

4287

[ALC269_FIXUP_HP_MUTE_LED] = {

4284

.type = HDA_FIXUP_FUNC,

4288

.type = HDA_FIXUP_FUNC,

4285

.v.func = alc269_fixup_hp_mute_led,

4289

.v.func = alc269_fixup_hp_mute_led,

4286

},

4290

},

4287

[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {

4291

[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {

4288

.type = HDA_FIXUP_FUNC,

4292

.type = HDA_FIXUP_FUNC,

4289

.v.func = alc269_fixup_hp_mute_led_mic1,

4293

.v.func = alc269_fixup_hp_mute_led_mic1,

4290

},

4294

},

4291

[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {

4295

[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {

4292

.type = HDA_FIXUP_FUNC,

4296

.type = HDA_FIXUP_FUNC,

4293

.v.func = alc269_fixup_hp_mute_led_mic2,

4297

.v.func = alc269_fixup_hp_mute_led_mic2,

4294

},

4298

},

4295

[ALC269_FIXUP_HP_GPIO_LED] = {

4299

[ALC269_FIXUP_HP_GPIO_LED] = {

4296

.type = HDA_FIXUP_FUNC,

4300

.type = HDA_FIXUP_FUNC,

4297

.v.func = alc269_fixup_hp_gpio_led,

4301

.v.func = alc269_fixup_hp_gpio_led,

4298

},

4302

},

4299

[ALC269_FIXUP_INV_DMIC] = {

4303

[ALC269_FIXUP_INV_DMIC] = {

4300

.type = HDA_FIXUP_FUNC,

4304

.type = HDA_FIXUP_FUNC,

4301

.v.func = alc_fixup_inv_dmic_0x12,

4305

.v.func = alc_fixup_inv_dmic_0x12,

4302

},

4306

},

4303

[ALC269_FIXUP_NO_SHUTUP] = {

4307

[ALC269_FIXUP_NO_SHUTUP] = {

4304

.type = HDA_FIXUP_FUNC,

4308

.type = HDA_FIXUP_FUNC,

4305

.v.func = alc_fixup_no_shutup,

4309

.v.func = alc_fixup_no_shutup,

4306

},

4310

},

4307

[ALC269_FIXUP_LENOVO_DOCK] = {

4311

[ALC269_FIXUP_LENOVO_DOCK] = {

4308

.type = HDA_FIXUP_PINS,

4312

.type = HDA_FIXUP_PINS,

4309

.v.pins = (const struct hda_pintbl[]) {

4313

.v.pins = (const struct hda_pintbl[]) {

4310

{ 0x19, 0x23a11040 }, /* dock mic */

4314

{ 0x19, 0x23a11040 }, /* dock mic */

4311

{ 0x1b, 0x2121103f }, /* dock headphone */

4315

{ 0x1b, 0x2121103f }, /* dock headphone */

4312

{ }

4316

{ }

4313

},

4317

},

4314

.chained = true,

4318

.chained = true,

4315

.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT

4319

.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT

4316

},

4320

},

4317

[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {

4321

[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {

4318

.type = HDA_FIXUP_FUNC,

4322

.type = HDA_FIXUP_FUNC,

4319

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4323

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4320

.chained = true,

4324

.chained = true,

4321

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4325

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4322

},

4326

},

4323

[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4327

[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4324

.type = HDA_FIXUP_PINS,

4328

.type = HDA_FIXUP_PINS,

4325

.v.pins = (const struct hda_pintbl[]) {

4329

.v.pins = (const struct hda_pintbl[]) {

4326

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4330

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4327

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4331

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4328

{ }

4332

{ }

4329

},

4333

},

4330

.chained = true,

4334

.chained = true,

4331

.chain_id = ALC269_FIXUP_HEADSET_MODE

4335

.chain_id = ALC269_FIXUP_HEADSET_MODE

4332

},

4336

},

4333

[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4337

[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4334

.type = HDA_FIXUP_PINS,

4338

.type = HDA_FIXUP_PINS,

4335

.v.pins = (const struct hda_pintbl[]) {

4339

.v.pins = (const struct hda_pintbl[]) {

4336

{ 0x16, 0x21014020 }, /* dock line out */

4340

{ 0x16, 0x21014020 }, /* dock line out */

4337

{ 0x19, 0x21a19030 }, /* dock mic */

4341

{ 0x19, 0x21a19030 }, /* dock mic */

4338

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4342

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4339

{ }

4343

{ }

4340

},

4344

},

4341

.chained = true,

4345

.chained = true,

4342

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4346

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4343

},

4347

},

4344

[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {

4348

[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {

4345

.type = HDA_FIXUP_PINS,

4349

.type = HDA_FIXUP_PINS,

4346

.v.pins = (const struct hda_pintbl[]) {

4350

.v.pins = (const struct hda_pintbl[]) {

4347

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4351

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4348

{ }

4352

{ }

4349

},

4353

},

4350

.chained = true,

4354

.chained = true,

4351

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4355

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4352

},

4356

},

4353

[ALC269_FIXUP_HEADSET_MODE] = {

4357

[ALC269_FIXUP_HEADSET_MODE] = {

4354

.type = HDA_FIXUP_FUNC,

4358

.type = HDA_FIXUP_FUNC,

4355

.v.func = alc_fixup_headset_mode,

4359

.v.func = alc_fixup_headset_mode,

4356

},

4360

},

4357

[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

4361

[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

4358

.type = HDA_FIXUP_FUNC,

4362

.type = HDA_FIXUP_FUNC,

4359

.v.func = alc_fixup_headset_mode_no_hp_mic,

4363

.v.func = alc_fixup_headset_mode_no_hp_mic,

4360

},

4364

},

4361

[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {

4365

[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {

4362

.type = HDA_FIXUP_PINS,

4366

.type = HDA_FIXUP_PINS,

4363

.v.pins = (const struct hda_pintbl[]) {

4367

.v.pins = (const struct hda_pintbl[]) {

4364

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4368

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4365

{ }

4369

{ }

4366

},

4370

},

4367

.chained = true,

4371

.chained = true,

4368

.chain_id = ALC269_FIXUP_HEADSET_MIC

4372

.chain_id = ALC269_FIXUP_HEADSET_MIC

4369

},

4373

},

4370

[ALC269_FIXUP_ASUS_X101_FUNC] = {

4374

[ALC269_FIXUP_ASUS_X101_FUNC] = {

4371

.type = HDA_FIXUP_FUNC,

4375

.type = HDA_FIXUP_FUNC,

4372

.v.func = alc269_fixup_x101_headset_mic,

4376

.v.func = alc269_fixup_x101_headset_mic,

4373

},

4377

},

4374

[ALC269_FIXUP_ASUS_X101_VERB] = {

4378

[ALC269_FIXUP_ASUS_X101_VERB] = {

4375

.type = HDA_FIXUP_VERBS,

4379

.type = HDA_FIXUP_VERBS,

4376

.v.verbs = (const struct hda_verb[]) {

4380

.v.verbs = (const struct hda_verb[]) {

4377

{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},

4381

{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},

4378

{0x20, AC_VERB_SET_COEF_INDEX, 0x08},

4382

{0x20, AC_VERB_SET_COEF_INDEX, 0x08},

4379

{0x20, AC_VERB_SET_PROC_COEF, 0x0310},

4383

{0x20, AC_VERB_SET_PROC_COEF, 0x0310},

4380

{ }

4384

{ }

4381

},

4385

},

4382

.chained = true,

4386

.chained = true,

4383

.chain_id = ALC269_FIXUP_ASUS_X101_FUNC

4387

.chain_id = ALC269_FIXUP_ASUS_X101_FUNC

4384

},

4388

},

4385

[ALC269_FIXUP_ASUS_X101] = {

4389

[ALC269_FIXUP_ASUS_X101] = {

4386

.type = HDA_FIXUP_PINS,

4390

.type = HDA_FIXUP_PINS,

4387

.v.pins = (const struct hda_pintbl[]) {

4391

.v.pins = (const struct hda_pintbl[]) {

4388

{ 0x18, 0x04a1182c }, /* Headset mic */

4392

{ 0x18, 0x04a1182c }, /* Headset mic */

4389

{ }

4393

{ }

4390

},

4394

},

4391

.chained = true,

4395

.chained = true,

4392

.chain_id = ALC269_FIXUP_ASUS_X101_VERB

4396

.chain_id = ALC269_FIXUP_ASUS_X101_VERB

4393

},

4397

},

4394

[ALC271_FIXUP_AMIC_MIC2] = {

4398

[ALC271_FIXUP_AMIC_MIC2] = {

4395

.type = HDA_FIXUP_PINS,

4399

.type = HDA_FIXUP_PINS,

4396

.v.pins = (const struct hda_pintbl[]) {

4400

.v.pins = (const struct hda_pintbl[]) {

4397

{ 0x14, 0x99130110 }, /* speaker */

4401

{ 0x14, 0x99130110 }, /* speaker */

4398

{ 0x19, 0x01a19c20 }, /* mic */

4402

{ 0x19, 0x01a19c20 }, /* mic */

4399

{ 0x1b, 0x99a7012f }, /* int-mic */

4403

{ 0x1b, 0x99a7012f }, /* int-mic */

4400

{ 0x21, 0x0121401f }, /* HP out */

4404

{ 0x21, 0x0121401f }, /* HP out */

4401

{ }

4405

{ }

4402

},

4406

},

4403

},

4407

},

4404

[ALC271_FIXUP_HP_GATE_MIC_JACK] = {

4408

[ALC271_FIXUP_HP_GATE_MIC_JACK] = {

4405

.type = HDA_FIXUP_FUNC,

4409

.type = HDA_FIXUP_FUNC,

4406

.v.func = alc271_hp_gate_mic_jack,

4410

.v.func = alc271_hp_gate_mic_jack,

4407

.chained = true,

4411

.chained = true,

4408

.chain_id = ALC271_FIXUP_AMIC_MIC2,

4412

.chain_id = ALC271_FIXUP_AMIC_MIC2,

4409

},

4413

},

4410

[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {

4414

[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {

4411

.type = HDA_FIXUP_FUNC,

4415

.type = HDA_FIXUP_FUNC,

4412

.v.func = alc269_fixup_limit_int_mic_boost,

4416

.v.func = alc269_fixup_limit_int_mic_boost,

4413

.chained = true,

4417

.chained = true,

4414

.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,

4418

.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,

4415

},

4419

},

4416

[ALC269_FIXUP_ACER_AC700] = {

4420

[ALC269_FIXUP_ACER_AC700] = {

4417

.type = HDA_FIXUP_PINS,

4421

.type = HDA_FIXUP_PINS,

4418

.v.pins = (const struct hda_pintbl[]) {

4422

.v.pins = (const struct hda_pintbl[]) {

4419

{ 0x12, 0x99a3092f }, /* int-mic */

4423

{ 0x12, 0x99a3092f }, /* int-mic */

4420

{ 0x14, 0x99130110 }, /* speaker */

4424

{ 0x14, 0x99130110 }, /* speaker */

4421

{ 0x18, 0x03a11c20 }, /* mic */

4425

{ 0x18, 0x03a11c20 }, /* mic */

4422

{ 0x1e, 0x0346101e }, /* SPDIF1 */

4426

{ 0x1e, 0x0346101e }, /* SPDIF1 */

4423

{ 0x21, 0x0321101f }, /* HP out */

4427

{ 0x21, 0x0321101f }, /* HP out */

4424

{ }

4428

{ }

4425

},

4429

},

4426

.chained = true,

4430

.chained = true,

4427

.chain_id = ALC271_FIXUP_DMIC,

4431

.chain_id = ALC271_FIXUP_DMIC,

4428

},

4432

},

4429

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {

4433

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {

4430

.type = HDA_FIXUP_FUNC,

4434

.type = HDA_FIXUP_FUNC,

4431

.v.func = alc269_fixup_limit_int_mic_boost,

4435

.v.func = alc269_fixup_limit_int_mic_boost,

4432

.chained = true,

4436

.chained = true,

4433

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4437

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4434

},

4438

},

4435

[ALC269VB_FIXUP_ASUS_ZENBOOK] = {

4439

[ALC269VB_FIXUP_ASUS_ZENBOOK] = {

4436

.type = HDA_FIXUP_FUNC,

4440

.type = HDA_FIXUP_FUNC,

4437

.v.func = alc269_fixup_limit_int_mic_boost,

4441

.v.func = alc269_fixup_limit_int_mic_boost,

4438

.chained = true,

4442

.chained = true,

4439

.chain_id = ALC269VB_FIXUP_DMIC,

4443

.chain_id = ALC269VB_FIXUP_DMIC,

4440

},

4444

},

4441

[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {

4445

[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {

4442

.type = HDA_FIXUP_VERBS,

4446

.type = HDA_FIXUP_VERBS,

4443

.v.verbs = (const struct hda_verb[]) {

4447

.v.verbs = (const struct hda_verb[]) {

4444

/* class-D output amp +5dB */

4448

/* class-D output amp +5dB */

4445

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },

4449

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },

4446

{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },

4450

{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },

4447

{}

4451

{}

4448

},

4452

},

4449

.chained = true,

4453

.chained = true,

4450

.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,

4454

.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,

4451

},

4455

},

4452

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {

4456

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {

4453

.type = HDA_FIXUP_FUNC,

4457

.type = HDA_FIXUP_FUNC,

4454

.v.func = alc269_fixup_limit_int_mic_boost,

4458

.v.func = alc269_fixup_limit_int_mic_boost,

4455

.chained = true,

4459

.chained = true,

4456

.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,

4460

.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,

4457

},

4461

},

4458

[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {

4462

[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {

4459

.type = HDA_FIXUP_PINS,

4463

.type = HDA_FIXUP_PINS,

4460

.v.pins = (const struct hda_pintbl[]) {

4464

.v.pins = (const struct hda_pintbl[]) {

4461

{ 0x12, 0x99a3092f }, /* int-mic */

4465

{ 0x12, 0x99a3092f }, /* int-mic */

4462

{ 0x18, 0x03a11d20 }, /* mic */

4466

{ 0x18, 0x03a11d20 }, /* mic */

4463

{ 0x19, 0x411111f0 }, /* Unused bogus pin */

4467

{ 0x19, 0x411111f0 }, /* Unused bogus pin */

4464

{ }

4468

{ }

4465

},

4469

},

4466

},

4470

},

4467

[ALC283_FIXUP_CHROME_BOOK] = {

4471

[ALC283_FIXUP_CHROME_BOOK] = {

4468

.type = HDA_FIXUP_FUNC,

4472

.type = HDA_FIXUP_FUNC,

4469

.v.func = alc283_fixup_chromebook,

4473

.v.func = alc283_fixup_chromebook,

4470

},

4474

},

4471

[ALC283_FIXUP_SENSE_COMBO_JACK] = {

4475

[ALC283_FIXUP_SENSE_COMBO_JACK] = {

4472

.type = HDA_FIXUP_FUNC,

4476

.type = HDA_FIXUP_FUNC,

4473

.v.func = alc283_fixup_sense_combo_jack,

4477

.v.func = alc283_fixup_sense_combo_jack,

4474

.chained = true,

4478

.chained = true,

4475

.chain_id = ALC283_FIXUP_CHROME_BOOK,

4479

.chain_id = ALC283_FIXUP_CHROME_BOOK,

4476

},

4480

},

4477

[ALC282_FIXUP_ASUS_TX300] = {

4481

[ALC282_FIXUP_ASUS_TX300] = {

4478

.type = HDA_FIXUP_FUNC,

4482

.type = HDA_FIXUP_FUNC,

4479

.v.func = alc282_fixup_asus_tx300,

4483

.v.func = alc282_fixup_asus_tx300,

4480

},

4484

},

4481

[ALC283_FIXUP_INT_MIC] = {

4485

[ALC283_FIXUP_INT_MIC] = {

4482

.type = HDA_FIXUP_VERBS,

4486

.type = HDA_FIXUP_VERBS,

4483

.v.verbs = (const struct hda_verb[]) {

4487

.v.verbs = (const struct hda_verb[]) {

4484

{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},

4488

{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},

4485

{0x20, AC_VERB_SET_PROC_COEF, 0x0011},

4489

{0x20, AC_VERB_SET_PROC_COEF, 0x0011},

4486

{ }

4490

{ }

4487

},

4491

},

4488

.chained = true,

4492

.chained = true,

4489

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

4493

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

4490

},

4494

},

4491

[ALC290_FIXUP_SUBWOOFER_HSJACK] = {

4495

[ALC290_FIXUP_SUBWOOFER_HSJACK] = {

4492

.type = HDA_FIXUP_PINS,

4496

.type = HDA_FIXUP_PINS,

4493

.v.pins = (const struct hda_pintbl[]) {

4497

.v.pins = (const struct hda_pintbl[]) {

4494

{ 0x17, 0x90170112 }, /* subwoofer */

4498

{ 0x17, 0x90170112 }, /* subwoofer */

4495

{ }

4499

{ }

4496

},

4500

},

4497

.chained = true,

4501

.chained = true,

4498

.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4502

.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4499

},

4503

},

4500

[ALC290_FIXUP_SUBWOOFER] = {

4504

[ALC290_FIXUP_SUBWOOFER] = {

4501

.type = HDA_FIXUP_PINS,

4505

.type = HDA_FIXUP_PINS,

4502

.v.pins = (const struct hda_pintbl[]) {

4506

.v.pins = (const struct hda_pintbl[]) {

4503

{ 0x17, 0x90170112 }, /* subwoofer */

4507

{ 0x17, 0x90170112 }, /* subwoofer */

4504

{ }

4508

{ }

4505

},

4509

},

4506

.chained = true,

4510

.chained = true,

4507

.chain_id = ALC290_FIXUP_MONO_SPEAKERS,

4511

.chain_id = ALC290_FIXUP_MONO_SPEAKERS,

4508

},

4512

},

4509

[ALC290_FIXUP_MONO_SPEAKERS] = {

4513

[ALC290_FIXUP_MONO_SPEAKERS] = {

4510

.type = HDA_FIXUP_FUNC,

4514

.type = HDA_FIXUP_FUNC,

4511

.v.func = alc290_fixup_mono_speakers,

4515

.v.func = alc290_fixup_mono_speakers,

4512

},

4516

},

4513

[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {

4517

[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {

4514

.type = HDA_FIXUP_FUNC,

4518

.type = HDA_FIXUP_FUNC,

4515

.v.func = alc290_fixup_mono_speakers,

4519

.v.func = alc290_fixup_mono_speakers,

4516

.chained = true,

4520

.chained = true,

4517

.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4521

.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4518

},

4522

},

4519

[ALC269_FIXUP_THINKPAD_ACPI] = {

4523

[ALC269_FIXUP_THINKPAD_ACPI] = {

4520

.type = HDA_FIXUP_FUNC,

4524

.type = HDA_FIXUP_FUNC,

4521

.v.func = hda_fixup_thinkpad_acpi,

4525

.v.func = hda_fixup_thinkpad_acpi,

4522

},

4526

},

4523

[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4527

[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4524

.type = HDA_FIXUP_PINS,

4528

.type = HDA_FIXUP_PINS,

4525

.v.pins = (const struct hda_pintbl[]) {

4529

.v.pins = (const struct hda_pintbl[]) {

4526

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4530

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4527

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4531

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4528

{ }

4532

{ }

4529

},

4533

},

4530

.chained = true,

4534

.chained = true,

4531

.chain_id = ALC255_FIXUP_HEADSET_MODE

4535

.chain_id = ALC255_FIXUP_HEADSET_MODE

4532

},

4536

},

4533

[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4537

[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4534

.type = HDA_FIXUP_PINS,

4538

.type = HDA_FIXUP_PINS,

4535

.v.pins = (const struct hda_pintbl[]) {

4539

.v.pins = (const struct hda_pintbl[]) {

4536

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4540

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4537

{ }

4541

{ }

4538

},

4542

},

4539

.chained = true,

4543

.chained = true,

4540

.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC

4544

.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC

4541

},

4545

},

4542

[ALC255_FIXUP_HEADSET_MODE] = {

4546

[ALC255_FIXUP_HEADSET_MODE] = {

4543

.type = HDA_FIXUP_FUNC,

4547

.type = HDA_FIXUP_FUNC,

4544

.v.func = alc_fixup_headset_mode_alc255,

4548

.v.func = alc_fixup_headset_mode_alc255,

4545

},

4549

},

4546

[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

4550

[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

4547

.type = HDA_FIXUP_FUNC,

4551

.type = HDA_FIXUP_FUNC,

4548

.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,

4552

.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,

4549

},

4553

},

4550

};

4554

};

4551

4555

4552

static const struct snd_pci_quirk alc269_fixup_tbl[] = {

4556

static const struct snd_pci_quirk alc269_fixup_tbl[] = {

4553

SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),

4557

SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),

4554

SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),

4558

SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),

4555

SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),

4559

SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),

4556

SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),

4560

SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),

4557

SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),

4561

SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),

4558

SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),

4562

SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),

4559

SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),

4563

SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),

4560

SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

4564

SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

4561

SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),

4565

SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),

4562

SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4566

SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4563

SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4567

SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4564

SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4568

SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4565

SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4569

SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4566

SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4570

SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4567

SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4571

SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4568

SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4572

SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4569

SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4573

SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4570

SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4574

SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4571

SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4575

SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4572

SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4576

SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4573

SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4577

SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4574

SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),

4578

SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),

4575

SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4579

SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4576

SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4580

SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4577

SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4581

SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4578

SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4582

SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4579

SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4583

SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4580

SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4584

SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4581

SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4585

SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4582

SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4586

SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4583

SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4587

SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4584

SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4588

SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4585

SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4589

SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4586

SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4590

SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4587

SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4591

SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4588

SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4592

SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4589

SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4593

SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4590

SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4594

SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4591

SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4595

SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4592

SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4596

SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4593

SND_PCI_QUIRK(0x1028, 0x060f, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),

4597

SND_PCI_QUIRK(0x1028, 0x060f, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),

4594

SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),

4598

SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),

4595

SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4599

SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4596

SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4600

SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4597

SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

4601

SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

4598

SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

4602

SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

4599

SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4603

SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4600

SND_PCI_QUIRK(0x1028, 0x0629, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4604

SND_PCI_QUIRK(0x1028, 0x0629, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4601

SND_PCI_QUIRK(0x1028, 0x062c, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4605

SND_PCI_QUIRK(0x1028, 0x062c, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4602

SND_PCI_QUIRK(0x1028, 0x062e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4606

SND_PCI_QUIRK(0x1028, 0x062e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4603

SND_PCI_QUIRK(0x1028, 0x0632, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4607

SND_PCI_QUIRK(0x1028, 0x0632, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4604

SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),

4608

SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),

4605

SND_PCI_QUIRK(0x1028, 0x063e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4609

SND_PCI_QUIRK(0x1028, 0x063e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4606

SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4610

SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4607

SND_PCI_QUIRK(0x1028, 0x0640, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4611

SND_PCI_QUIRK(0x1028, 0x0640, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4608

SND_PCI_QUIRK(0x1028, 0x064d, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4612

SND_PCI_QUIRK(0x1028, 0x064d, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4609

SND_PCI_QUIRK(0x1028, 0x0651, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4613

SND_PCI_QUIRK(0x1028, 0x0651, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4610

SND_PCI_QUIRK(0x1028, 0x0652, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4614

SND_PCI_QUIRK(0x1028, 0x0652, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4611

SND_PCI_QUIRK(0x1028, 0x0653, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4615

SND_PCI_QUIRK(0x1028, 0x0653, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4612

SND_PCI_QUIRK(0x1028, 0x0657, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4616

SND_PCI_QUIRK(0x1028, 0x0657, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4613

SND_PCI_QUIRK(0x1028, 0x0658, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4617

SND_PCI_QUIRK(0x1028, 0x0658, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

4614

SND_PCI_QUIRK(0x1028, 0x065f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4618

SND_PCI_QUIRK(0x1028, 0x065f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4615

SND_PCI_QUIRK(0x1028, 0x0662, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4619

SND_PCI_QUIRK(0x1028, 0x0662, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

4616

SND_PCI_QUIRK(0x1028, 0x0668, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),

4620

SND_PCI_QUIRK(0x1028, 0x0668, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),

4617

SND_PCI_QUIRK(0x1028, 0x0669, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),

4621

SND_PCI_QUIRK(0x1028, 0x0669, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),

4618

SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4622

SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4619

SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4623

SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),

4620

SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),

4624

SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),

4621

SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),

4625

SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),

4622

SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4626

SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4623

SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4627

SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4624

SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),

4628

SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),

4625

/* ALC282 */

4629

/* ALC282 */

4626

SND_PCI_QUIRK(0x103c, 0x220f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4630

SND_PCI_QUIRK(0x103c, 0x220f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4627

SND_PCI_QUIRK(0x103c, 0x2213, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4631

SND_PCI_QUIRK(0x103c, 0x2213, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4628

SND_PCI_QUIRK(0x103c, 0x2266, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4632

SND_PCI_QUIRK(0x103c, 0x2266, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4629

SND_PCI_QUIRK(0x103c, 0x2267, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4633

SND_PCI_QUIRK(0x103c, 0x2267, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4630

SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4634

SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4631

SND_PCI_QUIRK(0x103c, 0x2269, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4635

SND_PCI_QUIRK(0x103c, 0x2269, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4632

SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4636

SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4633

SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4637

SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4634

SND_PCI_QUIRK(0x103c, 0x227a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4638

SND_PCI_QUIRK(0x103c, 0x227a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4635

SND_PCI_QUIRK(0x103c, 0x227b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4639

SND_PCI_QUIRK(0x103c, 0x227b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4636

SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4640

SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4637

SND_PCI_QUIRK(0x103c, 0x22a0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4641

SND_PCI_QUIRK(0x103c, 0x22a0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4638

SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4642

SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4639

SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4643

SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4640

SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4644

SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4641

SND_PCI_QUIRK(0x103c, 0x22c0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4645

SND_PCI_QUIRK(0x103c, 0x22c0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4642

SND_PCI_QUIRK(0x103c, 0x22c1, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4646

SND_PCI_QUIRK(0x103c, 0x22c1, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4643

SND_PCI_QUIRK(0x103c, 0x22c2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4647

SND_PCI_QUIRK(0x103c, 0x22c2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4644

SND_PCI_QUIRK(0x103c, 0x22cd, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4648

SND_PCI_QUIRK(0x103c, 0x22cd, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4645

SND_PCI_QUIRK(0x103c, 0x22ce, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4649

SND_PCI_QUIRK(0x103c, 0x22ce, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4646

SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4650

SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4647

SND_PCI_QUIRK(0x103c, 0x22d0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4651

SND_PCI_QUIRK(0x103c, 0x22d0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4648

/* ALC290 */

4652

/* ALC290 */

4649

SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4653

SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4650

SND_PCI_QUIRK(0x103c, 0x2261, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4654

SND_PCI_QUIRK(0x103c, 0x2261, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4651

SND_PCI_QUIRK(0x103c, 0x2262, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4655

SND_PCI_QUIRK(0x103c, 0x2262, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4652

SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4656

SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4653

SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4657

SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4654

SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4658

SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4655

SND_PCI_QUIRK(0x103c, 0x227d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4659

SND_PCI_QUIRK(0x103c, 0x227d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4656

SND_PCI_QUIRK(0x103c, 0x227e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4660

SND_PCI_QUIRK(0x103c, 0x227e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4657

SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4661

SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4658

SND_PCI_QUIRK(0x103c, 0x2280, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4662

SND_PCI_QUIRK(0x103c, 0x2280, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4659

SND_PCI_QUIRK(0x103c, 0x2281, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4663

SND_PCI_QUIRK(0x103c, 0x2281, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4660

SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4664

SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4661

SND_PCI_QUIRK(0x103c, 0x2289, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4665

SND_PCI_QUIRK(0x103c, 0x2289, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4662

SND_PCI_QUIRK(0x103c, 0x228a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4666

SND_PCI_QUIRK(0x103c, 0x228a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4663

SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4667

SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4664

SND_PCI_QUIRK(0x103c, 0x228c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4668

SND_PCI_QUIRK(0x103c, 0x228c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4665

SND_PCI_QUIRK(0x103c, 0x228d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4669

SND_PCI_QUIRK(0x103c, 0x228d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4666

SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4670

SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4667

SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4671

SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4668

SND_PCI_QUIRK(0x103c, 0x22c6, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4672

SND_PCI_QUIRK(0x103c, 0x22c6, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4669

SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4673

SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4670

SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4674

SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4671

SND_PCI_QUIRK(0x103c, 0x22c3, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4675

SND_PCI_QUIRK(0x103c, 0x22c3, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4672

SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4676

SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

4673

SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),

4677

SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),

4674

SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),

4678

SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),

4675

SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4679

SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4676

SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4680

SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4677

SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),

4681

SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),

4678

SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),

4682

SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),

4679

SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),

4683

SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),

4680

SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),

4684

SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),

4681

SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),

4685

SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),

4682

SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4686

SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4683

SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),

4687

SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),

4684

SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),

4688

SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),

4685

SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

4689

SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

4686

SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

4690

SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

4687

SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),

4691

SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),

4688

SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

4692

SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

4689

SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

4693

SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

4690

SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),

4694

SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),

4691

SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

4695

SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

4692

SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

4696

SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

4693

SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),

4697

SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),

4694

SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),

4698

SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),

4695

SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),

4699

SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),

4696

SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),

4700

SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),

4697

SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

4701

SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

4698

SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),

4702

SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),

4699

SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),

4703

SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),

4700

SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),

4704

SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),

4701

SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),

4705

SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),

4702

SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),

4706

SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),

4703

SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),

4707

SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),

4704

SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),

4708

SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),

4705

SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),

4709

SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),

4706

SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4710

SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4707

SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4711

SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4708

SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4712

SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4709

SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4713

SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4710

SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),

4714

SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),

4711

SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4715

SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4712

SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),

4716

SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),

4713

SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4717

SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4714

SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4718

SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

4715

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),

4719

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),

4716

SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),

4720

SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),

4717

SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),

4721

SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),

4718

SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */

4722

SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */

4719

4723

4720

#if 0

4724

#if 0

4721

/* Below is a quirk table taken from the old code.

4725

/* Below is a quirk table taken from the old code.

4722

* Basically the device should work as is without the fixup table.

4726

* Basically the device should work as is without the fixup table.

4723

* If BIOS doesn't give a proper info, enable the corresponding

4727

* If BIOS doesn't give a proper info, enable the corresponding

4724

* fixup entry.

4728

* fixup entry.

4725

*/

4729

*/

4726

SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",

4730

SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",

4727

ALC269_FIXUP_AMIC),

4731

ALC269_FIXUP_AMIC),

4728

SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),

4732

SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),

4729

SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),

4733

SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),

4730

SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),

4734

SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),

4731

SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),

4735

SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),

4732

SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),

4736

SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),

4733

SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),

4737

SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),

4734

SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),

4738

SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),

4735

SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),

4739

SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),

4736

SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),

4740

SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),

4737

SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),

4741

SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),

4738

SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),

4742

SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),

4739

SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),

4743

SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),

4740

SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),

4744

SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),

4741

SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),

4745

SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),

4742

SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),

4746

SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),

4743

SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),

4747

SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),

4744

SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),

4748

SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),

4745

SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),

4749

SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),

4746

SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),

4750

SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),

4747

SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),

4751

SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),

4748

SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),

4752

SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),

4749

SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),

4753

SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),

4750

SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),

4754

SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),

4751

SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),

4755

SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),

4752

SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),

4756

SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),

4753

SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),

4757

SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),

4754

SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),

4758

SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),

4755

SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),

4759

SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),

4756

SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),

4760

SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),

4757

SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),

4761

SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),

4758

SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),

4762

SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),

4759

SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),

4763

SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),

4760

SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),

4764

SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),

4761

SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),

4765

SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),

4762

SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),

4766

SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),

4763

SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),

4767

SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),

4764

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),

4768

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),

4765

SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),

4769

SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),

4766

SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),

4770

SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),

4767

#endif

4771

#endif

4768

{}

4772

{}

4769

};

4773

};

4770

4774

4771

static const struct hda_model_fixup alc269_fixup_models[] = {

4775

static const struct hda_model_fixup alc269_fixup_models[] = {

4772

{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},

4776

{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},

4773

{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},

4777

{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},

4774

{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},

4778

{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},

4775

{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},

4779

{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},

4776

{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},

4780

{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},

4777

{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},

4781

{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},

4778

{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},

4782

{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},

4779

{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},

4783

{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},

4780

{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

4784

{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

4781

{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},

4785

{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},

4782

{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-chrome"},

4786

{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-chrome"},

4783

{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},

4787

{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},

4784

{}

4788

{}

4785

};

4789

};

4786

4790

4787

4791

4788

static void alc269_fill_coef(struct hda_codec *codec)

4792

static void alc269_fill_coef(struct hda_codec *codec)

4789

{

4793

{

4790

struct alc_spec *spec = codec->spec;

4794

struct alc_spec *spec = codec->spec;

4791

int val;

4795

int val;

4792

4796

4793

if (spec->codec_variant != ALC269_TYPE_ALC269VB)

4797

if (spec->codec_variant != ALC269_TYPE_ALC269VB)

4794

return;

4798

return;

4795

4799

4796

if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {

4800

if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {

4797

alc_write_coef_idx(codec, 0xf, 0x960b);

4801

alc_write_coef_idx(codec, 0xf, 0x960b);

4798

alc_write_coef_idx(codec, 0xe, 0x8817);

4802

alc_write_coef_idx(codec, 0xe, 0x8817);

4799

}

4803

}

4800

4804

4801

if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {

4805

if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {

4802

alc_write_coef_idx(codec, 0xf, 0x960b);

4806

alc_write_coef_idx(codec, 0xf, 0x960b);

4803

alc_write_coef_idx(codec, 0xe, 0x8814);

4807

alc_write_coef_idx(codec, 0xe, 0x8814);

4804

}

4808

}

4805

4809

4806

if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {

4810

if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {

4807

val = alc_read_coef_idx(codec, 0x04);

4811

val = alc_read_coef_idx(codec, 0x04);

4808

/* Power up output pin */

4812

/* Power up output pin */

4809

alc_write_coef_idx(codec, 0x04, val | (1<<11));

4813

alc_write_coef_idx(codec, 0x04, val | (1<<11));

4810

}

4814

}

4811

4815

4812

if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {

4816

if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {

4813

val = alc_read_coef_idx(codec, 0xd);

4817

val = alc_read_coef_idx(codec, 0xd);

4814

if ((val & 0x0c00) >> 10 != 0x1) {

4818

if ((val & 0x0c00) >> 10 != 0x1) {

4815

/* Capless ramp up clock control */

4819

/* Capless ramp up clock control */

4816

alc_write_coef_idx(codec, 0xd, val | (1<<10));

4820

alc_write_coef_idx(codec, 0xd, val | (1<<10));

4817

}

4821

}

4818

val = alc_read_coef_idx(codec, 0x17);

4822

val = alc_read_coef_idx(codec, 0x17);

4819

if ((val & 0x01c0) >> 6 != 0x4) {

4823

if ((val & 0x01c0) >> 6 != 0x4) {

4820

/* Class D power on reset */

4824

/* Class D power on reset */

4821

alc_write_coef_idx(codec, 0x17, val | (1<<7));

4825

alc_write_coef_idx(codec, 0x17, val | (1<<7));

4822

}

4826

}

4823

}

4827

}

4824

4828

4825

val = alc_read_coef_idx(codec, 0xd); /* Class D */

4829

val = alc_read_coef_idx(codec, 0xd); /* Class D */

4826

alc_write_coef_idx(codec, 0xd, val | (1<<14));

4830

alc_write_coef_idx(codec, 0xd, val | (1<<14));

4827

4831

4828

val = alc_read_coef_idx(codec, 0x4); /* HP */

4832

val = alc_read_coef_idx(codec, 0x4); /* HP */

4829

alc_write_coef_idx(codec, 0x4, val | (1<<11));

4833

alc_write_coef_idx(codec, 0x4, val | (1<<11));

4830

}

4834

}

4831

4835

4832

/*

4836

/*

4833

*/

4837

*/

4834

static int patch_alc269(struct hda_codec *codec)

4838

static int patch_alc269(struct hda_codec *codec)

4835

{

4839

{

4836

struct alc_spec *spec;

4840

struct alc_spec *spec;

4837

int err;

4841

int err;

4838

4842

4839

err = alc_alloc_spec(codec, 0x0b);

4843

err = alc_alloc_spec(codec, 0x0b);

4840

if (err < 0)

4844

if (err < 0)

4841

return err;

4845

return err;

4842

4846

4843

spec = codec->spec;

4847

spec = codec->spec;

4844

spec->gen.shared_mic_vref_pin = 0x18;

4848

spec->gen.shared_mic_vref_pin = 0x18;

4845

4849

4846

snd_hda_pick_fixup(codec, alc269_fixup_models,

4850

snd_hda_pick_fixup(codec, alc269_fixup_models,

4847

alc269_fixup_tbl, alc269_fixups);

4851

alc269_fixup_tbl, alc269_fixups);

4848

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

4852

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

4849

4853

4850

alc_auto_parse_customize_define(codec);

4854

alc_auto_parse_customize_define(codec);

4851

4855

4852

if (has_cdefine_beep(codec))

4856

if (has_cdefine_beep(codec))

4853

spec->gen.beep_nid = 0x01;

4857

spec->gen.beep_nid = 0x01;

4854

4858

4855

switch (codec->vendor_id) {

4859

switch (codec->vendor_id) {

4856

case 0x10ec0269:

4860

case 0x10ec0269:

4857

spec->codec_variant = ALC269_TYPE_ALC269VA;

4861

spec->codec_variant = ALC269_TYPE_ALC269VA;

4858

switch (alc_get_coef0(codec) & 0x00f0) {

4862

switch (alc_get_coef0(codec) & 0x00f0) {

4859

case 0x0010:

4863

case 0x0010:

4860

if (codec->bus->pci &&

4864

if (codec->bus->pci &&

4861

codec->bus->pci->subsystem_vendor == 0x1025 &&

4865

codec->bus->pci->subsystem_vendor == 0x1025 &&

4862

spec->cdefine.platform_type == 1)

4866

spec->cdefine.platform_type == 1)

4863

err = alc_codec_rename(codec, "ALC271X");

4867

err = alc_codec_rename(codec, "ALC271X");

4864

spec->codec_variant = ALC269_TYPE_ALC269VB;

4868

spec->codec_variant = ALC269_TYPE_ALC269VB;

4865

break;

4869

break;

4866

case 0x0020:

4870

case 0x0020:

4867

if (codec->bus->pci &&

4871

if (codec->bus->pci &&

4868

codec->bus->pci->subsystem_vendor == 0x17aa &&

4872

codec->bus->pci->subsystem_vendor == 0x17aa &&

4869

codec->bus->pci->subsystem_device == 0x21f3)

4873

codec->bus->pci->subsystem_device == 0x21f3)

4870

err = alc_codec_rename(codec, "ALC3202");

4874

err = alc_codec_rename(codec, "ALC3202");

4871

spec->codec_variant = ALC269_TYPE_ALC269VC;

4875

spec->codec_variant = ALC269_TYPE_ALC269VC;

4872

break;

4876

break;

4873

case 0x0030:

4877

case 0x0030:

4874

spec->codec_variant = ALC269_TYPE_ALC269VD;

4878

spec->codec_variant = ALC269_TYPE_ALC269VD;

4875

break;

4879

break;

4876

default:

4880

default:

4877

alc_fix_pll_init(codec, 0x20, 0x04, 15);

4881

alc_fix_pll_init(codec, 0x20, 0x04, 15);

4878

}

4882

}

4879

if (err < 0)

4883

if (err < 0)

4880

goto error;

4884

goto error;

4881

spec->init_hook = alc269_fill_coef;

4885

spec->init_hook = alc269_fill_coef;

4882

alc269_fill_coef(codec);

4886

alc269_fill_coef(codec);

4883

break;

4887

break;

4884

4888

4885

case 0x10ec0280:

4889

case 0x10ec0280:

4886

case 0x10ec0290:

4890

case 0x10ec0290:

4887

spec->codec_variant = ALC269_TYPE_ALC280;

4891

spec->codec_variant = ALC269_TYPE_ALC280;

4888

break;

4892

break;

4889

case 0x10ec0282:

4893

case 0x10ec0282:

4890

spec->codec_variant = ALC269_TYPE_ALC282;

4894

spec->codec_variant = ALC269_TYPE_ALC282;

4891

spec->shutup = alc282_shutup;

4895

spec->shutup = alc282_shutup;

4892

spec->init_hook = alc282_init;

4896

spec->init_hook = alc282_init;

4893

break;

4897

break;

4894

case 0x10ec0233:

4898

case 0x10ec0233:

4895

case 0x10ec0283:

4899

case 0x10ec0283:

4896

spec->codec_variant = ALC269_TYPE_ALC283;

4900

spec->codec_variant = ALC269_TYPE_ALC283;

4897

spec->shutup = alc283_shutup;

4901

spec->shutup = alc283_shutup;

4898

spec->init_hook = alc283_init;

4902

spec->init_hook = alc283_init;

4899

break;

4903

break;

4900

case 0x10ec0284:

4904

case 0x10ec0284:

4901

case 0x10ec0292:

4905

case 0x10ec0292:

4902

spec->codec_variant = ALC269_TYPE_ALC284;

4906

spec->codec_variant = ALC269_TYPE_ALC284;

4903

break;

4907

break;

4904

case 0x10ec0285:

4908

case 0x10ec0285:

4905

case 0x10ec0293:

4909

case 0x10ec0293:

4906

spec->codec_variant = ALC269_TYPE_ALC285;

4910

spec->codec_variant = ALC269_TYPE_ALC285;

4907

break;

4911

break;

4908

case 0x10ec0286:

4912

case 0x10ec0286:

4909

spec->codec_variant = ALC269_TYPE_ALC286;

4913

spec->codec_variant = ALC269_TYPE_ALC286;

4910

break;

4914

break;

4911

case 0x10ec0255:

4915

case 0x10ec0255:

4912

spec->codec_variant = ALC269_TYPE_ALC255;

4916

spec->codec_variant = ALC269_TYPE_ALC255;

4913

break;

4917

break;

4914

}

4918

}

4915

4919

4916

if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {

4920

if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {

4917

spec->has_alc5505_dsp = 1;

4921

spec->has_alc5505_dsp = 1;

4918

spec->init_hook = alc5505_dsp_init;

4922

spec->init_hook = alc5505_dsp_init;

4919

}

4923

}

4920

4924

4921

/* automatic parse from the BIOS config */

4925

/* automatic parse from the BIOS config */

4922

err = alc269_parse_auto_config(codec);

4926

err = alc269_parse_auto_config(codec);

4923

if (err < 0)

4927

if (err < 0)

4924

goto error;

4928

goto error;

4925

4929

4926

if (!spec->gen.no_analog && spec->gen.beep_nid)

4930

if (!spec->gen.no_analog && spec->gen.beep_nid)

4927

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

4931

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

4928

4932

4929

codec->patch_ops = alc_patch_ops;

4933

codec->patch_ops = alc_patch_ops;

4930

#ifdef CONFIG_PM

4934

#ifdef CONFIG_PM

4931

codec->patch_ops.suspend = alc269_suspend;

4935

codec->patch_ops.suspend = alc269_suspend;

4932

codec->patch_ops.resume = alc269_resume;

4936

codec->patch_ops.resume = alc269_resume;

4933

#endif

4937

#endif

4934

if (!spec->shutup)

4938

if (!spec->shutup)

4935

spec->shutup = alc269_shutup;

4939

spec->shutup = alc269_shutup;

4936

4940

4937

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

4941

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

4938

4942

4939

return 0;

4943

return 0;

4940

4944

4941

error:

4945

error:

4942

alc_free(codec);

4946

alc_free(codec);

4943

return err;

4947

return err;

4944

}

4948

}

4945

4949

4946

/*

4950

/*

4947

* ALC861

4951

* ALC861

4948

*/

4952

*/

4949

4953

4950

static int alc861_parse_auto_config(struct hda_codec *codec)

4954

static int alc861_parse_auto_config(struct hda_codec *codec)

4951

{

4955

{

4952

static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };

4956

static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };

4953

static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };

4957

static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };

4954

return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);

4958

return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);

4955

}

4959

}

4956

4960

4957

/* Pin config fixes */

4961

/* Pin config fixes */

4958

enum {

4962

enum {

4959

ALC861_FIXUP_FSC_AMILO_PI1505,

4963

ALC861_FIXUP_FSC_AMILO_PI1505,

4960

ALC861_FIXUP_AMP_VREF_0F,

4964

ALC861_FIXUP_AMP_VREF_0F,

4961

ALC861_FIXUP_NO_JACK_DETECT,

4965

ALC861_FIXUP_NO_JACK_DETECT,

4962

ALC861_FIXUP_ASUS_A6RP,

4966

ALC861_FIXUP_ASUS_A6RP,

4963

ALC660_FIXUP_ASUS_W7J,

4967

ALC660_FIXUP_ASUS_W7J,

4964

};

4968

};

4965

4969

4966

/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */

4970

/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */

4967

static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,

4971

static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,

4968

const struct hda_fixup *fix, int action)

4972

const struct hda_fixup *fix, int action)

4969

{

4973

{

4970

struct alc_spec *spec = codec->spec;

4974

struct alc_spec *spec = codec->spec;

4971

unsigned int val;

4975

unsigned int val;

4972

4976

4973

if (action != HDA_FIXUP_ACT_INIT)

4977

if (action != HDA_FIXUP_ACT_INIT)

4974

return;

4978

return;

4975

val = snd_hda_codec_get_pin_target(codec, 0x0f);

4979

val = snd_hda_codec_get_pin_target(codec, 0x0f);

4976

if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))

4980

if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))

4977

val |= AC_PINCTL_IN_EN;

4981

val |= AC_PINCTL_IN_EN;

4978

val |= AC_PINCTL_VREF_50;

4982

val |= AC_PINCTL_VREF_50;

4979

snd_hda_set_pin_ctl(codec, 0x0f, val);

4983

snd_hda_set_pin_ctl(codec, 0x0f, val);

4980

spec->gen.keep_vref_in_automute = 1;

4984

spec->gen.keep_vref_in_automute = 1;

4981

}

4985

}

4982

4986

4983

/* suppress the jack-detection */

4987

/* suppress the jack-detection */

4984

static void alc_fixup_no_jack_detect(struct hda_codec *codec,

4988

static void alc_fixup_no_jack_detect(struct hda_codec *codec,

4985

const struct hda_fixup *fix, int action)

4989

const struct hda_fixup *fix, int action)

4986

{

4990

{

4987

if (action == HDA_FIXUP_ACT_PRE_PROBE)

4991

if (action == HDA_FIXUP_ACT_PRE_PROBE)

4988

codec->no_jack_detect = 1;

4992

codec->no_jack_detect = 1;

4989

}

4993

}

4990

4994

4991

static const struct hda_fixup alc861_fixups[] = {

4995

static const struct hda_fixup alc861_fixups[] = {

4992

[ALC861_FIXUP_FSC_AMILO_PI1505] = {

4996

[ALC861_FIXUP_FSC_AMILO_PI1505] = {

4993

.type = HDA_FIXUP_PINS,

4997

.type = HDA_FIXUP_PINS,

4994

.v.pins = (const struct hda_pintbl[]) {

4998

.v.pins = (const struct hda_pintbl[]) {

4995

{ 0x0b, 0x0221101f }, /* HP */

4999

{ 0x0b, 0x0221101f }, /* HP */

4996

{ 0x0f, 0x90170310 }, /* speaker */

5000

{ 0x0f, 0x90170310 }, /* speaker */

4997

{ }

5001

{ }

4998

}

5002

}

4999

},

5003

},

5000

[ALC861_FIXUP_AMP_VREF_0F] = {

5004

[ALC861_FIXUP_AMP_VREF_0F] = {

5001

.type = HDA_FIXUP_FUNC,

5005

.type = HDA_FIXUP_FUNC,

5002

.v.func = alc861_fixup_asus_amp_vref_0f,

5006

.v.func = alc861_fixup_asus_amp_vref_0f,

5003

},

5007

},

5004

[ALC861_FIXUP_NO_JACK_DETECT] = {

5008

[ALC861_FIXUP_NO_JACK_DETECT] = {

5005

.type = HDA_FIXUP_FUNC,

5009

.type = HDA_FIXUP_FUNC,

5006

.v.func = alc_fixup_no_jack_detect,

5010

.v.func = alc_fixup_no_jack_detect,

5007

},

5011

},

5008

[ALC861_FIXUP_ASUS_A6RP] = {

5012

[ALC861_FIXUP_ASUS_A6RP] = {

5009

.type = HDA_FIXUP_FUNC,

5013

.type = HDA_FIXUP_FUNC,

5010

.v.func = alc861_fixup_asus_amp_vref_0f,

5014

.v.func = alc861_fixup_asus_amp_vref_0f,

5011

.chained = true,

5015

.chained = true,

5012

.chain_id = ALC861_FIXUP_NO_JACK_DETECT,

5016

.chain_id = ALC861_FIXUP_NO_JACK_DETECT,

5013

},

5017

},

5014

[ALC660_FIXUP_ASUS_W7J] = {

5018

[ALC660_FIXUP_ASUS_W7J] = {

5015

.type = HDA_FIXUP_VERBS,

5019

.type = HDA_FIXUP_VERBS,

5016

.v.verbs = (const struct hda_verb[]) {

5020

.v.verbs = (const struct hda_verb[]) {

5017

/* ASUS W7J needs a magic pin setup on unused NID 0x10

5021

/* ASUS W7J needs a magic pin setup on unused NID 0x10

5018

* for enabling outputs

5022

* for enabling outputs

5019

*/

5023

*/

5020

{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},

5024

{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},

5021

{ }

5025

{ }

5022

},

5026

},

5023

}

5027

}

5024

};

5028

};

5025

5029

5026

static const struct snd_pci_quirk alc861_fixup_tbl[] = {

5030

static const struct snd_pci_quirk alc861_fixup_tbl[] = {

5027

SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),

5031

SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),

5028

SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),

5032

SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),

5029

SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),

5033

SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),

5030

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),

5034

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),

5031

SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),

5035

SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),

5032

SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),

5036

SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),

5033

SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),

5037

SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),

5034

SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),

5038

SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),

5035

{}

5039

{}

5036

};

5040

};

5037

5041

5038

/*

5042

/*

5039

*/

5043

*/

5040

static int patch_alc861(struct hda_codec *codec)

5044

static int patch_alc861(struct hda_codec *codec)

5041

{

5045

{

5042

struct alc_spec *spec;

5046

struct alc_spec *spec;

5043

int err;

5047

int err;

5044

5048

5045

err = alc_alloc_spec(codec, 0x15);

5049

err = alc_alloc_spec(codec, 0x15);

5046

if (err < 0)

5050

if (err < 0)

5047

return err;

5051

return err;

5048

5052

5049

spec = codec->spec;

5053

spec = codec->spec;

5050

spec->gen.beep_nid = 0x23;

5054

spec->gen.beep_nid = 0x23;

5051

5055

5052

snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);

5056

snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);

5053

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5057

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5054

5058

5055

/* automatic parse from the BIOS config */

5059

/* automatic parse from the BIOS config */

5056

err = alc861_parse_auto_config(codec);

5060

err = alc861_parse_auto_config(codec);

5057

if (err < 0)

5061

if (err < 0)

5058

goto error;

5062

goto error;

5059

5063

5060

if (!spec->gen.no_analog)

5064

if (!spec->gen.no_analog)

5061

set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);

5065

set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);

5062

5066

5063

codec->patch_ops = alc_patch_ops;

5067

codec->patch_ops = alc_patch_ops;

5064

#ifdef CONFIG_PM

5068

#ifdef CONFIG_PM

5065

spec->power_hook = alc_power_eapd;

5069

spec->power_hook = alc_power_eapd;

5066

#endif

5070

#endif

5067

5071

5068

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5072

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5069

5073

5070

return 0;

5074

return 0;

5071

5075

5072

error:

5076

error:

5073

alc_free(codec);

5077

alc_free(codec);

5074

return err;

5078

return err;

5075

}

5079

}

5076

5080

5077

/*

5081

/*

5078

* ALC861-VD support

5082

* ALC861-VD support

5079

*

5083

*

5080

* Based on ALC882

5084

* Based on ALC882

5081

*

5085

*

5082

* In addition, an independent DAC

5086

* In addition, an independent DAC

5083

*/

5087

*/

5084

static int alc861vd_parse_auto_config(struct hda_codec *codec)

5088

static int alc861vd_parse_auto_config(struct hda_codec *codec)

5085

{

5089

{

5086

static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };

5090

static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };

5087

static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };

5091

static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };

5088

return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);

5092

return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);

5089

}

5093

}

5090

5094

5091

enum {

5095

enum {

5092

ALC660VD_FIX_ASUS_GPIO1,

5096

ALC660VD_FIX_ASUS_GPIO1,

5093

ALC861VD_FIX_DALLAS,

5097

ALC861VD_FIX_DALLAS,

5094

};

5098

};

5095

5099

5096

/* exclude VREF80 */

5100

/* exclude VREF80 */

5097

static void alc861vd_fixup_dallas(struct hda_codec *codec,

5101

static void alc861vd_fixup_dallas(struct hda_codec *codec,

5098

const struct hda_fixup *fix, int action)

5102

const struct hda_fixup *fix, int action)

5099

{

5103

{

5100

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

5104

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

5101

snd_hda_override_pin_caps(codec, 0x18, 0x00000734);

5105

snd_hda_override_pin_caps(codec, 0x18, 0x00000734);

5102

snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);

5106

snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);

5103

}

5107

}

5104

}

5108

}

5105

5109

5106

static const struct hda_fixup alc861vd_fixups[] = {

5110

static const struct hda_fixup alc861vd_fixups[] = {

5107

[ALC660VD_FIX_ASUS_GPIO1] = {

5111

[ALC660VD_FIX_ASUS_GPIO1] = {

5108

.type = HDA_FIXUP_VERBS,

5112

.type = HDA_FIXUP_VERBS,

5109

.v.verbs = (const struct hda_verb[]) {

5113

.v.verbs = (const struct hda_verb[]) {

5110

/* reset GPIO1 */

5114

/* reset GPIO1 */

5111

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

5115

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

5112

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

5116

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

5113

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

5117

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

5114

{ }

5118

{ }

5115

}

5119

}

5116

},

5120

},

5117

[ALC861VD_FIX_DALLAS] = {

5121

[ALC861VD_FIX_DALLAS] = {

5118

.type = HDA_FIXUP_FUNC,

5122

.type = HDA_FIXUP_FUNC,

5119

.v.func = alc861vd_fixup_dallas,

5123

.v.func = alc861vd_fixup_dallas,

5120

},

5124

},

5121

};

5125

};

5122

5126

5123

static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {

5127

static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {

5124

SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),

5128

SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),

5125

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),

5129

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),

5126

SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),

5130

SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),

5127

{}

5131

{}

5128

};

5132

};

5129

5133

5130

/*

5134

/*

5131

*/

5135

*/

5132

static int patch_alc861vd(struct hda_codec *codec)

5136

static int patch_alc861vd(struct hda_codec *codec)

5133

{

5137

{

5134

struct alc_spec *spec;

5138

struct alc_spec *spec;

5135

int err;

5139

int err;

5136

5140

5137

err = alc_alloc_spec(codec, 0x0b);

5141

err = alc_alloc_spec(codec, 0x0b);

5138

if (err < 0)

5142

if (err < 0)

5139

return err;

5143

return err;

5140

5144

5141

spec = codec->spec;

5145

spec = codec->spec;

5142

spec->gen.beep_nid = 0x23;

5146

spec->gen.beep_nid = 0x23;

5143

5147

5144

snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);

5148

snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);

5145

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5149

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5146

5150

5147

/* automatic parse from the BIOS config */

5151

/* automatic parse from the BIOS config */

5148

err = alc861vd_parse_auto_config(codec);

5152

err = alc861vd_parse_auto_config(codec);

5149

if (err < 0)

5153

if (err < 0)

5150

goto error;

5154

goto error;

5151

5155

5152

if (!spec->gen.no_analog)

5156

if (!spec->gen.no_analog)

5153

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

5157

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

5154

5158

5155

codec->patch_ops = alc_patch_ops;

5159

codec->patch_ops = alc_patch_ops;

5156

5160

5157

spec->shutup = alc_eapd_shutup;

5161

spec->shutup = alc_eapd_shutup;

5158

5162

5159

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5163

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5160

5164

5161

return 0;

5165

return 0;

5162

5166

5163

error:

5167

error:

5164

alc_free(codec);

5168

alc_free(codec);

5165

return err;

5169

return err;

5166

}

5170

}

5167

5171

5168

/*

5172

/*

5169

* ALC662 support

5173

* ALC662 support

5170

*

5174

*

5171

* ALC662 is almost identical with ALC880 but has cleaner and more flexible

5175

* ALC662 is almost identical with ALC880 but has cleaner and more flexible

5172

* configuration. Each pin widget can choose any input DACs and a mixer.

5176

* configuration. Each pin widget can choose any input DACs and a mixer.

5173

* Each ADC is connected from a mixer of all inputs. This makes possible

5177

* Each ADC is connected from a mixer of all inputs. This makes possible

5174

* 6-channel independent captures.

5178

* 6-channel independent captures.

5175

*

5179

*

5176

* In addition, an independent DAC for the multi-playback (not used in this

5180

* In addition, an independent DAC for the multi-playback (not used in this

5177

* driver yet).

5181

* driver yet).

5178

*/

5182

*/

5179

5183

5180

/*

5184

/*

5181

* BIOS auto configuration

5185

* BIOS auto configuration

5182

*/

5186

*/

5183

5187

5184

static int alc662_parse_auto_config(struct hda_codec *codec)

5188

static int alc662_parse_auto_config(struct hda_codec *codec)

5185

{

5189

{

5186

static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };

5190

static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };

5187

static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };

5191

static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };

5188

static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };

5192

static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };

5189

const hda_nid_t *ssids;

5193

const hda_nid_t *ssids;

5190

5194

5191

if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||

5195

if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||

5192

codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||

5196

codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||

5193

codec->vendor_id == 0x10ec0671)

5197

codec->vendor_id == 0x10ec0671)

5194

ssids = alc663_ssids;

5198

ssids = alc663_ssids;

5195

else

5199

else

5196

ssids = alc662_ssids;

5200

ssids = alc662_ssids;

5197

return alc_parse_auto_config(codec, alc662_ignore, ssids);

5201

return alc_parse_auto_config(codec, alc662_ignore, ssids);

5198

}

5202

}

5199

5203

5200

static void alc272_fixup_mario(struct hda_codec *codec,

5204

static void alc272_fixup_mario(struct hda_codec *codec,

5201

const struct hda_fixup *fix, int action)

5205

const struct hda_fixup *fix, int action)

5202

{

5206

{

5203

if (action != HDA_FIXUP_ACT_PRE_PROBE)

5207

if (action != HDA_FIXUP_ACT_PRE_PROBE)

5204

return;

5208

return;

5205

if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,

5209

if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,

5206

(0x3b << AC_AMPCAP_OFFSET_SHIFT) |

5210

(0x3b << AC_AMPCAP_OFFSET_SHIFT) |

5207

(0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |

5211

(0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |

5208

(0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |

5212

(0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |

5209

(0 << AC_AMPCAP_MUTE_SHIFT)))

5213

(0 << AC_AMPCAP_MUTE_SHIFT)))

5210

codec_warn(codec, "failed to override amp caps for NID 0x2\n");

5214

codec_warn(codec, "failed to override amp caps for NID 0x2\n");

5211

}

5215

}

5212

5216

5213

static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {

5217

static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {

5214

{ .channels = 2,

5218

{ .channels = 2,

5215

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },

5219

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },

5216

{ .channels = 4,

5220

{ .channels = 4,

5217

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,

5221

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,

5218

SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */

5222

SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */

5219

{ }

5223

{ }

5220

};

5224

};

5221

5225

5222

/* override the 2.1 chmap */

5226

/* override the 2.1 chmap */

5223

static void alc_fixup_bass_chmap(struct hda_codec *codec,

5227

static void alc_fixup_bass_chmap(struct hda_codec *codec,

5224

const struct hda_fixup *fix, int action)

5228

const struct hda_fixup *fix, int action)

5225

{

5229

{

5226

if (action == HDA_FIXUP_ACT_BUILD) {

5230

if (action == HDA_FIXUP_ACT_BUILD) {

5227

struct alc_spec *spec = codec->spec;

5231

struct alc_spec *spec = codec->spec;

5228

spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps;

5232

spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps;

5229

}

5233

}

5230

}

5234

}

5231

5235

5232

/* turn on/off mute LED per vmaster hook */

5236

/* turn on/off mute LED per vmaster hook */

5233

static void alc662_led_gpio1_mute_hook(void *private_data, int enabled)

5237

static void alc662_led_gpio1_mute_hook(void *private_data, int enabled)

5234

{

5238

{

5235

struct hda_codec *codec = private_data;

5239

struct hda_codec *codec = private_data;

5236

struct alc_spec *spec = codec->spec;

5240

struct alc_spec *spec = codec->spec;

5237

unsigned int oldval = spec->gpio_led;

5241

unsigned int oldval = spec->gpio_led;

5238

5242

5239

if (enabled)

5243

if (enabled)

5240

spec->gpio_led &= ~0x01;

5244

spec->gpio_led &= ~0x01;

5241

else

5245

else

5242

spec->gpio_led |= 0x01;

5246

spec->gpio_led |= 0x01;

5243

if (spec->gpio_led != oldval)

5247

if (spec->gpio_led != oldval)

5244

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

5248

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

5245

spec->gpio_led);

5249

spec->gpio_led);

5246

}

5250

}

5247

5251

5248

/* avoid D3 for keeping GPIO up */

5252

/* avoid D3 for keeping GPIO up */

5249

static unsigned int gpio_led_power_filter(struct hda_codec *codec,

5253

static unsigned int gpio_led_power_filter(struct hda_codec *codec,

5250

hda_nid_t nid,

5254

hda_nid_t nid,

5251

unsigned int power_state)

5255

unsigned int power_state)

5252

{

5256

{

5253

struct alc_spec *spec = codec->spec;

5257

struct alc_spec *spec = codec->spec;

5254

if (nid == codec->afg && power_state == AC_PWRST_D3 && spec->gpio_led)

5258

if (nid == codec->afg && power_state == AC_PWRST_D3 && spec->gpio_led)

5255

return AC_PWRST_D0;

5259

return AC_PWRST_D0;

5256

return power_state;

5260

return power_state;

5257

}

5261

}

5258

5262

5259

static void alc662_fixup_led_gpio1(struct hda_codec *codec,

5263

static void alc662_fixup_led_gpio1(struct hda_codec *codec,

5260

const struct hda_fixup *fix, int action)

5264

const struct hda_fixup *fix, int action)

5261

{

5265

{

5262

struct alc_spec *spec = codec->spec;

5266

struct alc_spec *spec = codec->spec;

5263

static const struct hda_verb gpio_init[] = {

5267

static const struct hda_verb gpio_init[] = {

5264

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },

5268

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },

5265

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },

5269

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },

5266

{}

5270

{}

5267

};

5271

};

5268

5272

5269

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

5273

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

5270

spec->gen.vmaster_mute.hook = alc662_led_gpio1_mute_hook;

5274

spec->gen.vmaster_mute.hook = alc662_led_gpio1_mute_hook;

5271

spec->gpio_led = 0;

5275

spec->gpio_led = 0;

5272

snd_hda_add_verbs(codec, gpio_init);

5276

snd_hda_add_verbs(codec, gpio_init);

5273

codec->power_filter = gpio_led_power_filter;

5277

codec->power_filter = gpio_led_power_filter;

5274

}

5278

}

5275

}

5279

}

5276

5280

5277

enum {

5281

enum {

5278

ALC662_FIXUP_ASPIRE,

5282

ALC662_FIXUP_ASPIRE,

5279

ALC662_FIXUP_LED_GPIO1,

5283

ALC662_FIXUP_LED_GPIO1,

5280

ALC662_FIXUP_IDEAPAD,

5284

ALC662_FIXUP_IDEAPAD,

5281

ALC272_FIXUP_MARIO,

5285

ALC272_FIXUP_MARIO,

5282

ALC662_FIXUP_CZC_P10T,

5286

ALC662_FIXUP_CZC_P10T,

5283

ALC662_FIXUP_SKU_IGNORE,

5287

ALC662_FIXUP_SKU_IGNORE,

5284

ALC662_FIXUP_HP_RP5800,

5288

ALC662_FIXUP_HP_RP5800,

5285

ALC662_FIXUP_ASUS_MODE1,

5289

ALC662_FIXUP_ASUS_MODE1,

5286

ALC662_FIXUP_ASUS_MODE2,

5290

ALC662_FIXUP_ASUS_MODE2,

5287

ALC662_FIXUP_ASUS_MODE3,

5291

ALC662_FIXUP_ASUS_MODE3,

5288

ALC662_FIXUP_ASUS_MODE4,

5292

ALC662_FIXUP_ASUS_MODE4,

5289

ALC662_FIXUP_ASUS_MODE5,

5293

ALC662_FIXUP_ASUS_MODE5,

5290

ALC662_FIXUP_ASUS_MODE6,

5294

ALC662_FIXUP_ASUS_MODE6,

5291

ALC662_FIXUP_ASUS_MODE7,

5295

ALC662_FIXUP_ASUS_MODE7,

5292

ALC662_FIXUP_ASUS_MODE8,

5296

ALC662_FIXUP_ASUS_MODE8,

5293

ALC662_FIXUP_NO_JACK_DETECT,

5297

ALC662_FIXUP_NO_JACK_DETECT,

5294

ALC662_FIXUP_ZOTAC_Z68,

5298

ALC662_FIXUP_ZOTAC_Z68,

5295

ALC662_FIXUP_INV_DMIC,

5299

ALC662_FIXUP_INV_DMIC,

5296

ALC668_FIXUP_DELL_MIC_NO_PRESENCE,

5300

ALC668_FIXUP_DELL_MIC_NO_PRESENCE,

5297

ALC668_FIXUP_HEADSET_MODE,

5301

ALC668_FIXUP_HEADSET_MODE,

5298

ALC662_FIXUP_BASS_MODE4_CHMAP,

5302

ALC662_FIXUP_BASS_MODE4_CHMAP,

5299

ALC662_FIXUP_BASS_16,

5303

ALC662_FIXUP_BASS_16,

5300

ALC662_FIXUP_BASS_1A,

5304

ALC662_FIXUP_BASS_1A,

5301

ALC662_FIXUP_BASS_CHMAP,

5305

ALC662_FIXUP_BASS_CHMAP,

5302

ALC668_FIXUP_AUTO_MUTE,

5306

ALC668_FIXUP_AUTO_MUTE,

5303

};

5307

};

5304

5308

5305

static const struct hda_fixup alc662_fixups[] = {

5309

static const struct hda_fixup alc662_fixups[] = {

5306

[ALC662_FIXUP_ASPIRE] = {

5310

[ALC662_FIXUP_ASPIRE] = {

5307

.type = HDA_FIXUP_PINS,

5311

.type = HDA_FIXUP_PINS,

5308

.v.pins = (const struct hda_pintbl[]) {

5312

.v.pins = (const struct hda_pintbl[]) {

5309

{ 0x15, 0x99130112 }, /* subwoofer */

5313

{ 0x15, 0x99130112 }, /* subwoofer */

5310

{ }

5314

{ }

5311

}

5315

}

5312

},

5316

},

5313

[ALC662_FIXUP_LED_GPIO1] = {

5317

[ALC662_FIXUP_LED_GPIO1] = {

5314

.type = HDA_FIXUP_FUNC,

5318

.type = HDA_FIXUP_FUNC,

5315

.v.func = alc662_fixup_led_gpio1,

5319

.v.func = alc662_fixup_led_gpio1,

5316

},

5320

},

5317

[ALC662_FIXUP_IDEAPAD] = {

5321

[ALC662_FIXUP_IDEAPAD] = {

5318

.type = HDA_FIXUP_PINS,

5322

.type = HDA_FIXUP_PINS,

5319

.v.pins = (const struct hda_pintbl[]) {

5323

.v.pins = (const struct hda_pintbl[]) {

5320

{ 0x17, 0x99130112 }, /* subwoofer */

5324

{ 0x17, 0x99130112 }, /* subwoofer */

5321

{ }

5325

{ }

5322

},

5326

},

5323

.chained = true,

5327

.chained = true,

5324

.chain_id = ALC662_FIXUP_LED_GPIO1,

5328

.chain_id = ALC662_FIXUP_LED_GPIO1,

5325

},

5329

},

5326

[ALC272_FIXUP_MARIO] = {

5330

[ALC272_FIXUP_MARIO] = {

5327

.type = HDA_FIXUP_FUNC,

5331

.type = HDA_FIXUP_FUNC,

5328

.v.func = alc272_fixup_mario,

5332

.v.func = alc272_fixup_mario,

5329

},

5333

},

5330

[ALC662_FIXUP_CZC_P10T] = {

5334

[ALC662_FIXUP_CZC_P10T] = {

5331

.type = HDA_FIXUP_VERBS,

5335

.type = HDA_FIXUP_VERBS,

5332

.v.verbs = (const struct hda_verb[]) {

5336

.v.verbs = (const struct hda_verb[]) {

5333

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

5337

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

5334

{}

5338

{}

5335

}

5339

}

5336

},

5340

},

5337

[ALC662_FIXUP_SKU_IGNORE] = {

5341

[ALC662_FIXUP_SKU_IGNORE] = {

5338

.type = HDA_FIXUP_FUNC,

5342

.type = HDA_FIXUP_FUNC,

5339

.v.func = alc_fixup_sku_ignore,

5343

.v.func = alc_fixup_sku_ignore,

5340

},

5344

},

5341

[ALC662_FIXUP_HP_RP5800] = {

5345

[ALC662_FIXUP_HP_RP5800] = {

5342

.type = HDA_FIXUP_PINS,

5346

.type = HDA_FIXUP_PINS,

5343

.v.pins = (const struct hda_pintbl[]) {

5347

.v.pins = (const struct hda_pintbl[]) {

5344

{ 0x14, 0x0221201f }, /* HP out */

5348

{ 0x14, 0x0221201f }, /* HP out */

5345

{ }

5349

{ }

5346

},

5350

},

5347

.chained = true,

5351

.chained = true,

5348

.chain_id = ALC662_FIXUP_SKU_IGNORE

5352

.chain_id = ALC662_FIXUP_SKU_IGNORE

5349

},

5353

},

5350

[ALC662_FIXUP_ASUS_MODE1] = {

5354

[ALC662_FIXUP_ASUS_MODE1] = {

5351

.type = HDA_FIXUP_PINS,

5355

.type = HDA_FIXUP_PINS,

5352

.v.pins = (const struct hda_pintbl[]) {

5356

.v.pins = (const struct hda_pintbl[]) {

5353

{ 0x14, 0x99130110 }, /* speaker */

5357

{ 0x14, 0x99130110 }, /* speaker */

5354

{ 0x18, 0x01a19c20 }, /* mic */

5358

{ 0x18, 0x01a19c20 }, /* mic */

5355

{ 0x19, 0x99a3092f }, /* int-mic */

5359

{ 0x19, 0x99a3092f }, /* int-mic */

5356

{ 0x21, 0x0121401f }, /* HP out */

5360

{ 0x21, 0x0121401f }, /* HP out */

5357

{ }

5361

{ }

5358

},

5362

},

5359

.chained = true,

5363

.chained = true,

5360

.chain_id = ALC662_FIXUP_SKU_IGNORE

5364

.chain_id = ALC662_FIXUP_SKU_IGNORE

5361

},

5365

},

5362

[ALC662_FIXUP_ASUS_MODE2] = {

5366

[ALC662_FIXUP_ASUS_MODE2] = {

5363

.type = HDA_FIXUP_PINS,

5367

.type = HDA_FIXUP_PINS,

5364

.v.pins = (const struct hda_pintbl[]) {

5368

.v.pins = (const struct hda_pintbl[]) {

5365

{ 0x14, 0x99130110 }, /* speaker */

5369

{ 0x14, 0x99130110 }, /* speaker */

5366

{ 0x18, 0x01a19820 }, /* mic */

5370

{ 0x18, 0x01a19820 }, /* mic */

5367

{ 0x19, 0x99a3092f }, /* int-mic */

5371

{ 0x19, 0x99a3092f }, /* int-mic */

5368

{ 0x1b, 0x0121401f }, /* HP out */

5372

{ 0x1b, 0x0121401f }, /* HP out */

5369

{ }

5373

{ }

5370

},

5374

},

5371

.chained = true,

5375

.chained = true,

5372

.chain_id = ALC662_FIXUP_SKU_IGNORE

5376

.chain_id = ALC662_FIXUP_SKU_IGNORE

5373

},

5377

},

5374

[ALC662_FIXUP_ASUS_MODE3] = {

5378

[ALC662_FIXUP_ASUS_MODE3] = {

5375

.type = HDA_FIXUP_PINS,

5379

.type = HDA_FIXUP_PINS,

5376

.v.pins = (const struct hda_pintbl[]) {

5380

.v.pins = (const struct hda_pintbl[]) {

5377

{ 0x14, 0x99130110 }, /* speaker */

5381

{ 0x14, 0x99130110 }, /* speaker */

5378

{ 0x15, 0x0121441f }, /* HP */

5382

{ 0x15, 0x0121441f }, /* HP */

5379

{ 0x18, 0x01a19840 }, /* mic */

5383

{ 0x18, 0x01a19840 }, /* mic */

5380

{ 0x19, 0x99a3094f }, /* int-mic */

5384

{ 0x19, 0x99a3094f }, /* int-mic */

5381

{ 0x21, 0x01211420 }, /* HP2 */

5385

{ 0x21, 0x01211420 }, /* HP2 */

5382

{ }

5386

{ }

5383

},

5387

},

5384

.chained = true,

5388

.chained = true,

5385

.chain_id = ALC662_FIXUP_SKU_IGNORE

5389

.chain_id = ALC662_FIXUP_SKU_IGNORE

5386

},

5390

},

5387

[ALC662_FIXUP_ASUS_MODE4] = {

5391

[ALC662_FIXUP_ASUS_MODE4] = {

5388

.type = HDA_FIXUP_PINS,

5392

.type = HDA_FIXUP_PINS,

5389

.v.pins = (const struct hda_pintbl[]) {

5393

.v.pins = (const struct hda_pintbl[]) {

5390

{ 0x14, 0x99130110 }, /* speaker */

5394

{ 0x14, 0x99130110 }, /* speaker */

5391

{ 0x16, 0x99130111 }, /* speaker */

5395

{ 0x16, 0x99130111 }, /* speaker */

5392

{ 0x18, 0x01a19840 }, /* mic */

5396

{ 0x18, 0x01a19840 }, /* mic */

5393

{ 0x19, 0x99a3094f }, /* int-mic */

5397

{ 0x19, 0x99a3094f }, /* int-mic */

5394

{ 0x21, 0x0121441f }, /* HP */

5398

{ 0x21, 0x0121441f }, /* HP */

5395

{ }

5399

{ }

5396

},

5400

},

5397

.chained = true,

5401

.chained = true,

5398

.chain_id = ALC662_FIXUP_SKU_IGNORE

5402

.chain_id = ALC662_FIXUP_SKU_IGNORE

5399

},

5403

},

5400

[ALC662_FIXUP_ASUS_MODE5] = {

5404

[ALC662_FIXUP_ASUS_MODE5] = {

5401

.type = HDA_FIXUP_PINS,

5405

.type = HDA_FIXUP_PINS,

5402

.v.pins = (const struct hda_pintbl[]) {

5406

.v.pins = (const struct hda_pintbl[]) {

5403

{ 0x14, 0x99130110 }, /* speaker */

5407

{ 0x14, 0x99130110 }, /* speaker */

5404

{ 0x15, 0x0121441f }, /* HP */

5408

{ 0x15, 0x0121441f }, /* HP */

5405

{ 0x16, 0x99130111 }, /* speaker */

5409

{ 0x16, 0x99130111 }, /* speaker */

5406

{ 0x18, 0x01a19840 }, /* mic */

5410

{ 0x18, 0x01a19840 }, /* mic */

5407

{ 0x19, 0x99a3094f }, /* int-mic */

5411

{ 0x19, 0x99a3094f }, /* int-mic */

5408

{ }

5412

{ }

5409

},

5413

},

5410

.chained = true,

5414

.chained = true,

5411

.chain_id = ALC662_FIXUP_SKU_IGNORE

5415

.chain_id = ALC662_FIXUP_SKU_IGNORE

5412

},

5416

},

5413

[ALC662_FIXUP_ASUS_MODE6] = {

5417

[ALC662_FIXUP_ASUS_MODE6] = {

5414

.type = HDA_FIXUP_PINS,

5418

.type = HDA_FIXUP_PINS,

5415

.v.pins = (const struct hda_pintbl[]) {

5419

.v.pins = (const struct hda_pintbl[]) {

5416

{ 0x14, 0x99130110 }, /* speaker */

5420

{ 0x14, 0x99130110 }, /* speaker */

5417

{ 0x15, 0x01211420 }, /* HP2 */

5421

{ 0x15, 0x01211420 }, /* HP2 */

5418

{ 0x18, 0x01a19840 }, /* mic */

5422

{ 0x18, 0x01a19840 }, /* mic */

5419

{ 0x19, 0x99a3094f }, /* int-mic */

5423

{ 0x19, 0x99a3094f }, /* int-mic */

5420

{ 0x1b, 0x0121441f }, /* HP */

5424

{ 0x1b, 0x0121441f }, /* HP */

5421

{ }

5425

{ }

5422

},

5426

},

5423

.chained = true,

5427

.chained = true,

5424

.chain_id = ALC662_FIXUP_SKU_IGNORE

5428

.chain_id = ALC662_FIXUP_SKU_IGNORE

5425

},

5429

},

5426

[ALC662_FIXUP_ASUS_MODE7] = {

5430

[ALC662_FIXUP_ASUS_MODE7] = {

5427

.type = HDA_FIXUP_PINS,

5431

.type = HDA_FIXUP_PINS,

5428

.v.pins = (const struct hda_pintbl[]) {

5432

.v.pins = (const struct hda_pintbl[]) {

5429

{ 0x14, 0x99130110 }, /* speaker */

5433

{ 0x14, 0x99130110 }, /* speaker */

5430

{ 0x17, 0x99130111 }, /* speaker */

5434

{ 0x17, 0x99130111 }, /* speaker */

5431

{ 0x18, 0x01a19840 }, /* mic */

5435

{ 0x18, 0x01a19840 }, /* mic */

5432

{ 0x19, 0x99a3094f }, /* int-mic */

5436

{ 0x19, 0x99a3094f }, /* int-mic */

5433

{ 0x1b, 0x01214020 }, /* HP */

5437

{ 0x1b, 0x01214020 }, /* HP */

5434

{ 0x21, 0x0121401f }, /* HP */

5438

{ 0x21, 0x0121401f }, /* HP */

5435

{ }

5439

{ }

5436

},

5440

},

5437

.chained = true,

5441

.chained = true,

5438

.chain_id = ALC662_FIXUP_SKU_IGNORE

5442

.chain_id = ALC662_FIXUP_SKU_IGNORE

5439

},

5443

},

5440

[ALC662_FIXUP_ASUS_MODE8] = {

5444

[ALC662_FIXUP_ASUS_MODE8] = {

5441

.type = HDA_FIXUP_PINS,

5445

.type = HDA_FIXUP_PINS,

5442

.v.pins = (const struct hda_pintbl[]) {

5446

.v.pins = (const struct hda_pintbl[]) {

5443

{ 0x14, 0x99130110 }, /* speaker */

5447

{ 0x14, 0x99130110 }, /* speaker */

5444

{ 0x12, 0x99a30970 }, /* int-mic */

5448

{ 0x12, 0x99a30970 }, /* int-mic */

5445

{ 0x15, 0x01214020 }, /* HP */

5449

{ 0x15, 0x01214020 }, /* HP */

5446

{ 0x17, 0x99130111 }, /* speaker */

5450

{ 0x17, 0x99130111 }, /* speaker */

5447

{ 0x18, 0x01a19840 }, /* mic */

5451

{ 0x18, 0x01a19840 }, /* mic */

5448

{ 0x21, 0x0121401f }, /* HP */

5452

{ 0x21, 0x0121401f }, /* HP */

5449

{ }

5453

{ }

5450

},

5454

},

5451

.chained = true,

5455

.chained = true,

5452

.chain_id = ALC662_FIXUP_SKU_IGNORE

5456

.chain_id = ALC662_FIXUP_SKU_IGNORE

5453

},

5457

},

5454

[ALC662_FIXUP_NO_JACK_DETECT] = {

5458

[ALC662_FIXUP_NO_JACK_DETECT] = {

5455

.type = HDA_FIXUP_FUNC,

5459

.type = HDA_FIXUP_FUNC,

5456

.v.func = alc_fixup_no_jack_detect,

5460

.v.func = alc_fixup_no_jack_detect,

5457

},

5461

},

5458

[ALC662_FIXUP_ZOTAC_Z68] = {

5462

[ALC662_FIXUP_ZOTAC_Z68] = {

5459

.type = HDA_FIXUP_PINS,

5463

.type = HDA_FIXUP_PINS,

5460

.v.pins = (const struct hda_pintbl[]) {

5464

.v.pins = (const struct hda_pintbl[]) {

5461

{ 0x1b, 0x02214020 }, /* Front HP */

5465

{ 0x1b, 0x02214020 }, /* Front HP */

5462

{ }

5466

{ }

5463

}

5467

}

5464

},

5468

},

5465

[ALC662_FIXUP_INV_DMIC] = {

5469

[ALC662_FIXUP_INV_DMIC] = {

5466

.type = HDA_FIXUP_FUNC,

5470

.type = HDA_FIXUP_FUNC,

5467

.v.func = alc_fixup_inv_dmic_0x12,

5471

.v.func = alc_fixup_inv_dmic_0x12,

5468

},

5472

},

5469

[ALC668_FIXUP_AUTO_MUTE] = {

5473

[ALC668_FIXUP_AUTO_MUTE] = {

5470

.type = HDA_FIXUP_FUNC,

5474

.type = HDA_FIXUP_FUNC,

5471

.v.func = alc_fixup_auto_mute_via_amp,

5475

.v.func = alc_fixup_auto_mute_via_amp,

5472

.chained = true,

5476

.chained = true,

5473

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

5477

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

5474

},

5478

},

5475

[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {

5479

[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {

5476

.type = HDA_FIXUP_PINS,

5480

.type = HDA_FIXUP_PINS,

5477

.v.pins = (const struct hda_pintbl[]) {

5481

.v.pins = (const struct hda_pintbl[]) {

5478

{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */

5482

{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */

5479

{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */

5483

{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */

5480

{ }

5484

{ }

5481

},

5485

},

5482

.chained = true,

5486

.chained = true,

5483

.chain_id = ALC668_FIXUP_HEADSET_MODE

5487

.chain_id = ALC668_FIXUP_HEADSET_MODE

5484

},

5488

},

5485

[ALC668_FIXUP_HEADSET_MODE] = {

5489

[ALC668_FIXUP_HEADSET_MODE] = {

5486

.type = HDA_FIXUP_FUNC,

5490

.type = HDA_FIXUP_FUNC,

5487

.v.func = alc_fixup_headset_mode_alc668,

5491

.v.func = alc_fixup_headset_mode_alc668,

5488

},

5492

},

5489

[ALC662_FIXUP_BASS_MODE4_CHMAP] = {

5493

[ALC662_FIXUP_BASS_MODE4_CHMAP] = {

5490

.type = HDA_FIXUP_FUNC,

5494

.type = HDA_FIXUP_FUNC,

5491

.v.func = alc_fixup_bass_chmap,

5495

.v.func = alc_fixup_bass_chmap,

5492

.chained = true,

5496

.chained = true,

5493

.chain_id = ALC662_FIXUP_ASUS_MODE4

5497

.chain_id = ALC662_FIXUP_ASUS_MODE4

5494

},

5498

},

5495

[ALC662_FIXUP_BASS_16] = {

5499

[ALC662_FIXUP_BASS_16] = {

5496

.type = HDA_FIXUP_PINS,

5500

.type = HDA_FIXUP_PINS,

5497

.v.pins = (const struct hda_pintbl[]) {

5501

.v.pins = (const struct hda_pintbl[]) {

5498

{0x16, 0x80106111}, /* bass speaker */

5502

{0x16, 0x80106111}, /* bass speaker */

5499

{}

5503

{}

5500

},

5504

},

5501

.chained = true,

5505

.chained = true,

5502

.chain_id = ALC662_FIXUP_BASS_CHMAP,

5506

.chain_id = ALC662_FIXUP_BASS_CHMAP,

5503

},

5507

},

5504

[ALC662_FIXUP_BASS_1A] = {

5508

[ALC662_FIXUP_BASS_1A] = {

5505

.type = HDA_FIXUP_PINS,

5509

.type = HDA_FIXUP_PINS,

5506

.v.pins = (const struct hda_pintbl[]) {

5510

.v.pins = (const struct hda_pintbl[]) {

5507

{0x1a, 0x80106111}, /* bass speaker */

5511

{0x1a, 0x80106111}, /* bass speaker */

5508

{}

5512

{}

5509

},

5513

},

5510

.chained = true,

5514

.chained = true,

5511

.chain_id = ALC662_FIXUP_BASS_CHMAP,

5515

.chain_id = ALC662_FIXUP_BASS_CHMAP,

5512

},

5516

},

5513

[ALC662_FIXUP_BASS_CHMAP] = {

5517

[ALC662_FIXUP_BASS_CHMAP] = {

5514

.type = HDA_FIXUP_FUNC,

5518

.type = HDA_FIXUP_FUNC,

5515

.v.func = alc_fixup_bass_chmap,

5519

.v.func = alc_fixup_bass_chmap,

5516

},

5520

},

5517

};

5521

};

5518

5522

5519

static const struct snd_pci_quirk alc662_fixup_tbl[] = {

5523

static const struct snd_pci_quirk alc662_fixup_tbl[] = {

5520

SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),

5524

SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),

5521

SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),

5525

SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),

5522

SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),

5526

SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),

5523

SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),

5527

SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),

5524

SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),

5528

SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),

5525

SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),

5529

SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),

5526

SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),

5530

SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),

5527

SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5531

SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5528

SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5532

SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5529

SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5533

SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5530

SND_PCI_QUIRK(0x1028, 0x0623, "Dell", ALC668_FIXUP_AUTO_MUTE),

5534

SND_PCI_QUIRK(0x1028, 0x0623, "Dell", ALC668_FIXUP_AUTO_MUTE),

5531

SND_PCI_QUIRK(0x1028, 0x0624, "Dell", ALC668_FIXUP_AUTO_MUTE),

5535

SND_PCI_QUIRK(0x1028, 0x0624, "Dell", ALC668_FIXUP_AUTO_MUTE),

5532

SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5536

SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5533

SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5537

SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

5534

SND_PCI_QUIRK(0x1028, 0x0628, "Dell", ALC668_FIXUP_AUTO_MUTE),

5538

SND_PCI_QUIRK(0x1028, 0x0628, "Dell", ALC668_FIXUP_AUTO_MUTE),

5535

SND_PCI_QUIRK(0x1028, 0x064e, "Dell", ALC668_FIXUP_AUTO_MUTE),

5539

SND_PCI_QUIRK(0x1028, 0x064e, "Dell", ALC668_FIXUP_AUTO_MUTE),

5536

SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),

5540

SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),

5537

SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),

5541

SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),

5538

SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

5542

SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

5539

SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),

5543

SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),

5540

SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),

5544

SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),

5541

SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

5545

SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

5542

SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),

5546

SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),

5543

SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),

5547

SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),

5544

SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),

5548

SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),

5545

SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),

5549

SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),

5546

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),

5550

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),

5547

SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),

5551

SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),

5548

SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),

5552

SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),

5549

5553

5550

#if 0

5554

#if 0

5551

/* Below is a quirk table taken from the old code.

5555

/* Below is a quirk table taken from the old code.

5552

* Basically the device should work as is without the fixup table.

5556

* Basically the device should work as is without the fixup table.

5553

* If BIOS doesn't give a proper info, enable the corresponding

5557

* If BIOS doesn't give a proper info, enable the corresponding

5554

* fixup entry.

5558

* fixup entry.

5555

*/

5559

*/

5556

SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),

5560

SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),

5557

SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),

5561

SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),

5558

SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),

5562

SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),

5559

SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),

5563

SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),

5560

SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5564

SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5561

SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5565

SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5562

SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5566

SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5563

SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),

5567

SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),

5564

SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),

5568

SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),

5565

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5569

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5566

SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),

5570

SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),

5567

SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),

5571

SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),

5568

SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),

5572

SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),

5569

SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),

5573

SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),

5570

SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),

5574

SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),

5571

SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5575

SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5572

SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),

5576

SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),

5573

SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),

5577

SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),

5574

SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5578

SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5575

SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5579

SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5576

SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5580

SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5577

SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5581

SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5578

SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),

5582

SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),

5579

SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),

5583

SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),

5580

SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),

5584

SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),

5581

SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5585

SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5582

SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),

5586

SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),

5583

SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5587

SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

5584

SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5588

SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5585

SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),

5589

SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),

5586

SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5590

SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5587

SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5591

SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5588

SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),

5592

SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),

5589

SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),

5593

SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),

5590

SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),

5594

SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),

5591

SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),

5595

SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),

5592

SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),

5596

SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),

5593

SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),

5597

SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),

5594

SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),

5598

SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),

5595

SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5599

SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

5596

SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),

5600

SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),

5597

SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),

5601

SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),

5598

SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5602

SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5599

SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),

5603

SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),

5600

SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),

5604

SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),

5601

SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),

5605

SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),

5602

SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),

5606

SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),

5603

SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),

5607

SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),

5604

SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5608

SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

5605

SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),

5609

SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),

5606

#endif

5610

#endif

5607

{}

5611

{}

5608

};

5612

};

5609

5613

5610

static const struct hda_model_fixup alc662_fixup_models[] = {

5614

static const struct hda_model_fixup alc662_fixup_models[] = {

5611

{.id = ALC272_FIXUP_MARIO, .name = "mario"},

5615

{.id = ALC272_FIXUP_MARIO, .name = "mario"},

5612

{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},

5616

{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},

5613

{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},

5617

{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},

5614

{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},

5618

{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},

5615

{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},

5619

{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},

5616

{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},

5620

{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},

5617

{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},

5621

{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},

5618

{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},

5622

{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},

5619

{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},

5623

{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},

5620

{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},

5624

{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},

5621

{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

5625

{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

5622

{}

5626

{}

5623

};

5627

};

5624

5628

5625

static void alc662_fill_coef(struct hda_codec *codec)

5629

static void alc662_fill_coef(struct hda_codec *codec)

5626

{

5630

{

5627

int val, coef;

5631

int val, coef;

5628

5632

5629

coef = alc_get_coef0(codec);

5633

coef = alc_get_coef0(codec);

5630

5634

5631

switch (codec->vendor_id) {

5635

switch (codec->vendor_id) {

5632

case 0x10ec0662:

5636

case 0x10ec0662:

5633

if ((coef & 0x00f0) == 0x0030) {

5637

if ((coef & 0x00f0) == 0x0030) {

5634

val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */

5638

val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */

5635

alc_write_coef_idx(codec, 0x4, val & ~(1<<10));

5639

alc_write_coef_idx(codec, 0x4, val & ~(1<<10));

5636

}

5640

}

5637

break;

5641

break;

5638

case 0x10ec0272:

5642

case 0x10ec0272:

5639

case 0x10ec0273:

5643

case 0x10ec0273:

5640

case 0x10ec0663:

5644

case 0x10ec0663:

5641

case 0x10ec0665:

5645

case 0x10ec0665:

5642

case 0x10ec0670:

5646

case 0x10ec0670:

5643

case 0x10ec0671:

5647

case 0x10ec0671:

5644

case 0x10ec0672:

5648

case 0x10ec0672:

5645

val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */

5649

val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */

5646

alc_write_coef_idx(codec, 0xd, val | (1<<14));

5650

alc_write_coef_idx(codec, 0xd, val | (1<<14));

5647

break;

5651

break;

5648

}

5652

}

5649

}

5653

}

5650

5654

5651

/*

5655

/*

5652

*/

5656

*/

5653

static int patch_alc662(struct hda_codec *codec)

5657

static int patch_alc662(struct hda_codec *codec)

5654

{

5658

{

5655

struct alc_spec *spec;

5659

struct alc_spec *spec;

5656

int err;

5660

int err;

5657

5661

5658

err = alc_alloc_spec(codec, 0x0b);

5662

err = alc_alloc_spec(codec, 0x0b);

5659

if (err < 0)

5663

if (err < 0)

5660

return err;

5664

return err;

5661

5665

5662

spec = codec->spec;

5666

spec = codec->spec;

5663

5667

5664

/* handle multiple HPs as is */

5668

/* handle multiple HPs as is */

5665

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

5669

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

5666

5670

5667

alc_fix_pll_init(codec, 0x20, 0x04, 15);

5671

alc_fix_pll_init(codec, 0x20, 0x04, 15);

5668

5672

5669

spec->init_hook = alc662_fill_coef;

5673

spec->init_hook = alc662_fill_coef;

5670

alc662_fill_coef(codec);

5674

alc662_fill_coef(codec);

5671

5675

5672

snd_hda_pick_fixup(codec, alc662_fixup_models,

5676

snd_hda_pick_fixup(codec, alc662_fixup_models,

5673

alc662_fixup_tbl, alc662_fixups);

5677

alc662_fixup_tbl, alc662_fixups);

5674

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5678

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5675

5679

5676

alc_auto_parse_customize_define(codec);

5680

alc_auto_parse_customize_define(codec);

5677

5681

5678

if (has_cdefine_beep(codec))

5682

if (has_cdefine_beep(codec))

5679

spec->gen.beep_nid = 0x01;

5683

spec->gen.beep_nid = 0x01;

5680

5684

5681

if ((alc_get_coef0(codec) & (1 << 14)) &&

5685

if ((alc_get_coef0(codec) & (1 << 14)) &&

5682

codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&

5686

codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&

5683

spec->cdefine.platform_type == 1) {

5687

spec->cdefine.platform_type == 1) {

5684

err = alc_codec_rename(codec, "ALC272X");

5688

err = alc_codec_rename(codec, "ALC272X");

5685

if (err < 0)

5689

if (err < 0)

5686

goto error;

5690

goto error;

5687

}

5691

}

5688

5692

5689

/* automatic parse from the BIOS config */

5693

/* automatic parse from the BIOS config */

5690

err = alc662_parse_auto_config(codec);

5694

err = alc662_parse_auto_config(codec);

5691

if (err < 0)

5695

if (err < 0)

5692

goto error;

5696

goto error;

5693

5697

5694

if (!spec->gen.no_analog && spec->gen.beep_nid) {

5698

if (!spec->gen.no_analog && spec->gen.beep_nid) {

5695

switch (codec->vendor_id) {

5699

switch (codec->vendor_id) {

5696

case 0x10ec0662:

5700

case 0x10ec0662:

5697

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

5701

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

5698

break;

5702

break;

5699

case 0x10ec0272:

5703

case 0x10ec0272:

5700

case 0x10ec0663:

5704

case 0x10ec0663:

5701

case 0x10ec0665:

5705

case 0x10ec0665:

5702

case 0x10ec0668:

5706

case 0x10ec0668:

5703

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

5707

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

5704

break;

5708

break;

5705

case 0x10ec0273:

5709

case 0x10ec0273:

5706

set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);

5710

set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);

5707

break;

5711

break;

5708

}

5712

}

5709

}

5713

}

5710

5714

5711

codec->patch_ops = alc_patch_ops;

5715

codec->patch_ops = alc_patch_ops;

5712

spec->shutup = alc_eapd_shutup;

5716

spec->shutup = alc_eapd_shutup;

5713

5717

5714

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5718

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5715

5719

5716

return 0;

5720

return 0;

5717

5721

5718

error:

5722

error:

5719

alc_free(codec);

5723

alc_free(codec);

5720

return err;

5724

return err;

5721

}

5725

}

5722

5726

5723

/*

5727

/*

5724

* ALC680 support

5728

* ALC680 support

5725

*/

5729

*/

5726

5730

5727

static int alc680_parse_auto_config(struct hda_codec *codec)

5731

static int alc680_parse_auto_config(struct hda_codec *codec)

5728

{

5732

{

5729

return alc_parse_auto_config(codec, NULL, NULL);

5733

return alc_parse_auto_config(codec, NULL, NULL);

5730

}

5734

}

5731

5735

5732

/*

5736

/*

5733

*/

5737

*/

5734

static int patch_alc680(struct hda_codec *codec)

5738

static int patch_alc680(struct hda_codec *codec)

5735

{

5739

{

5736

int err;

5740

int err;

5737

5741

5738

/* ALC680 has no aa-loopback mixer */

5742

/* ALC680 has no aa-loopback mixer */

5739

err = alc_alloc_spec(codec, 0);

5743

err = alc_alloc_spec(codec, 0);

5740

if (err < 0)

5744

if (err < 0)

5741

return err;

5745

return err;

5742

5746

5743

/* automatic parse from the BIOS config */

5747

/* automatic parse from the BIOS config */

5744

err = alc680_parse_auto_config(codec);

5748

err = alc680_parse_auto_config(codec);

5745

if (err < 0) {

5749

if (err < 0) {

5746

alc_free(codec);

5750

alc_free(codec);

5747

return err;

5751

return err;

5748

}

5752

}

5749

5753

5750

codec->patch_ops = alc_patch_ops;

5754

codec->patch_ops = alc_patch_ops;

5751

5755

5752

return 0;

5756

return 0;

5753

}

5757

}

5754

5758

5755

/*

5759

/*

5756

* patch entries

5760

* patch entries

5757

*/

5761

*/

5758

static const struct hda_codec_preset snd_hda_preset_realtek[] = {

5762

static const struct hda_codec_preset snd_hda_preset_realtek[] = {

5759

{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },

5763

{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },

5760

{ .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },

5764

{ .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },

5761

{ .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },

5765

{ .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },

5762

{ .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },

5766

{ .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },

5763

{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },

5767

{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },

5764

{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },

5768

{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },

5765

{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },

5769

{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },

5766

{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },

5770

{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },

5767

{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },

5771

{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },

5768

{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },

5772

{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },

5769

{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },

5773

{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },

5770

{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },

5774

{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },

5771

{ .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },

5775

{ .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },

5772

{ .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },

5776

{ .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },

5773

{ .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },

5777

{ .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },

5774

{ .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },

5778

{ .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },

5775

{ .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },

5779

{ .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },

5776

{ .id = 0x10ec0285, .name = "ALC285", .patch = patch_alc269 },

5780

{ .id = 0x10ec0285, .name = "ALC285", .patch = patch_alc269 },

5777

{ .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },

5781

{ .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },

5778

{ .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },

5782

{ .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },

5779

{ .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },

5783

{ .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },

5780

{ .id = 0x10ec0293, .name = "ALC293", .patch = patch_alc269 },

5784

{ .id = 0x10ec0293, .name = "ALC293", .patch = patch_alc269 },

5781

{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",

5785

{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",

5782

.patch = patch_alc861 },

5786

.patch = patch_alc861 },

5783

{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },

5787

{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },

5784

{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },

5788

{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },

5785

{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },

5789

{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },

5786

{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",

5790

{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",

5787

.patch = patch_alc882 },

5791

.patch = patch_alc882 },

5788

{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",

5792

{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",

5789

.patch = patch_alc662 },

5793

.patch = patch_alc662 },

5790

{ .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",

5794

{ .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",

5791

.patch = patch_alc662 },

5795

.patch = patch_alc662 },

5792

{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },

5796

{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },

5793

{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },

5797

{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },

5794

{ .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },

5798

{ .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },

5795

{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },

5799

{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },

5796

{ .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },

5800

{ .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },

5797

{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },

5801

{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },

5798

{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },

5802

{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },

5799

{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },

5803

{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },

5800

{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },

5804

{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },

5801

{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",

5805

{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",

5802

.patch = patch_alc882 },

5806

.patch = patch_alc882 },

5803

{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",

5807

{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",

5804

.patch = patch_alc882 },

5808

.patch = patch_alc882 },

5805

{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },

5809

{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },

5806

{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },

5810

{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },

5807

{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",

5811

{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",

5808

.patch = patch_alc882 },

5812

.patch = patch_alc882 },

5809

{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },

5813

{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },

5810

{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },

5814

{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },

5811

{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },

5815

{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },

5812

{ .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },

5816

{ .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },

5813

{ .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },

5817

{ .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },

5814

{} /* terminator */

5818

{} /* terminator */

5815

};

5819

};

5816

5820

5817

MODULE_ALIAS("snd-hda-codec-id:10ec*");

5821

MODULE_ALIAS("snd-hda-codec-id:10ec*");

5818

5822

5819

MODULE_LICENSE("GPL");

5823

MODULE_LICENSE("GPL");

5820

MODULE_DESCRIPTION("Realtek HD-audio codec");

5824

MODULE_DESCRIPTION("Realtek HD-audio codec");

5821

5825

5822

static struct hda_codec_preset_list realtek_list = {

5826

static struct hda_codec_preset_list realtek_list = {

5823

.preset = snd_hda_preset_realtek,

5827

.preset = snd_hda_preset_realtek,

5824

.owner = THIS_MODULE,

5828

.owner = THIS_MODULE,

5825

};

5829

};

5826

5830

5827

static int __init patch_realtek_init(void)

5831

static int __init patch_realtek_init(void)

5828

{

5832

{

5829

return snd_hda_add_codec_preset(&realtek_list);

5833

return snd_hda_add_codec_preset(&realtek_list);

5830

}

5834

}

5831

5835

5832

static void __exit patch_realtek_exit(void)

5836

static void __exit patch_realtek_exit(void)

5833

{

5837

{

5834

snd_hda_delete_codec_preset(&realtek_list);

5838

snd_hda_delete_codec_preset(&realtek_list);

5835

}

5839

}

5836

5840

5837

module_init(patch_realtek_init)

5841

module_init(patch_realtek_init)

5838

module_exit(patch_realtek_exit)

5842

module_exit(patch_realtek_exit)

5839

5843

GITLAB

ALSA: hda/realtek - Improve HP depop when system change power state on Chromebook

 /*
  * Universal Interface for Intel High Definition Audio Codec
  *
  * HD audio interface patch for Realtek ALC codecs
  *
  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
  *                    PeiSen Hou <pshou@realtek.com.tw>
  *                    Takashi Iwai <tiwai@suse.de>
  *                    Jonathan Woithe <jwoithe@just42.net>
  *
  *  This driver is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This driver 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.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/dmi.h>
 #include <linux/module.h>
 #include <sound/core.h>
 #include <sound/jack.h>
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_auto_parser.h"
 #include "hda_jack.h"
 #include "hda_generic.h"
 /* keep halting ALC5505 DSP, for power saving */
 #define HALT_REALTEK_ALC5505
 /* unsol event tags */
 #define ALC_DCVOL_EVENT		0x08
 /* for GPIO Poll */
 #define GPIO_MASK	0x03
 /* extra amp-initialization sequence types */
 enum {
 	ALC_INIT_NONE,
 	ALC_INIT_DEFAULT,
 	ALC_INIT_GPIO1,
 	ALC_INIT_GPIO2,
 	ALC_INIT_GPIO3,
 };
 enum {
 	ALC_HEADSET_MODE_UNKNOWN,
 	ALC_HEADSET_MODE_UNPLUGGED,
 	ALC_HEADSET_MODE_HEADSET,
 	ALC_HEADSET_MODE_MIC,
 	ALC_HEADSET_MODE_HEADPHONE,
 };
 enum {
 	ALC_HEADSET_TYPE_UNKNOWN,
 	ALC_HEADSET_TYPE_CTIA,
 	ALC_HEADSET_TYPE_OMTP,
 };
 struct alc_customize_define {
 	unsigned int  sku_cfg;
 	unsigned char port_connectivity;
 	unsigned char check_sum;
 	unsigned char customization;
 	unsigned char external_amp;
 	unsigned int  enable_pcbeep:1;
 	unsigned int  platform_type:1;
 	unsigned int  swap:1;
 	unsigned int  override:1;
 	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 };
 struct alc_spec {
 	struct hda_gen_spec gen; /* must be at head */
 	/* codec parameterization */
 	const struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
 	unsigned int num_mixers;
 	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
 	struct alc_customize_define cdefine;
 	unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
 	/* inverted dmic fix */
 	unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */
 	unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */
 	hda_nid_t inv_dmic_pin;
 	/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
 	int mute_led_polarity;
 	hda_nid_t mute_led_nid;
 	unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
 	hda_nid_t headset_mic_pin;
 	hda_nid_t headphone_mic_pin;
 	int current_headset_mode;
 	int current_headset_type;
 	/* hooks */
 	void (*init_hook)(struct hda_codec *codec);
 #ifdef CONFIG_PM
 	void (*power_hook)(struct hda_codec *codec);
 #endif
 	void (*shutup)(struct hda_codec *codec);
 	int init_amp;
 	int codec_variant;	/* flag for other variants */
 	unsigned int has_alc5505_dsp:1;
 	unsigned int no_depop_delay:1;
 	/* for PLL fix */
 	hda_nid_t pll_nid;
 	unsigned int pll_coef_idx, pll_coef_bit;
 	unsigned int coef0;
 };
 /*
  * Append the given mixer and verb elements for the later use
  * The mixer array is referred in build_controls(), and init_verbs are
  * called in init().
  */
 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 {
 	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 		return;
 	spec->mixers[spec->num_mixers++] = mix;
 }
 /*
  * GPIO setup tables, used in initialization
  */
 /* Enable GPIO mask and set output */
 static const struct hda_verb alc_gpio1_init_verbs[] = {
 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 	{ }
 };
 static const struct hda_verb alc_gpio2_init_verbs[] = {
 	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 	{ }
 };
 static const struct hda_verb alc_gpio3_init_verbs[] = {
 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 	{ }
 };
 /*
  * Fix hardware PLL issue
  * On some codecs, the analog PLL gating control must be off while
  * the default value is 1.
  */
 static void alc_fix_pll(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	unsigned int val;
 	if (!spec->pll_nid)
 		return;
 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 			    spec->pll_coef_idx);
 	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 				 AC_VERB_GET_PROC_COEF, 0);
 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 			    spec->pll_coef_idx);
 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 			    val & ~(1 << spec->pll_coef_bit));
 }
 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 			     unsigned int coef_idx, unsigned int coef_bit)
 {
 	struct alc_spec *spec = codec->spec;
 	spec->pll_nid = nid;
 	spec->pll_coef_idx = coef_idx;
 	spec->pll_coef_bit = coef_bit;
 	alc_fix_pll(codec);
 }
 /* update the master volume per volume-knob's unsol event */
 static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)
 {
 	unsigned int val;
 	struct snd_kcontrol *kctl;
 	struct snd_ctl_elem_value *uctl;
 	kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 	if (!kctl)
 		return;
 	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 	if (!uctl)
 		return;
 	val = snd_hda_codec_read(codec, jack->nid, 0,
 				 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 	val &= HDA_AMP_VOLMASK;
 	uctl->value.integer.value[0] = val;
 	uctl->value.integer.value[1] = val;
 	kctl->put(kctl, uctl);
 	kfree(uctl);
 }
 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 {
 	/* For some reason, the res given from ALC880 is broken.
 	   Here we adjust it properly. */
 	snd_hda_jack_unsol_event(codec, res >> 2);
 }
 /* additional initialization for ALC888 variants */
 static void alc888_coef_init(struct hda_codec *codec)
 {
 	unsigned int tmp;
 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 	if ((tmp & 0xf0) == 0x20)
 		/* alc888S-VC */
 		snd_hda_codec_read(codec, 0x20, 0,
 				   AC_VERB_SET_PROC_COEF, 0x830);
 	 else
 		 /* alc888-VB */
 		 snd_hda_codec_read(codec, 0x20, 0,
 				    AC_VERB_SET_PROC_COEF, 0x3030);
 }
 /* additional initialization for ALC889 variants */
 static void alc889_coef_init(struct hda_codec *codec)
 {
 	unsigned int tmp;
 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
 }
 /* turn on/off EAPD control (only if available) */
 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 {
 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 		return;
 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 				    on ? 2 : 0);
 }
 /* turn on/off EAPD controls of the codec */
 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 {
 	/* We currently only handle front, HP */
 	static hda_nid_t pins[] = {
 		0x0f, 0x10, 0x14, 0x15, 0
 	};
 	hda_nid_t *p;
 	for (p = pins; *p; p++)
 		set_eapd(codec, *p, on);
 }
 /* generic shutup callback;
  * just turning off EPAD and a little pause for avoiding pop-noise
  */
 static void alc_eapd_shutup(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	alc_auto_setup_eapd(codec, false);
 	if (!spec->no_depop_delay)
 		msleep(200);
 	snd_hda_shutup_pins(codec);
 }
 /* generic EAPD initialization */
 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 {
 	unsigned int tmp;
 	alc_auto_setup_eapd(codec, true);
 	switch (type) {
 	case ALC_INIT_GPIO1:
 		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 		break;
 	case ALC_INIT_GPIO2:
 		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 		break;
 	case ALC_INIT_GPIO3:
 		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 		break;
 	case ALC_INIT_DEFAULT:
 		switch (codec->vendor_id) {
 		case 0x10ec0260:
 			snd_hda_codec_write(codec, 0x1a, 0,
 					    AC_VERB_SET_COEF_INDEX, 7);
 			tmp = snd_hda_codec_read(codec, 0x1a, 0,
 						 AC_VERB_GET_PROC_COEF, 0);
 			snd_hda_codec_write(codec, 0x1a, 0,
 					    AC_VERB_SET_COEF_INDEX, 7);
 			snd_hda_codec_write(codec, 0x1a, 0,
 					    AC_VERB_SET_PROC_COEF,
 					    tmp | 0x2010);
 			break;
 		case 0x10ec0262:
 		case 0x10ec0880:
 		case 0x10ec0882:
 		case 0x10ec0883:
 		case 0x10ec0885:
 		case 0x10ec0887:
 		/*case 0x10ec0889:*/ /* this causes an SPDIF problem */
 			alc889_coef_init(codec);
 			break;
 		case 0x10ec0888:
 			alc888_coef_init(codec);
 			break;
 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
 		case 0x10ec0267:
 		case 0x10ec0268:
 			snd_hda_codec_write(codec, 0x20, 0,
 					    AC_VERB_SET_COEF_INDEX, 7);
 			tmp = snd_hda_codec_read(codec, 0x20, 0,
 						 AC_VERB_GET_PROC_COEF, 0);
 			snd_hda_codec_write(codec, 0x20, 0,
 					    AC_VERB_SET_COEF_INDEX, 7);
 			snd_hda_codec_write(codec, 0x20, 0,
 					    AC_VERB_SET_PROC_COEF,
 					    tmp | 0x3000);
 			break;
 #endif /* XXX */
 		}
 		break;
 	}
 }
 /*
  * Realtek SSID verification
  */
 /* Could be any non-zero and even value. When used as fixup, tells
  * the driver to ignore any present sku defines.
  */
 #define ALC_FIXUP_SKU_IGNORE (2)
 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 				 const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->cdefine.fixup = 1;
 		spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 	}
 }
 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PROBE) {
 		spec->no_depop_delay = 1;
 		codec->depop_delay = 0;
 	}
 }
 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 {
 	unsigned int ass, tmp, i;
 	unsigned nid = 0;
 	struct alc_spec *spec = codec->spec;
 	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 	if (spec->cdefine.fixup) {
 		ass = spec->cdefine.sku_cfg;
 		if (ass == ALC_FIXUP_SKU_IGNORE)
 			return -1;
 		goto do_sku;
 	}
 	if (!codec->bus->pci)
 		return -1;
 	ass = codec->subsystem_id & 0xffff;
 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 		goto do_sku;
 	nid = 0x1d;
 	if (codec->vendor_id == 0x10ec0260)
 		nid = 0x17;
 	ass = snd_hda_codec_get_pincfg(codec, nid);
 	if (!(ass & 1)) {
 		codec_info(codec, "%s: SKU not ready 0x%08x\n",
 			   codec->chip_name, ass);
 		return -1;
 	}
 	/* check sum */
 	tmp = 0;
 	for (i = 1; i < 16; i++) {
 		if ((ass >> i) & 1)
 			tmp++;
 	}
 	if (((ass >> 16) & 0xf) != tmp)
 		return -1;
 	spec->cdefine.port_connectivity = ass >> 30;
 	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 	spec->cdefine.check_sum = (ass >> 16) & 0xf;
 	spec->cdefine.customization = ass >> 8;
 do_sku:
 	spec->cdefine.sku_cfg = ass;
 	spec->cdefine.external_amp = (ass & 0x38) >> 3;
 	spec->cdefine.platform_type = (ass & 0x4) >> 2;
 	spec->cdefine.swap = (ass & 0x2) >> 1;
 	spec->cdefine.override = ass & 0x1;
 	codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 		   nid, spec->cdefine.sku_cfg);
 	codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 		   spec->cdefine.port_connectivity);
 	codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 	codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 	codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 	codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 	codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 	codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 	codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 	return 0;
 }
 /* return the position of NID in the list, or -1 if not found */
 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 {
 	int i;
 	for (i = 0; i < nums; i++)
 		if (list[i] == nid)
 			return i;
 	return -1;
 }
 /* return true if the given NID is found in the list */
 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 {
 	return find_idx_in_nid_list(nid, list, nums) >= 0;
 }
 /* check subsystem ID and set up device-specific initialization;
  * return 1 if initialized, 0 if invalid SSID
  */
 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
  *	31 ~ 16 :	Manufacture ID
  *	15 ~ 8	:	SKU ID
  *	7  ~ 0	:	Assembly ID
  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
  */
 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 {
 	unsigned int ass, tmp, i;
 	unsigned nid;
 	struct alc_spec *spec = codec->spec;
 	if (spec->cdefine.fixup) {
 		ass = spec->cdefine.sku_cfg;
 		if (ass == ALC_FIXUP_SKU_IGNORE)
 			return 0;
 		goto do_sku;
 	}
 	ass = codec->subsystem_id & 0xffff;
 	if (codec->bus->pci &&
 	    ass != codec->bus->pci->subsystem_device && (ass & 1))
 		goto do_sku;
 	/* invalid SSID, check the special NID pin defcfg instead */
 	/*
 	 * 31~30	: port connectivity
 	 * 29~21	: reserve
 	 * 20		: PCBEEP input
 	 * 19~16	: Check sum (15:1)
 	 * 15~1		: Custom
 	 * 0		: override
 	*/
 	nid = 0x1d;
 	if (codec->vendor_id == 0x10ec0260)
 		nid = 0x17;
 	ass = snd_hda_codec_get_pincfg(codec, nid);
 	codec_dbg(codec,
 		  "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 		   ass, nid);
 	if (!(ass & 1))
 		return 0;
 	if ((ass >> 30) != 1)	/* no physical connection */
 		return 0;
 	/* check sum */
 	tmp = 0;
 	for (i = 1; i < 16; i++) {
 		if ((ass >> i) & 1)
 			tmp++;
 	}
 	if (((ass >> 16) & 0xf) != tmp)
 		return 0;
 do_sku:
 	codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 		   ass & 0xffff, codec->vendor_id);
 	/*
 	 * 0 : override
 	 * 1 :	Swap Jack
 	 * 2 : 0 --> Desktop, 1 --> Laptop
 	 * 3~5 : External Amplifier control
 	 * 7~6 : Reserved
 	*/
 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
 	switch (tmp) {
 	case 1:
 		spec->init_amp = ALC_INIT_GPIO1;
 		break;
 	case 3:
 		spec->init_amp = ALC_INIT_GPIO2;
 		break;
 	case 7:
 		spec->init_amp = ALC_INIT_GPIO3;
 		break;
 	case 5:
 	default:
 		spec->init_amp = ALC_INIT_DEFAULT;
 		break;
 	}
 	/* is laptop or Desktop and enable the function "Mute internal speaker
 	 * when the external headphone out jack is plugged"
 	 */
 	if (!(ass & 0x8000))
 		return 1;
 	/*
 	 * 10~8 : Jack location
 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 	 * 14~13: Resvered
 	 * 15   : 1 --> enable the function "Mute internal speaker
 	 *	        when the external headphone out jack is plugged"
 	 */
 	if (!spec->gen.autocfg.hp_pins[0] &&
 	    !(spec->gen.autocfg.line_out_pins[0] &&
 	      spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
 		hda_nid_t nid;
 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
 		nid = ports[tmp];
 		if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 				      spec->gen.autocfg.line_outs))
 			return 1;
 		spec->gen.autocfg.hp_pins[0] = nid;
 	}
 	return 1;
 }
 /* Check the validity of ALC subsystem-id
  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 {
 	if (!alc_subsystem_id(codec, ports)) {
 		struct alc_spec *spec = codec->spec;
 		codec_dbg(codec,
 			  "realtek: Enable default setup for auto mode as fallback\n");
 		spec->init_amp = ALC_INIT_DEFAULT;
 	}
 }
 /*
  * COEF access helper functions
  */
 static int alc_read_coefex_idx(struct hda_codec *codec,
 					hda_nid_t nid,
 					unsigned int coef_idx)
 {
 	unsigned int val;
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
 		    		coef_idx);
 	val = snd_hda_codec_read(codec, nid, 0,
 			 	AC_VERB_GET_PROC_COEF, 0);
 	return val;
 }
 #define alc_read_coef_idx(codec, coef_idx) \
 	alc_read_coefex_idx(codec, 0x20, coef_idx)
 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 							unsigned int coef_idx,
 							unsigned int coef_val)
 {
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
 			    coef_idx);
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF,
 			    coef_val);
 }
 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 	alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 /* a special bypass for COEF 0; read the cached value at the second time */
 static unsigned int alc_get_coef0(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (!spec->coef0)
 		spec->coef0 = alc_read_coef_idx(codec, 0);
 	return spec->coef0;
 }
 /*
  */
 static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
 {
 	struct hda_gen_spec *spec = codec->spec;
 	if (spec->dyn_adc_switch)
 		adc_idx = spec->dyn_adc_idx[imux_idx];
 	return spec->adc_nids[adc_idx];
 }
 static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)
 {
 	struct alc_spec *spec = codec->spec;
 	struct hda_input_mux *imux = &spec->gen.input_mux;
 	struct nid_path *path;
 	hda_nid_t nid;
 	int i, dir, parm;
 	unsigned int val;
 	for (i = 0; i < imux->num_items; i++) {
 		if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)
 			break;
 	}
 	if (i >= imux->num_items)
 		return;
 	path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,
 				    get_adc_nid(codec, adc_idx, i));
 	val = path->ctls[NID_PATH_MUTE_CTL];
 	if (!val)
 		return;
 	nid = get_amp_nid_(val);
 	dir = get_amp_direction_(val);
 	parm = AC_AMP_SET_RIGHT |
 		(dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);
 	/* flush all cached amps at first */
 	snd_hda_codec_flush_cache(codec);
 	/* we care only right channel */
 	val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);
 	if (val & 0x80) /* if already muted, we don't need to touch */
 		return;
 	val |= 0x80;
 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 			    parm | val);
 }
 /*
  * Inverted digital-mic handling
  *
  * First off, it's a bit tricky.  The "Inverted Internal Mic Capture Switch"
  * gives the additional mute only to the right channel of the digital mic
  * capture stream.  This is a workaround for avoiding the almost silence
  * by summing the stereo stream from some (known to be ForteMedia)
  * digital mic unit.
  *
  * The logic is to call alc_inv_dmic_sync() after each action (possibly)
  * modifying ADC amp.  When the mute flag is set, it mutes the R-channel
  * without caching so that the cache can still keep the original value.
  * The cached value is then restored when the flag is set off or any other
  * than d-mic is used as the current input source.
  */
 static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)
 {
 	struct alc_spec *spec = codec->spec;
 	int src, nums;
 	if (!spec->inv_dmic_fixup)
 		return;
 	if (!spec->inv_dmic_muted && !force)
 		return;
 	nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;
 	for (src = 0; src < nums; src++) {
 		bool dmic_fixup = false;
 		if (spec->inv_dmic_muted &&
 		    spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)
 			dmic_fixup = true;
 		if (!dmic_fixup && !force)
 			continue;
 		alc_inv_dmic_sync_adc(codec, src);
 	}
 }
 static void alc_inv_dmic_hook(struct hda_codec *codec,
 			      struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	alc_inv_dmic_sync(codec, false);
 }
 static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,
 			       struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct alc_spec *spec = codec->spec;
 	ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;
 	return 0;
 }
 static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,
 			       struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct alc_spec *spec = codec->spec;
 	unsigned int val = !ucontrol->value.integer.value[0];
 	if (val == spec->inv_dmic_muted)
 		return 0;
 	spec->inv_dmic_muted = val;
 	alc_inv_dmic_sync(codec, true);
 	return 0;
 }
 static const struct snd_kcontrol_new alc_inv_dmic_sw = {
 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 	.name = "Inverted Internal Mic Capture Switch",
 	.info = snd_ctl_boolean_mono_info,
 	.get = alc_inv_dmic_sw_get,
 	.put = alc_inv_dmic_sw_put,
 };
 static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)
 {
 	struct alc_spec *spec = codec->spec;
 	if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))
 		return -ENOMEM;
 	spec->inv_dmic_fixup = 1;
 	spec->inv_dmic_muted = 0;
 	spec->inv_dmic_pin = nid;
 	spec->gen.cap_sync_hook = alc_inv_dmic_hook;
 	return 0;
 }
 /* typically the digital mic is put at node 0x12 */
 static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PROBE)
 		alc_add_inv_dmic_mixer(codec, 0x12);
 }
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 /* additional beep mixers; the actual parameters are overwritten at build */
 static const struct snd_kcontrol_new alc_beep_mixer[] = {
 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
 	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
 	{ } /* end */
 };
 #endif
 static int alc_build_controls(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	int i, err;
 	err = snd_hda_gen_build_controls(codec);
 	if (err < 0)
 		return err;
 	for (i = 0; i < spec->num_mixers; i++) {
 		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 		if (err < 0)
 			return err;
 	}
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 	/* create beep controls if needed */
 	if (spec->beep_amp) {
 		const struct snd_kcontrol_new *knew;
 		for (knew = alc_beep_mixer; knew->name; knew++) {
 			struct snd_kcontrol *kctl;
 			kctl = snd_ctl_new1(knew, codec);
 			if (!kctl)
 				return -ENOMEM;
 			kctl->private_value = spec->beep_amp;
 			err = snd_hda_ctl_add(codec, 0, kctl);
 			if (err < 0)
 				return err;
 		}
 	}
 #endif
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 	return 0;
 }
 /*
  * Common callbacks
  */
 static int alc_init(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec->init_hook)
 		spec->init_hook(codec);
 	alc_fix_pll(codec);
 	alc_auto_init_amp(codec, spec->init_amp);
 	snd_hda_gen_init(codec);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 	return 0;
 }
 static inline void alc_shutup(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec && spec->shutup)
 		spec->shutup(codec);
 	else
 		snd_hda_shutup_pins(codec);
 }
 #define alc_free	snd_hda_gen_free
 #ifdef CONFIG_PM
 static void alc_power_eapd(struct hda_codec *codec)
 {
 	alc_auto_setup_eapd(codec, false);
 }
 static int alc_suspend(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	alc_shutup(codec);
 	if (spec && spec->power_hook)
 		spec->power_hook(codec);
 	return 0;
 }
 #endif
 #ifdef CONFIG_PM
 static int alc_resume(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (!spec->no_depop_delay)
 		msleep(150); /* to avoid pop noise */
 	codec->patch_ops.init(codec);
 	snd_hda_codec_resume_amp(codec);
 	snd_hda_codec_resume_cache(codec);
 	alc_inv_dmic_sync(codec, true);
 	hda_call_check_power_status(codec, 0x01);
 	return 0;
 }
 #endif
 /*
  */
 static const struct hda_codec_ops alc_patch_ops = {
 	.build_controls = alc_build_controls,
 	.build_pcms = snd_hda_gen_build_pcms,
 	.init = alc_init,
 	.free = alc_free,
 	.unsol_event = snd_hda_jack_unsol_event,
 #ifdef CONFIG_PM
 	.resume = alc_resume,
 	.suspend = alc_suspend,
 	.check_power_status = snd_hda_gen_check_power_status,
 #endif
 	.reboot_notify = alc_shutup,
 };
 /* replace the codec chip_name with the given string */
 static int alc_codec_rename(struct hda_codec *codec, const char *name)
 {
 	kfree(codec->chip_name);
 	codec->chip_name = kstrdup(name, GFP_KERNEL);
 	if (!codec->chip_name) {
 		alc_free(codec);
 		return -ENOMEM;
 	}
 	return 0;
 }
 /*
  * Rename codecs appropriately from COEF value or subvendor id
  */
 struct alc_codec_rename_table {
 	unsigned int vendor_id;
 	unsigned short coef_mask;
 	unsigned short coef_bits;
 	const char *name;
 };
 struct alc_codec_rename_pci_table {
 	unsigned int codec_vendor_id;
 	unsigned short pci_subvendor;
 	unsigned short pci_subdevice;
 	const char *name;
 };
 static struct alc_codec_rename_table rename_tbl[] = {
 	{ 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
 	{ 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
 	{ 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
 	{ 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
 	{ 0x10ec0269, 0xffff, 0xa023, "ALC259" },
 	{ 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
 	{ 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
 	{ 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
 	{ 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
 	{ 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
 	{ 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
 	{ 0x10ec0899, 0x2000, 0x2000, "ALC899" },
 	{ 0x10ec0892, 0xffff, 0x8020, "ALC661" },
 	{ 0x10ec0892, 0xffff, 0x8011, "ALC661" },
 	{ 0x10ec0892, 0xffff, 0x4011, "ALC656" },
 	{ } /* terminator */
 };
 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
 	{ 0x10ec0280, 0x1028, 0, "ALC3220" },
 	{ 0x10ec0282, 0x1028, 0, "ALC3221" },
 	{ 0x10ec0283, 0x1028, 0, "ALC3223" },
 	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
 	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
 	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
 	{ } /* terminator */
 };
 static int alc_codec_rename_from_preset(struct hda_codec *codec)
 {
 	const struct alc_codec_rename_table *p;
 	const struct alc_codec_rename_pci_table *q;
 	for (p = rename_tbl; p->vendor_id; p++) {
 		if (p->vendor_id != codec->vendor_id)
 			continue;
 		if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
 			return alc_codec_rename(codec, p->name);
 	}
 	if (!codec->bus->pci)
 		return 0;
 	for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
 		if (q->codec_vendor_id != codec->vendor_id)
 			continue;
 		if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
 			continue;
 		if (!q->pci_subdevice ||
 		    q->pci_subdevice == codec->bus->pci->subsystem_device)
 			return alc_codec_rename(codec, q->name);
 	}
 	return 0;
 }
 /*
  * Digital-beep handlers
  */
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 #define set_beep_amp(spec, nid, idx, dir) \
 	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
 static const struct snd_pci_quirk beep_white_list[] = {
 	SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
 	SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
 	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
 	SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
 	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
 	SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
 	SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
 	SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
 	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
 	{}
 };
 static inline int has_cdefine_beep(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	const struct snd_pci_quirk *q;
 	q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
 	if (q)
 		return q->value;
 	return spec->cdefine.enable_pcbeep;
 }
 #else
 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
 #define has_cdefine_beep(codec)		0
 #endif
 /* parse the BIOS configuration and set up the alc_spec */
 /* return 1 if successful, 0 if the proper config is not found,
  * or a negative error code
  */
 static int alc_parse_auto_config(struct hda_codec *codec,
 				 const hda_nid_t *ignore_nids,
 				 const hda_nid_t *ssid_nids)
 {
 	struct alc_spec *spec = codec->spec;
 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 	int err;
 	err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
 				       spec->parse_flags);
 	if (err < 0)
 		return err;
 	if (ssid_nids)
 		alc_ssid_check(codec, ssid_nids);
 	err = snd_hda_gen_parse_auto_config(codec, cfg);
 	if (err < 0)
 		return err;
 	return 1;
 }
 /* common preparation job for alc_spec */
 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
 {
 	struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 	int err;
 	if (!spec)
 		return -ENOMEM;
 	codec->spec = spec;
 	snd_hda_gen_spec_init(&spec->gen);
 	spec->gen.mixer_nid = mixer_nid;
 	spec->gen.own_eapd_ctl = 1;
 	codec->single_adc_amp = 1;
 	/* FIXME: do we need this for all Realtek codec models? */
 	codec->spdif_status_reset = 1;
 	err = alc_codec_rename_from_preset(codec);
 	if (err < 0) {
 		kfree(spec);
 		return err;
 	}
 	return 0;
 }
 static int alc880_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
 }
 /*
  * ALC880 fix-ups
  */
 enum {
 	ALC880_FIXUP_GPIO1,
 	ALC880_FIXUP_GPIO2,
 	ALC880_FIXUP_MEDION_RIM,
 	ALC880_FIXUP_LG,
 	ALC880_FIXUP_LG_LW25,
 	ALC880_FIXUP_W810,
 	ALC880_FIXUP_EAPD_COEF,
 	ALC880_FIXUP_TCL_S700,
 	ALC880_FIXUP_VOL_KNOB,
 	ALC880_FIXUP_FUJITSU,
 	ALC880_FIXUP_F1734,
 	ALC880_FIXUP_UNIWILL,
 	ALC880_FIXUP_UNIWILL_DIG,
 	ALC880_FIXUP_Z71V,
 	ALC880_FIXUP_ASUS_W5A,
 	ALC880_FIXUP_3ST_BASE,
 	ALC880_FIXUP_3ST,
 	ALC880_FIXUP_3ST_DIG,
 	ALC880_FIXUP_5ST_BASE,
 	ALC880_FIXUP_5ST,
 	ALC880_FIXUP_5ST_DIG,
 	ALC880_FIXUP_6ST_BASE,
 	ALC880_FIXUP_6ST,
 	ALC880_FIXUP_6ST_DIG,
 	ALC880_FIXUP_6ST_AUTOMUTE,
 };
 /* enable the volume-knob widget support on NID 0x21 */
 static void alc880_fixup_vol_knob(struct hda_codec *codec,
 				  const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PROBE)
 		snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);
 }
 static const struct hda_fixup alc880_fixups[] = {
 	[ALC880_FIXUP_GPIO1] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio1_init_verbs,
 	},
 	[ALC880_FIXUP_GPIO2] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio2_init_verbs,
 	},
 	[ALC880_FIXUP_MEDION_RIM] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_GPIO2,
 	},
 	[ALC880_FIXUP_LG] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* disable bogus unused pins */
 			{ 0x16, 0x411111f0 },
 			{ 0x18, 0x411111f0 },
 			{ 0x1a, 0x411111f0 },
 			{ }
 		}
 	},
 	[ALC880_FIXUP_LG_LW25] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1a, 0x0181344f }, /* line-in */
 			{ 0x1b, 0x0321403f }, /* headphone */
 			{ }
 		}
 	},
 	[ALC880_FIXUP_W810] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* disable bogus unused pins */
 			{ 0x17, 0x411111f0 },
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_GPIO2,
 	},
 	[ALC880_FIXUP_EAPD_COEF] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* change to EAPD mode */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
 			{}
 		},
 	},
 	[ALC880_FIXUP_TCL_S700] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* change to EAPD mode */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_GPIO2,
 	},
 	[ALC880_FIXUP_VOL_KNOB] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc880_fixup_vol_knob,
 	},
 	[ALC880_FIXUP_FUJITSU] = {
 		/* override all pins as BIOS on old Amilo is broken */
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x0121411f }, /* HP */
 			{ 0x15, 0x99030120 }, /* speaker */
 			{ 0x16, 0x99030130 }, /* bass speaker */
 			{ 0x17, 0x411111f0 }, /* N/A */
 			{ 0x18, 0x411111f0 }, /* N/A */
 			{ 0x19, 0x01a19950 }, /* mic-in */
 			{ 0x1a, 0x411111f0 }, /* N/A */
 			{ 0x1b, 0x411111f0 }, /* N/A */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			{ 0x1e, 0x01454140 }, /* SPDIF out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_VOL_KNOB,
 	},
 	[ALC880_FIXUP_F1734] = {
 		/* almost compatible with FUJITSU, but no bass and SPDIF */
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x0121411f }, /* HP */
 			{ 0x15, 0x99030120 }, /* speaker */
 			{ 0x16, 0x411111f0 }, /* N/A */
 			{ 0x17, 0x411111f0 }, /* N/A */
 			{ 0x18, 0x411111f0 }, /* N/A */
 			{ 0x19, 0x01a19950 }, /* mic-in */
 			{ 0x1a, 0x411111f0 }, /* N/A */
 			{ 0x1b, 0x411111f0 }, /* N/A */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			{ 0x1e, 0x411111f0 }, /* N/A */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_VOL_KNOB,
 	},
 	[ALC880_FIXUP_UNIWILL] = {
 		/* need to fix HP and speaker pins to be parsed correctly */
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x0121411f }, /* HP */
 			{ 0x15, 0x99030120 }, /* speaker */
 			{ 0x16, 0x99030130 }, /* bass speaker */
 			{ }
 		},
 	},
 	[ALC880_FIXUP_UNIWILL_DIG] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* disable bogus unused pins */
 			{ 0x17, 0x411111f0 },
 			{ 0x19, 0x411111f0 },
 			{ 0x1b, 0x411111f0 },
 			{ 0x1f, 0x411111f0 },
 			{ }
 		}
 	},
 	[ALC880_FIXUP_Z71V] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* set up the whole pins as BIOS is utterly broken */
 			{ 0x14, 0x99030120 }, /* speaker */
 			{ 0x15, 0x0121411f }, /* HP */
 			{ 0x16, 0x411111f0 }, /* N/A */
 			{ 0x17, 0x411111f0 }, /* N/A */
 			{ 0x18, 0x01a19950 }, /* mic-in */
 			{ 0x19, 0x411111f0 }, /* N/A */
 			{ 0x1a, 0x01813031 }, /* line-in */
 			{ 0x1b, 0x411111f0 }, /* N/A */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			{ 0x1e, 0x0144111e }, /* SPDIF */
 			{ }
 		}
 	},
 	[ALC880_FIXUP_ASUS_W5A] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* set up the whole pins as BIOS is utterly broken */
 			{ 0x14, 0x0121411f }, /* HP */
 			{ 0x15, 0x411111f0 }, /* N/A */
 			{ 0x16, 0x411111f0 }, /* N/A */
 			{ 0x17, 0x411111f0 }, /* N/A */
 			{ 0x18, 0x90a60160 }, /* mic */
 			{ 0x19, 0x411111f0 }, /* N/A */
 			{ 0x1a, 0x411111f0 }, /* N/A */
 			{ 0x1b, 0x411111f0 }, /* N/A */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			{ 0x1e, 0xb743111e }, /* SPDIF out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_GPIO1,
 	},
 	[ALC880_FIXUP_3ST_BASE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x01014010 }, /* line-out */
 			{ 0x15, 0x411111f0 }, /* N/A */
 			{ 0x16, 0x411111f0 }, /* N/A */
 			{ 0x17, 0x411111f0 }, /* N/A */
 			{ 0x18, 0x01a19c30 }, /* mic-in */
 			{ 0x19, 0x0121411f }, /* HP */
 			{ 0x1a, 0x01813031 }, /* line-in */
 			{ 0x1b, 0x02a19c40 }, /* front-mic */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			/* 0x1e is filled in below */
 			{ 0x1f, 0x411111f0 }, /* N/A */
 			{ }
 		}
 	},
 	[ALC880_FIXUP_3ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x411111f0 }, /* N/A */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_3ST_BASE,
 	},
 	[ALC880_FIXUP_3ST_DIG] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x0144111e }, /* SPDIF */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_3ST_BASE,
 	},
 	[ALC880_FIXUP_5ST_BASE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x01014010 }, /* front */
 			{ 0x15, 0x411111f0 }, /* N/A */
 			{ 0x16, 0x01011411 }, /* CLFE */
 			{ 0x17, 0x01016412 }, /* surr */
 			{ 0x18, 0x01a19c30 }, /* mic-in */
 			{ 0x19, 0x0121411f }, /* HP */
 			{ 0x1a, 0x01813031 }, /* line-in */
 			{ 0x1b, 0x02a19c40 }, /* front-mic */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			/* 0x1e is filled in below */
 			{ 0x1f, 0x411111f0 }, /* N/A */
 			{ }
 		}
 	},
 	[ALC880_FIXUP_5ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x411111f0 }, /* N/A */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_5ST_BASE,
 	},
 	[ALC880_FIXUP_5ST_DIG] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x0144111e }, /* SPDIF */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_5ST_BASE,
 	},
 	[ALC880_FIXUP_6ST_BASE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x01014010 }, /* front */
 			{ 0x15, 0x01016412 }, /* surr */
 			{ 0x16, 0x01011411 }, /* CLFE */
 			{ 0x17, 0x01012414 }, /* side */
 			{ 0x18, 0x01a19c30 }, /* mic-in */
 			{ 0x19, 0x02a19c40 }, /* front-mic */
 			{ 0x1a, 0x01813031 }, /* line-in */
 			{ 0x1b, 0x0121411f }, /* HP */
 			{ 0x1c, 0x411111f0 }, /* N/A */
 			{ 0x1d, 0x411111f0 }, /* N/A */
 			/* 0x1e is filled in below */
 			{ 0x1f, 0x411111f0 }, /* N/A */
 			{ }
 		}
 	},
 	[ALC880_FIXUP_6ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x411111f0 }, /* N/A */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_6ST_BASE,
 	},
 	[ALC880_FIXUP_6ST_DIG] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x0144111e }, /* SPDIF */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC880_FIXUP_6ST_BASE,
 	},
 	[ALC880_FIXUP_6ST_AUTOMUTE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1b, 0x0121401f }, /* HP with jack detect */
 			{ }
 		},
 		.chained_before = true,
 		.chain_id = ALC880_FIXUP_6ST_BASE,
 	},
 };
 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
 	SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
 	SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),
 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
 	SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
 	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
 	/* Below is the copied entries from alc880_quirks.c.
 	 * It's not quite sure whether BIOS sets the correct pin-config table
 	 * on these machines, thus they are kept to be compatible with
 	 * the old static quirks.  Once when it's confirmed to work without
 	 * these overrides, it'd be better to remove.
 	 */
 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
 	/* default Intel */
 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
 	{}
 };
 static const struct hda_model_fixup alc880_fixup_models[] = {
 	{.id = ALC880_FIXUP_3ST, .name = "3stack"},
 	{.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
 	{.id = ALC880_FIXUP_5ST, .name = "5stack"},
 	{.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
 	{.id = ALC880_FIXUP_6ST, .name = "6stack"},
 	{.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
 	{.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
 	{}
 };
 /*
  * OK, here we have finally the patch for ALC880
  */
 static int patch_alc880(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.need_dac_fix = 1;
 	spec->gen.beep_nid = 0x01;
 	snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
 		       alc880_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	/* automatic parse from the BIOS config */
 	err = alc880_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog)
 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 	codec->patch_ops.unsol_event = alc880_unsol_event;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC260 support
  */
 static int alc260_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
 	static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
 	return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
 }
 /*
  * Pin config fixes
  */
 enum {
 	ALC260_FIXUP_HP_DC5750,
 	ALC260_FIXUP_HP_PIN_0F,
 	ALC260_FIXUP_COEF,
 	ALC260_FIXUP_GPIO1,
 	ALC260_FIXUP_GPIO1_TOGGLE,
 	ALC260_FIXUP_REPLACER,
 	ALC260_FIXUP_HP_B1900,
 	ALC260_FIXUP_KN1,
 	ALC260_FIXUP_FSC_S7020,
 	ALC260_FIXUP_FSC_S7020_JWSE,
 	ALC260_FIXUP_VAIO_PINS,
 };
 static void alc260_gpio1_automute(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 			    spec->gen.hp_jack_present);
 }
 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
 				      const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PROBE) {
 		/* although the machine has only one output pin, we need to
 		 * toggle GPIO1 according to the jack state
 		 */
 		spec->gen.automute_hook = alc260_gpio1_automute;
 		spec->gen.detect_hp = 1;
 		spec->gen.automute_speaker = 1;
 		spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
 		snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,
 						    snd_hda_gen_hp_automute);
 		snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
 	}
 }
 static void alc260_fixup_kn1(struct hda_codec *codec,
 			     const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	static const struct hda_pintbl pincfgs[] = {
 		{ 0x0f, 0x02214000 }, /* HP/speaker */
 		{ 0x12, 0x90a60160 }, /* int mic */
 		{ 0x13, 0x02a19000 }, /* ext mic */
 		{ 0x18, 0x01446000 }, /* SPDIF out */
 		/* disable bogus I/O pins */
 		{ 0x10, 0x411111f0 },
 		{ 0x11, 0x411111f0 },
 		{ 0x14, 0x411111f0 },
 		{ 0x15, 0x411111f0 },
 		{ 0x16, 0x411111f0 },
 		{ 0x17, 0x411111f0 },
 		{ 0x19, 0x411111f0 },
 		{ }
 	};
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		snd_hda_apply_pincfgs(codec, pincfgs);
 		break;
 	case HDA_FIXUP_ACT_PROBE:
 		spec->init_amp = ALC_INIT_NONE;
 		break;
 	}
 }
 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PROBE)
 		spec->init_amp = ALC_INIT_NONE;
 }
 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.add_jack_modes = 1;
 		spec->gen.hp_mic = 1;
 	}
 }
 static const struct hda_fixup alc260_fixups[] = {
 	[ALC260_FIXUP_HP_DC5750] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x11, 0x90130110 }, /* speaker */
 			{ }
 		}
 	},
 	[ALC260_FIXUP_HP_PIN_0F] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x0f, 0x01214000 }, /* HP */
 			{ }
 		}
 	},
 	[ALC260_FIXUP_COEF] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3040 },
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC260_FIXUP_HP_PIN_0F,
 	},
 	[ALC260_FIXUP_GPIO1] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio1_init_verbs,
 	},
 	[ALC260_FIXUP_GPIO1_TOGGLE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc260_fixup_gpio1_toggle,
 		.chained = true,
 		.chain_id = ALC260_FIXUP_HP_PIN_0F,
 	},
 	[ALC260_FIXUP_REPLACER] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x3050 },
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
 	},
 	[ALC260_FIXUP_HP_B1900] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc260_fixup_gpio1_toggle,
 		.chained = true,
 		.chain_id = ALC260_FIXUP_COEF,
 	},
 	[ALC260_FIXUP_KN1] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc260_fixup_kn1,
 	},
 	[ALC260_FIXUP_FSC_S7020] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc260_fixup_fsc_s7020,
 	},
 	[ALC260_FIXUP_FSC_S7020_JWSE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc260_fixup_fsc_s7020_jwse,
 		.chained = true,
 		.chain_id = ALC260_FIXUP_FSC_S7020,
 	},
 	[ALC260_FIXUP_VAIO_PINS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* Pin configs are missing completely on some VAIOs */
 			{ 0x0f, 0x01211020 },
 			{ 0x10, 0x0001003f },
 			{ 0x11, 0x411111f0 },
 			{ 0x12, 0x01a15930 },
 			{ 0x13, 0x411111f0 },
 			{ 0x14, 0x411111f0 },
 			{ 0x15, 0x411111f0 },
 			{ 0x16, 0x411111f0 },
 			{ 0x17, 0x411111f0 },
 			{ 0x18, 0x411111f0 },
 			{ 0x19, 0x411111f0 },
 			{ }
 		}
 	},
 };
 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
 	SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
 	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
 	SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
 	SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
 	SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
 	SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
 	{}
 };
 static const struct hda_model_fixup alc260_fixup_models[] = {
 	{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
 	{.id = ALC260_FIXUP_COEF, .name = "coef"},
 	{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
 	{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
 	{}
 };
 /*
  */
 static int patch_alc260(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x07);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	/* as quite a few machines require HP amp for speaker outputs,
 	 * it's easier to enable it unconditionally; even if it's unneeded,
 	 * it's almost harmless.
 	 */
 	spec->gen.prefer_hp_amp = 1;
 	spec->gen.beep_nid = 0x01;
 	snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
 			   alc260_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	/* automatic parse from the BIOS config */
 	err = alc260_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog)
 		set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 	spec->shutup = alc_eapd_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC882/883/885/888/889 support
  *
  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
  * configuration.  Each pin widget can choose any input DACs and a mixer.
  * Each ADC is connected from a mixer of all inputs.  This makes possible
  * 6-channel independent captures.
  *
  * In addition, an independent DAC for the multi-playback (not used in this
  * driver yet).
  */
 /*
  * Pin config fixes
  */
 enum {
 	ALC882_FIXUP_ABIT_AW9D_MAX,
 	ALC882_FIXUP_LENOVO_Y530,
 	ALC882_FIXUP_PB_M5210,
 	ALC882_FIXUP_ACER_ASPIRE_7736,
 	ALC882_FIXUP_ASUS_W90V,
 	ALC889_FIXUP_CD,
 	ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
 	ALC889_FIXUP_VAIO_TT,
 	ALC888_FIXUP_EEE1601,
 	ALC882_FIXUP_EAPD,
 	ALC883_FIXUP_EAPD,
 	ALC883_FIXUP_ACER_EAPD,
 	ALC882_FIXUP_GPIO1,
 	ALC882_FIXUP_GPIO2,
 	ALC882_FIXUP_GPIO3,
 	ALC889_FIXUP_COEF,
 	ALC882_FIXUP_ASUS_W2JC,
 	ALC882_FIXUP_ACER_ASPIRE_4930G,
 	ALC882_FIXUP_ACER_ASPIRE_8930G,
 	ALC882_FIXUP_ASPIRE_8930G_VERBS,
 	ALC885_FIXUP_MACPRO_GPIO,
 	ALC889_FIXUP_DAC_ROUTE,
 	ALC889_FIXUP_MBP_VREF,
 	ALC889_FIXUP_IMAC91_VREF,
 	ALC889_FIXUP_MBA11_VREF,
 	ALC889_FIXUP_MBA21_VREF,
 	ALC889_FIXUP_MP11_VREF,
 	ALC882_FIXUP_INV_DMIC,
 	ALC882_FIXUP_NO_PRIMARY_HP,
 	ALC887_FIXUP_ASUS_BASS,
 	ALC887_FIXUP_BASS_CHMAP,
 };
 static void alc889_fixup_coef(struct hda_codec *codec,
 			      const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	alc889_coef_init(codec);
 }
 /* toggle speaker-output according to the hp-jack state */
 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
 {
 	unsigned int gpiostate, gpiomask, gpiodir;
 	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
 				       AC_VERB_GET_GPIO_DATA, 0);
 	if (!muted)
 		gpiostate |= (1 << pin);
 	else
 		gpiostate &= ~(1 << pin);
 	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
 				      AC_VERB_GET_GPIO_MASK, 0);
 	gpiomask |= (1 << pin);
 	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
 				     AC_VERB_GET_GPIO_DIRECTION, 0);
 	gpiodir |= (1 << pin);
 	snd_hda_codec_write(codec, codec->afg, 0,
 			    AC_VERB_SET_GPIO_MASK, gpiomask);
 	snd_hda_codec_write(codec, codec->afg, 0,
 			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
 	msleep(1);
 	snd_hda_codec_write(codec, codec->afg, 0,
 			    AC_VERB_SET_GPIO_DATA, gpiostate);
 }
 /* set up GPIO at initialization */
 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	alc882_gpio_mute(codec, 0, 0);
 	alc882_gpio_mute(codec, 1, 0);
 }
 /* Fix the connection of some pins for ALC889:
  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
  * work correctly (bko#42740)
  */
 static void alc889_fixup_dac_route(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		/* fake the connections during parsing the tree */
 		hda_nid_t conn1[2] = { 0x0c, 0x0d };
 		hda_nid_t conn2[2] = { 0x0e, 0x0f };
 		snd_hda_override_conn_list(codec, 0x14, 2, conn1);
 		snd_hda_override_conn_list(codec, 0x15, 2, conn1);
 		snd_hda_override_conn_list(codec, 0x18, 2, conn2);
 		snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
 	} else if (action == HDA_FIXUP_ACT_PROBE) {
 		/* restore the connections */
 		hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
 		snd_hda_override_conn_list(codec, 0x14, 5, conn);
 		snd_hda_override_conn_list(codec, 0x15, 5, conn);
 		snd_hda_override_conn_list(codec, 0x18, 5, conn);
 		snd_hda_override_conn_list(codec, 0x1a, 5, conn);
 	}
 }
 /* Set VREF on HP pin */
 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
 				  const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	static hda_nid_t nids[2] = { 0x14, 0x15 };
 	int i;
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	for (i = 0; i < ARRAY_SIZE(nids); i++) {
 		unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
 		if (get_defcfg_device(val) != AC_JACK_HP_OUT)
 			continue;
 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
 		val |= AC_PINCTL_VREF_80;
 		snd_hda_set_pin_ctl(codec, nids[i], val);
 		spec->gen.keep_vref_in_automute = 1;
 		break;
 	}
 }
 static void alc889_fixup_mac_pins(struct hda_codec *codec,
 				  const hda_nid_t *nids, int num_nids)
 {
 	struct alc_spec *spec = codec->spec;
 	int i;
 	for (i = 0; i < num_nids; i++) {
 		unsigned int val;
 		val = snd_hda_codec_get_pin_target(codec, nids[i]);
 		val |= AC_PINCTL_VREF_50;
 		snd_hda_set_pin_ctl(codec, nids[i], val);
 	}
 	spec->gen.keep_vref_in_automute = 1;
 }
 /* Set VREF on speaker pins on imac91 */
 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	static hda_nid_t nids[2] = { 0x18, 0x1a };
 	if (action == HDA_FIXUP_ACT_INIT)
 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
 }
 /* Set VREF on speaker pins on mba11 */
 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	static hda_nid_t nids[1] = { 0x18 };
 	if (action == HDA_FIXUP_ACT_INIT)
 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
 }
 /* Set VREF on speaker pins on mba21 */
 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	static hda_nid_t nids[2] = { 0x18, 0x19 };
 	if (action == HDA_FIXUP_ACT_INIT)
 		alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
 }
 /* Don't take HP output as primary
  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
  */
 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.no_primary_hp = 1;
 		spec->gen.no_multi_io = 1;
 	}
 }
 static void alc_fixup_bass_chmap(struct hda_codec *codec,
 				 const struct hda_fixup *fix, int action);
 static const struct hda_fixup alc882_fixups[] = {
 	[ALC882_FIXUP_ABIT_AW9D_MAX] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x15, 0x01080104 }, /* side */
 			{ 0x16, 0x01011012 }, /* rear */
 			{ 0x17, 0x01016011 }, /* clfe */
 			{ }
 		}
 	},
 	[ALC882_FIXUP_LENOVO_Y530] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x15, 0x99130112 }, /* rear int speakers */
 			{ 0x16, 0x99130111 }, /* subwoofer */
 			{ }
 		}
 	},
 	[ALC882_FIXUP_PB_M5210] = {
 		.type = HDA_FIXUP_PINCTLS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, PIN_VREF50 },
 			{}
 		}
 	},
 	[ALC882_FIXUP_ACER_ASPIRE_7736] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_sku_ignore,
 	},
 	[ALC882_FIXUP_ASUS_W90V] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x16, 0x99130110 }, /* fix sequence for CLFE */
 			{ }
 		}
 	},
 	[ALC889_FIXUP_CD] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1c, 0x993301f0 }, /* CD */
 			{ }
 		}
 	},
 	[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC889_FIXUP_CD,
 	},
 	[ALC889_FIXUP_VAIO_TT] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x17, 0x90170111 }, /* hidden surround speaker */
 			{ }
 		}
 	},
 	[ALC888_FIXUP_EEE1601] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
 			{ 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
 			{ }
 		}
 	},
 	[ALC882_FIXUP_EAPD] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* change to EAPD mode */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
 			{ }
 		}
 	},
 	[ALC883_FIXUP_EAPD] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* change to EAPD mode */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
 			{ }
 		}
 	},
 	[ALC883_FIXUP_ACER_EAPD] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* eanable EAPD on Acer laptops */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
 			{ }
 		}
 	},
 	[ALC882_FIXUP_GPIO1] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio1_init_verbs,
 	},
 	[ALC882_FIXUP_GPIO2] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio2_init_verbs,
 	},
 	[ALC882_FIXUP_GPIO3] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio3_init_verbs,
 	},
 	[ALC882_FIXUP_ASUS_W2JC] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = alc_gpio1_init_verbs,
 		.chained = true,
 		.chain_id = ALC882_FIXUP_EAPD,
 	},
 	[ALC889_FIXUP_COEF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_coef,
 	},
 	[ALC882_FIXUP_ACER_ASPIRE_4930G] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x16, 0x99130111 }, /* CLFE speaker */
 			{ 0x17, 0x99130112 }, /* surround speaker */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC882_FIXUP_GPIO1,
 	},
 	[ALC882_FIXUP_ACER_ASPIRE_8930G] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x16, 0x99130111 }, /* CLFE speaker */
 			{ 0x1b, 0x99130112 }, /* surround speaker */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
 	},
 	[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
 		/* additional init verbs for Acer Aspire 8930G */
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* Enable all DACs */
 			/* DAC DISABLE/MUTE 1? */
 			/*  setting bits 1-5 disables DAC nids 0x02-0x06
 			 *  apparently. Init=0x38 */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
 			/* DAC DISABLE/MUTE 2? */
 			/*  some bit here disables the other DACs.
 			 *  Init=0x4900 */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
 			/* DMIC fix
 			 * This laptop has a stereo digital microphone.
 			 * The mics are only 1cm apart which makes the stereo
 			 * useless. However, either the mic or the ALC889
 			 * makes the signal become a difference/sum signal
 			 * instead of standard stereo, which is annoying.
 			 * So instead we flip this bit which makes the
 			 * codec replicate the sum signal to both channels,
 			 * turning it into a normal mono mic.
 			 */
 			/* DMIC_CONTROL? Init value = 0x0001 */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC882_FIXUP_GPIO1,
 	},
 	[ALC885_FIXUP_MACPRO_GPIO] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc885_fixup_macpro_gpio,
 	},
 	[ALC889_FIXUP_DAC_ROUTE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_dac_route,
 	},
 	[ALC889_FIXUP_MBP_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_mbp_vref,
 		.chained = true,
 		.chain_id = ALC882_FIXUP_GPIO1,
 	},
 	[ALC889_FIXUP_IMAC91_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_imac91_vref,
 		.chained = true,
 		.chain_id = ALC882_FIXUP_GPIO1,
 	},
 	[ALC889_FIXUP_MBA11_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_mba11_vref,
 		.chained = true,
 		.chain_id = ALC889_FIXUP_MBP_VREF,
 	},
 	[ALC889_FIXUP_MBA21_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_mba21_vref,
 		.chained = true,
 		.chain_id = ALC889_FIXUP_MBP_VREF,
 	},
 	[ALC889_FIXUP_MP11_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_mba11_vref,
 		.chained = true,
 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
 	},
 	[ALC882_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic_0x12,
 	},
 	[ALC882_FIXUP_NO_PRIMARY_HP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc882_fixup_no_primary_hp,
 	},
 	[ALC887_FIXUP_ASUS_BASS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{0x16, 0x99130130}, /* bass speaker */
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC887_FIXUP_BASS_CHMAP,
 	},
 	[ALC887_FIXUP_BASS_CHMAP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_bass_chmap,
 	},
 };
 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
 		      ALC882_FIXUP_ACER_ASPIRE_8930G),
 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
 	SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
 		      ALC882_FIXUP_ACER_ASPIRE_4930G),
 	SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
 	SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
 	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
 	SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
 	SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
 	SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
 	/* All Apple entries are in codec SSIDs */
 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
 	SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),
 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
 	SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
 	{}
 };
 static const struct hda_model_fixup alc882_fixup_models[] = {
 	{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
 	{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
 	{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
 	{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
 	{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
 	{}
 };
 /*
  * BIOS auto configuration
  */
 /* almost identical with ALC880 parser... */
 static int alc882_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
 }
 /*
  */
 static int patch_alc882(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	switch (codec->vendor_id) {
 	case 0x10ec0882:
 	case 0x10ec0885:
 		break;
 	default:
 		/* ALC883 and variants */
 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
 		break;
 	}
 	snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
 		       alc882_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	alc_auto_parse_customize_define(codec);
 	if (has_cdefine_beep(codec))
 		spec->gen.beep_nid = 0x01;
 	/* automatic parse from the BIOS config */
 	err = alc882_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog && spec->gen.beep_nid)
 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC262 support
  */
 static int alc262_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
 }
 /*
  * Pin config fixes
  */
 enum {
 	ALC262_FIXUP_FSC_H270,
 	ALC262_FIXUP_FSC_S7110,
 	ALC262_FIXUP_HP_Z200,
 	ALC262_FIXUP_TYAN,
 	ALC262_FIXUP_LENOVO_3000,
 	ALC262_FIXUP_BENQ,
 	ALC262_FIXUP_BENQ_T31,
 	ALC262_FIXUP_INV_DMIC,
 	ALC262_FIXUP_INTEL_BAYLEYBAY,
 };
 static const struct hda_fixup alc262_fixups[] = {
 	[ALC262_FIXUP_FSC_H270] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x0221142f }, /* front HP */
 			{ 0x1b, 0x0121141f }, /* rear HP */
 			{ }
 		}
 	},
 	[ALC262_FIXUP_FSC_S7110] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x15, 0x90170110 }, /* speaker */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC262_FIXUP_BENQ,
 	},
 	[ALC262_FIXUP_HP_Z200] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x16, 0x99130120 }, /* internal speaker */
 			{ }
 		}
 	},
 	[ALC262_FIXUP_TYAN] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x1993e1f0 }, /* int AUX */
 			{ }
 		}
 	},
 	[ALC262_FIXUP_LENOVO_3000] = {
 		.type = HDA_FIXUP_PINCTLS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, PIN_VREF50 },
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC262_FIXUP_BENQ,
 	},
 	[ALC262_FIXUP_BENQ] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
 			{}
 		}
 	},
 	[ALC262_FIXUP_BENQ_T31] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
 			{}
 		}
 	},
 	[ALC262_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic_0x12,
 	},
 	[ALC262_FIXUP_INTEL_BAYLEYBAY] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_no_depop_delay,
 	},
 };
 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
 	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
 	SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
 	{}
 };
 static const struct hda_model_fixup alc262_fixup_models[] = {
 	{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
 	{}
 };
 /*
  */
 static int patch_alc262(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.shared_mic_vref_pin = 0x18;
 #if 0
 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
 	 * under-run
 	 */
 	{
 	int tmp;
 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
 	}
 #endif
 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
 	snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
 		       alc262_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	alc_auto_parse_customize_define(codec);
 	if (has_cdefine_beep(codec))
 		spec->gen.beep_nid = 0x01;
 	/* automatic parse from the BIOS config */
 	err = alc262_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog && spec->gen.beep_nid)
 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 	spec->shutup = alc_eapd_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  *  ALC268
  */
 /* bind Beep switches of both NID 0x0f and 0x10 */
 static const struct hda_bind_ctls alc268_bind_beep_sw = {
 	.ops = &snd_hda_bind_sw,
 	.values = {
 		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
 		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
 		0
 	},
 };
 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
 	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
 	{ }
 };
 /* set PCBEEP vol = 0, mute connections */
 static const struct hda_verb alc268_beep_init_verbs[] = {
 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 	{ }
 };
 enum {
 	ALC268_FIXUP_INV_DMIC,
 	ALC268_FIXUP_HP_EAPD,
 	ALC268_FIXUP_SPDIF,
 };
 static const struct hda_fixup alc268_fixups[] = {
 	[ALC268_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic_0x12,
 	},
 	[ALC268_FIXUP_HP_EAPD] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
 			{}
 		}
 	},
 	[ALC268_FIXUP_SPDIF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1e, 0x014b1180 }, /* enable SPDIF out */
 			{}
 		}
 	},
 };
 static const struct hda_model_fixup alc268_fixup_models[] = {
 	{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
 	{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
 	{}
 };
 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
 	/* below is codec SSID since multiple Toshiba laptops have the
 	 * same PCI SSID 1179:ff00
 	 */
 	SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
 	{}
 };
 /*
  * BIOS auto configuration
  */
 static int alc268_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	return alc_parse_auto_config(codec, NULL, alc268_ssids);
 }
 /*
  */
 static int patch_alc268(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	/* ALC268 has no aa-loopback mixer */
 	err = alc_alloc_spec(codec, 0);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.beep_nid = 0x01;
 	snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	/* automatic parse from the BIOS config */
 	err = alc268_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (err > 0 && !spec->gen.no_analog &&
 	    spec->gen.autocfg.speaker_pins[0] != 0x1d) {
 		add_mixer(spec, alc268_beep_mixer);
 		snd_hda_add_verbs(codec, alc268_beep_init_verbs);
 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
 			/* override the amp caps for beep generator */
 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 					  (0 << AC_AMPCAP_MUTE_SHIFT));
 	}
 	codec->patch_ops = alc_patch_ops;
 	spec->shutup = alc_eapd_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC269
  */
 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
 			     struct hda_codec *codec,
 			     struct snd_pcm_substream *substream)
 {
 	struct hda_gen_spec *spec = codec->spec;
 	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 					     hinfo);
 }
 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 				struct hda_codec *codec,
 				unsigned int stream_tag,
 				unsigned int format,
 				struct snd_pcm_substream *substream)
 {
 	struct hda_gen_spec *spec = codec->spec;
 	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 						stream_tag, format, substream);
 }
 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 				struct hda_codec *codec,
 				struct snd_pcm_substream *substream)
 {
 	struct hda_gen_spec *spec = codec->spec;
 	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 }
 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
 	.substreams = 1,
 	.channels_min = 2,
 	.channels_max = 8,
 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
 	/* NID is set in alc_build_pcms */
 	.ops = {
 		.open = playback_pcm_open,
 		.prepare = playback_pcm_prepare,
 		.cleanup = playback_pcm_cleanup
 	},
 };
 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
 	.substreams = 1,
 	.channels_min = 2,
 	.channels_max = 2,
 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
 	/* NID is set in alc_build_pcms */
 };
 /* different alc269-variants */
 enum {
 	ALC269_TYPE_ALC269VA,
 	ALC269_TYPE_ALC269VB,
 	ALC269_TYPE_ALC269VC,
 	ALC269_TYPE_ALC269VD,
 	ALC269_TYPE_ALC280,
 	ALC269_TYPE_ALC282,
 	ALC269_TYPE_ALC283,
 	ALC269_TYPE_ALC284,
 	ALC269_TYPE_ALC285,
 	ALC269_TYPE_ALC286,
 	ALC269_TYPE_ALC255,
 };
 /*
  * BIOS auto configuration
  */
 static int alc269_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
 	static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	struct alc_spec *spec = codec->spec;
 	const hda_nid_t *ssids;
 	switch (spec->codec_variant) {
 	case ALC269_TYPE_ALC269VA:
 	case ALC269_TYPE_ALC269VC:
 	case ALC269_TYPE_ALC280:
 	case ALC269_TYPE_ALC284:
 	case ALC269_TYPE_ALC285:
 		ssids = alc269va_ssids;
 		break;
 	case ALC269_TYPE_ALC269VB:
 	case ALC269_TYPE_ALC269VD:
 	case ALC269_TYPE_ALC282:
 	case ALC269_TYPE_ALC283:
 	case ALC269_TYPE_ALC286:
 	case ALC269_TYPE_ALC255:
 		ssids = alc269_ssids;
 		break;
 	default:
 		ssids = alc269_ssids;
 		break;
 	}
 	return alc_parse_auto_config(codec, alc269_ignore, ssids);
 }
 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
 {
 	int val = alc_read_coef_idx(codec, 0x04);
 	if (power_up)
 		val |= 1 << 11;
 	else
 		val &= ~(1 << 11);
 	alc_write_coef_idx(codec, 0x04, val);
 }
 static void alc269_shutup(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
 		alc269vb_toggle_power_output(codec, 0);
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
 		msleep(150);
 	}
 	snd_hda_shutup_pins(codec);
 }
 static void alc282_restore_default_value(struct hda_codec *codec)
 {
 	int val;
 	/* Power Down Control */
 	alc_write_coef_idx(codec, 0x03, 0x0002);
 	/* FIFO and filter clock */
 	alc_write_coef_idx(codec, 0x05, 0x0700);
 	/* DMIC control */
 	alc_write_coef_idx(codec, 0x07, 0x0200);
 	/* Analog clock */
 	val = alc_read_coef_idx(codec, 0x06);
 	alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);
 	/* JD */
 	val = alc_read_coef_idx(codec, 0x08);
 	alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);
 	/* JD offset1 */
 	alc_write_coef_idx(codec, 0x0a, 0xcccc);
 	/* JD offset2 */
 	alc_write_coef_idx(codec, 0x0b, 0xcccc);
 	/* LDO1/2/3, DAC/ADC */
 	alc_write_coef_idx(codec, 0x0e, 0x6e00);
 	/* JD */
 	val = alc_read_coef_idx(codec, 0x0f);
 	alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);
 	/* Capless */
 	val = alc_read_coef_idx(codec, 0x10);
 	alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);
 	/* Class D test 4 */
 	alc_write_coef_idx(codec, 0x6f, 0x0);
 	/* IO power down directly */
 	val = alc_read_coef_idx(codec, 0x0c);
 	alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);
 	/* ANC */
 	alc_write_coef_idx(codec, 0x34, 0xa0c0);
 	/* AGC MUX */
 	val = alc_read_coef_idx(codec, 0x16);
 	alc_write_coef_idx(codec, 0x16, (val & ~0x0008) | 0x0);
 	/* DAC simple content protection */
 	val = alc_read_coef_idx(codec, 0x1d);
 	alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);
 	/* ADC simple content protection */
 	val = alc_read_coef_idx(codec, 0x1f);
 	alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);
 	/* DAC ADC Zero Detection */
 	alc_write_coef_idx(codec, 0x21, 0x8804);
 	/* PLL */
 	alc_write_coef_idx(codec, 0x63, 0x2902);
 	/* capless control 2 */
 	alc_write_coef_idx(codec, 0x68, 0xa080);
 	/* capless control 3 */
 	alc_write_coef_idx(codec, 0x69, 0x3400);
 	/* capless control 4 */
 	alc_write_coef_idx(codec, 0x6a, 0x2f3e);
 	/* capless control 5 */
 	alc_write_coef_idx(codec, 0x6b, 0x0);
 	/* class D test 2 */
 	val = alc_read_coef_idx(codec, 0x6d);
 	alc_write_coef_idx(codec, 0x6d, (val & ~0x0fff) | 0x0900);
 	/* class D test 3 */
 	alc_write_coef_idx(codec, 0x6e, 0x110a);
 	/* class D test 5 */
 	val = alc_read_coef_idx(codec, 0x70);
 	alc_write_coef_idx(codec, 0x70, (val & ~0x00f8) | 0x00d8);
 	/* class D test 6 */
 	alc_write_coef_idx(codec, 0x71, 0x0014);
 	/* classD OCP */
 	alc_write_coef_idx(codec, 0x72, 0xc2ba);
 	/* classD pure DC test */
 	val = alc_read_coef_idx(codec, 0x77);
 	alc_write_coef_idx(codec, 0x77, (val & ~0x0f80) | 0x0);
 	/* Class D amp control */
 	alc_write_coef_idx(codec, 0x6c, 0xfc06);
 }
 static void alc282_init(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
 	bool hp_pin_sense;
 	int coef78;
 	alc282_restore_default_value(codec);
 	if (!hp_pin)
 		return;
 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
 	coef78 = alc_read_coef_idx(codec, 0x78);
 	/* Index 0x78 Direct Drive HP AMP LPM Control 1 */
 	/* Headphone capless set to high power mode */
 	alc_write_coef_idx(codec, 0x78, 0x9004);
 	if (hp_pin_sense)
 		msleep(2);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 	if (hp_pin_sense)
 		msleep(85);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 	if (hp_pin_sense)
 		msleep(100);
 	/* Headphone capless set to normal mode */
 	alc_write_coef_idx(codec, 0x78, coef78);
 }
 static void alc282_shutup(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
 	bool hp_pin_sense;
 	int coef78;
 	if (!hp_pin) {
 		alc269_shutup(codec);
 		return;
 	}
 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
 	coef78 = alc_read_coef_idx(codec, 0x78);
 	alc_write_coef_idx(codec, 0x78, 0x9004);
 	if (hp_pin_sense)
 		msleep(2);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 	if (hp_pin_sense)
 		msleep(85);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 	if (hp_pin_sense)
 		msleep(100);
 	alc_auto_setup_eapd(codec, false);
 	snd_hda_shutup_pins(codec);
 	alc_write_coef_idx(codec, 0x78, coef78);
 }
 static void alc283_restore_default_value(struct hda_codec *codec)
 {
 	int val;
 	/* Power Down Control */
 	alc_write_coef_idx(codec, 0x03, 0x0002);
 	/* FIFO and filter clock */
 	alc_write_coef_idx(codec, 0x05, 0x0700);
 	/* DMIC control */
 	alc_write_coef_idx(codec, 0x07, 0x0200);
 	/* Analog clock */
 	val = alc_read_coef_idx(codec, 0x06);
 	alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);
 	/* JD */
 	val = alc_read_coef_idx(codec, 0x08);
 	alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);
 	/* JD offset1 */
 	alc_write_coef_idx(codec, 0x0a, 0xcccc);
 	/* JD offset2 */
 	alc_write_coef_idx(codec, 0x0b, 0xcccc);
 	/* LDO1/2/3, DAC/ADC */
 	alc_write_coef_idx(codec, 0x0e, 0x6fc0);
 	/* JD */
 	val = alc_read_coef_idx(codec, 0x0f);
 	alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);
 	/* Capless */
 	val = alc_read_coef_idx(codec, 0x10);
 	alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);
 	/* Class D test 4 */
 	alc_write_coef_idx(codec, 0x3a, 0x0);
 	/* IO power down directly */
 	val = alc_read_coef_idx(codec, 0x0c);
 	alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);
 	/* ANC */
 	alc_write_coef_idx(codec, 0x22, 0xa0c0);
 	/* AGC MUX */
 	val = alc_read_coefex_idx(codec, 0x53, 0x01);
 	alc_write_coefex_idx(codec, 0x53, 0x01, (val & ~0x000f) | 0x0008);
 	/* DAC simple content protection */
 	val = alc_read_coef_idx(codec, 0x1d);
 	alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);
 	/* ADC simple content protection */
 	val = alc_read_coef_idx(codec, 0x1f);
 	alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);
 	/* DAC ADC Zero Detection */
 	alc_write_coef_idx(codec, 0x21, 0x8804);
 	/* PLL */
 	alc_write_coef_idx(codec, 0x2e, 0x2902);
 	/* capless control 2 */
 	alc_write_coef_idx(codec, 0x33, 0xa080);
 	/* capless control 3 */
 	alc_write_coef_idx(codec, 0x34, 0x3400);
 	/* capless control 4 */
 	alc_write_coef_idx(codec, 0x35, 0x2f3e);
 	/* capless control 5 */
 	alc_write_coef_idx(codec, 0x36, 0x0);
 	/* class D test 2 */
 	val = alc_read_coef_idx(codec, 0x38);
 	alc_write_coef_idx(codec, 0x38, (val & ~0x0fff) | 0x0900);
 	/* class D test 3 */
 	alc_write_coef_idx(codec, 0x39, 0x110a);
 	/* class D test 5 */
 	val = alc_read_coef_idx(codec, 0x3b);
 	alc_write_coef_idx(codec, 0x3b, (val & ~0x00f8) | 0x00d8);
 	/* class D test 6 */
 	alc_write_coef_idx(codec, 0x3c, 0x0014);
 	/* classD OCP */
 	alc_write_coef_idx(codec, 0x3d, 0xc2ba);
 	/* classD pure DC test */
 	val = alc_read_coef_idx(codec, 0x42);
 	alc_write_coef_idx(codec, 0x42, (val & ~0x0f80) | 0x0);
 	/* test mode */
 	alc_write_coef_idx(codec, 0x49, 0x0);
 	/* Class D DC enable */
 	val = alc_read_coef_idx(codec, 0x40);
 	alc_write_coef_idx(codec, 0x40, (val & ~0xf800) | 0x9800);
 	/* DC offset */
 	val = alc_read_coef_idx(codec, 0x42);
 	alc_write_coef_idx(codec, 0x42, (val & ~0xf000) | 0x2000);
 	/* Class D amp control */
 	alc_write_coef_idx(codec, 0x37, 0xfc06);
 }
 static void alc283_init(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
 	bool hp_pin_sense;
 	int val;
 	if (!spec->gen.autocfg.hp_outs) {
 		if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 			hp_pin = spec->gen.autocfg.line_out_pins[0];
 	}
 	alc283_restore_default_value(codec);
 	if (!hp_pin)
 		return;
 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
 	/* Index 0x43 Direct Drive HP AMP LPM Control 1 */
 	/* Headphone capless set to high power mode */
 	alc_write_coef_idx(codec, 0x43, 0x9004);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 	if (hp_pin_sense)
 		msleep(85);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 	if (hp_pin_sense)
 		msleep(85);
 	/* Index 0x46 Combo jack auto switch control 2 */
 	/* 3k pull low control for Headset jack. */
 	val = alc_read_coef_idx(codec, 0x46);
 	alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));
 	/* Headphone capless set to normal mode */
 	alc_write_coef_idx(codec, 0x43, 0x9614);
 }
 static void alc283_shutup(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
 	bool hp_pin_sense;
 	int val;
 	if (!spec->gen.autocfg.hp_outs) {
 		if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 			hp_pin = spec->gen.autocfg.line_out_pins[0];
 	}
 	if (!hp_pin) {
 		alc269_shutup(codec);
 		return;
 	}
 	hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
 	alc_write_coef_idx(codec, 0x43, 0x9004);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 	if (hp_pin_sense)
 		msleep(100);
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 	val = alc_read_coef_idx(codec, 0x46);
 	alc_write_coef_idx(codec, 0x46, val | (3 << 12));
 	if (hp_pin_sense)
 		msleep(100);
 	snd_hda_shutup_pins(codec);
 	alc_write_coef_idx(codec, 0x43, 0x9614);
 }
 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
 			     unsigned int val)
 {
 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
 }
 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
 {
 	unsigned int val;
 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
 	val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
 		& 0xffff;
 	val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
 		<< 16;
 	return val;
 }
 static void alc5505_dsp_halt(struct hda_codec *codec)
 {
 	unsigned int val;
 	alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
 	alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
 	alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
 	alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
 	alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
 	alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
 	alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
 	val = alc5505_coef_get(codec, 0x6220);
 	alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
 }
 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
 {
 	alc5505_coef_set(codec, 0x61b8, 0x04133302);
 	alc5505_coef_set(codec, 0x61b0, 0x00005b16);
 	alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
 	alc5505_coef_set(codec, 0x6230, 0xf80d4011);
 	alc5505_coef_set(codec, 0x6220, 0x2002010f);
 	alc5505_coef_set(codec, 0x880c, 0x00000004);
 }
 static void alc5505_dsp_init(struct hda_codec *codec)
 {
 	unsigned int val;
 	alc5505_dsp_halt(codec);
 	alc5505_dsp_back_from_halt(codec);
 	alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
 	alc5505_coef_set(codec, 0x61b0, 0x5b16);
 	alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
 	alc5505_coef_set(codec, 0x61b4, 0x04132b02);
 	alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
 	alc5505_coef_set(codec, 0x61b8, 0x041f3302);
 	snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
 	alc5505_coef_set(codec, 0x61b8, 0x041b3302);
 	alc5505_coef_set(codec, 0x61b8, 0x04173302);
 	alc5505_coef_set(codec, 0x61b8, 0x04163302);
 	alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
 	alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
 	alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
 	val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
 	if (val <= 3)
 		alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
 	else
 		alc5505_coef_set(codec, 0x6220, 0x6002018f);
 	alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
 	alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
 	alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
 	alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
 	alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
 	alc5505_coef_set(codec, 0x880c, 0x00000003);
 	alc5505_coef_set(codec, 0x880c, 0x00000010);
 #ifdef HALT_REALTEK_ALC5505
 	alc5505_dsp_halt(codec);
 #endif
 }
 #ifdef HALT_REALTEK_ALC5505
 #define alc5505_dsp_suspend(codec)	/* NOP */
 #define alc5505_dsp_resume(codec)	/* NOP */
 #else
 #define alc5505_dsp_suspend(codec)	alc5505_dsp_halt(codec)
 #define alc5505_dsp_resume(codec)	alc5505_dsp_back_from_halt(codec)
 #endif
 #ifdef CONFIG_PM
 static int alc269_suspend(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec->has_alc5505_dsp)
 		alc5505_dsp_suspend(codec);
 	return alc_suspend(codec);
 }
 static int alc269_resume(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
 		alc269vb_toggle_power_output(codec, 0);
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
 			(alc_get_coef0(codec) & 0x00ff) == 0x018) {
 		msleep(150);
 	}
 	codec->patch_ops.init(codec);
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB)
 		alc269vb_toggle_power_output(codec, 1);
 	if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
 			(alc_get_coef0(codec) & 0x00ff) == 0x017) {
 		msleep(200);
 	}
 	snd_hda_codec_resume_amp(codec);
 	snd_hda_codec_resume_cache(codec);
 	alc_inv_dmic_sync(codec, true);
 	hda_call_check_power_status(codec, 0x01);
 	if (spec->has_alc5505_dsp)
 		alc5505_dsp_resume(codec);
 	return 0;
 }
 #endif /* CONFIG_PM */
 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
 						 const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 }
 static void alc269_fixup_hweq(struct hda_codec *codec,
 			       const struct hda_fixup *fix, int action)
 {
 	int coef;
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	coef = alc_read_coef_idx(codec, 0x1e);
 	alc_write_coef_idx(codec, 0x1e, coef | 0x80);
 }
 static void alc269_fixup_headset_mic(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
 }
 static void alc271_fixup_dmic(struct hda_codec *codec,
 			      const struct hda_fixup *fix, int action)
 {
 	static const struct hda_verb verbs[] = {
 		{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
 		{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
 		{}
 	};
 	unsigned int cfg;
 	if (strcmp(codec->chip_name, "ALC271X") &&
 	    strcmp(codec->chip_name, "ALC269VB"))
 		return;
 	cfg = snd_hda_codec_get_pincfg(codec, 0x12);
 	if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
 		snd_hda_sequence_write(codec, verbs);
 }
 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
 				 const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PROBE)
 		return;
 	/* Due to a hardware problem on Lenovo Ideadpad, we need to
 	 * fix the sample rate of analog I/O to 44.1kHz
 	 */
 	spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
 	spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
 }
 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	int coef;
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	/* The digital-mic unit sends PDM (differential signal) instead of
 	 * the standard PCM, thus you can't record a valid mono stream as is.
 	 * Below is a workaround specific to ALC269 to control the dmic
 	 * signal source as mono.
 	 */
 	coef = alc_read_coef_idx(codec, 0x07);
 	alc_write_coef_idx(codec, 0x07, coef | 0x80);
 }
 static void alc269_quanta_automute(struct hda_codec *codec)
 {
 	snd_hda_gen_update_outputs(codec);
 	snd_hda_codec_write(codec, 0x20, 0,
 			AC_VERB_SET_COEF_INDEX, 0x0c);
 	snd_hda_codec_write(codec, 0x20, 0,
 			AC_VERB_SET_PROC_COEF, 0x680);
 	snd_hda_codec_write(codec, 0x20, 0,
 			AC_VERB_SET_COEF_INDEX, 0x0c);
 	snd_hda_codec_write(codec, 0x20, 0,
 			AC_VERB_SET_PROC_COEF, 0x480);
 }
 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PROBE)
 		return;
 	spec->gen.automute_hook = alc269_quanta_automute;
 }
 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
 					 struct hda_jack_tbl *jack)
 {
 	struct alc_spec *spec = codec->spec;
 	int vref;
 	msleep(200);
 	snd_hda_gen_hp_automute(codec, jack);
 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
 	msleep(100);
 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 			    vref);
 	msleep(500);
 	snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 			    vref);
 }
 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
 		spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
 	}
 }
 /* update mute-LED according to the speaker mute state via mic VREF pin */
 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
 {
 	struct hda_codec *codec = private_data;
 	struct alc_spec *spec = codec->spec;
 	unsigned int pinval;
 	if (spec->mute_led_polarity)
 		enabled = !enabled;
 	pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
 	pinval &= ~AC_PINCTL_VREFEN;
 	pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
 	if (spec->mute_led_nid)
 		snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
 }
 /* Make sure the led works even in runtime suspend */
 static unsigned int led_power_filter(struct hda_codec *codec,
 						  hda_nid_t nid,
 						  unsigned int power_state)
 {
 	struct alc_spec *spec = codec->spec;
 	if (power_state != AC_PWRST_D3 || nid != spec->mute_led_nid)
 		return power_state;
 	/* Set pin ctl again, it might have just been set to 0 */
 	snd_hda_set_pin_ctl(codec, nid,
 			    snd_hda_codec_get_pin_target(codec, nid));
 	return AC_PWRST_D0;
 }
 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	const struct dmi_device *dev = NULL;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
 		int pol, pin;
 		if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
 			continue;
 		if (pin < 0x0a || pin >= 0x10)
 			break;
 		spec->mute_led_polarity = pol;
 		spec->mute_led_nid = pin - 0x0a + 0x18;
 		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
 		spec->gen.vmaster_mute_enum = 1;
 		codec->power_filter = led_power_filter;
 		codec_dbg(codec,
 			  "Detected mute LED for %x:%d\n", spec->mute_led_nid,
 			   spec->mute_led_polarity);
 		break;
 	}
 }
 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->mute_led_polarity = 0;
 		spec->mute_led_nid = 0x18;
 		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
 		spec->gen.vmaster_mute_enum = 1;
 		codec->power_filter = led_power_filter;
 	}
 }
 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->mute_led_polarity = 0;
 		spec->mute_led_nid = 0x19;
 		spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
 		spec->gen.vmaster_mute_enum = 1;
 		codec->power_filter = led_power_filter;
 	}
 }
 /* turn on/off mute LED per vmaster hook */
 static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)
 {
 	struct hda_codec *codec = private_data;
 	struct alc_spec *spec = codec->spec;
 	unsigned int oldval = spec->gpio_led;
 	if (enabled)
 		spec->gpio_led &= ~0x08;
 	else
 		spec->gpio_led |= 0x08;
 	if (spec->gpio_led != oldval)
 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 				    spec->gpio_led);
 }
 /* turn on/off mic-mute LED per capture hook */
 static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,
 					       struct snd_kcontrol *kcontrol,
 					       struct snd_ctl_elem_value *ucontrol)
 {
 	struct alc_spec *spec = codec->spec;
 	unsigned int oldval = spec->gpio_led;
 	if (!ucontrol)
 		return;
 	if (ucontrol->value.integer.value[0] ||
 	    ucontrol->value.integer.value[1])
 		spec->gpio_led &= ~0x10;
 	else
 		spec->gpio_led |= 0x10;
 	if (spec->gpio_led != oldval)
 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 				    spec->gpio_led);
 }
 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	static const struct hda_verb gpio_init[] = {
 		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
 		{}
 	};
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;
 		spec->gpio_led = 0;
 		snd_hda_add_verbs(codec, gpio_init);
 	}
 }
 static void alc_headset_mode_unplugged(struct hda_codec *codec)
 {
 	int val;
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		/* LDO and MISC control */
 		alc_write_coef_idx(codec, 0x1b, 0x0c0b);
 		/* UAJ function set to menual mode */
 		alc_write_coef_idx(codec, 0x45, 0xd089);
 		/* Direct Drive HP Amp control(Set to verb control)*/
 		val = alc_read_coefex_idx(codec, 0x57, 0x05);
 		alc_write_coefex_idx(codec, 0x57, 0x05, val & ~(1<<14));
 		/* Set MIC2 Vref gate with HP */
 		alc_write_coef_idx(codec, 0x06, 0x6104);
 		/* Direct Drive HP Amp control */
 		alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x1b, 0x0c0b);
 		alc_write_coef_idx(codec, 0x45, 0xc429);
 		val = alc_read_coef_idx(codec, 0x35);
 		alc_write_coef_idx(codec, 0x35, val & 0xbfff);
 		alc_write_coef_idx(codec, 0x06, 0x2104);
 		alc_write_coef_idx(codec, 0x1a, 0x0001);
 		alc_write_coef_idx(codec, 0x26, 0x0004);
 		alc_write_coef_idx(codec, 0x32, 0x42a3);
 		break;
 	case 0x10ec0292:
 		alc_write_coef_idx(codec, 0x76, 0x000e);
 		alc_write_coef_idx(codec, 0x6c, 0x2400);
 		alc_write_coef_idx(codec, 0x18, 0x7308);
 		alc_write_coef_idx(codec, 0x6b, 0xc429);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x15, 0x0d40);
 		alc_write_coef_idx(codec, 0xb7, 0x802b);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to unplugged mode.\n");
 }
 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
 				    hda_nid_t mic_pin)
 {
 	int val;
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		alc_write_coef_idx(codec, 0x45, 0xc489);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
 		/* Set MIC2 Vref gate to normal */
 		alc_write_coef_idx(codec, 0x06, 0x6100);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x45, 0xc429);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		val = alc_read_coef_idx(codec, 0x35);
 		alc_write_coef_idx(codec, 0x35, val | 1<<14);
 		alc_write_coef_idx(codec, 0x06, 0x2100);
 		alc_write_coef_idx(codec, 0x1a, 0x0021);
 		alc_write_coef_idx(codec, 0x26, 0x008c);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0292:
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_write_coef_idx(codec, 0x19, 0xa208);
 		alc_write_coef_idx(codec, 0x2e, 0xacf0);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0001);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_write_coef_idx(codec, 0xb7, 0x802b);
 		alc_write_coef_idx(codec, 0xb5, 0x1040);
 		val = alc_read_coef_idx(codec, 0xc3);
 		alc_write_coef_idx(codec, 0xc3, val | 1<<12);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to mic-in mode.\n");
 }
 static void alc_headset_mode_default(struct hda_codec *codec)
 {
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		alc_write_coef_idx(codec, 0x45, 0xc089);
 		alc_write_coef_idx(codec, 0x45, 0xc489);
 		alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
 		alc_write_coef_idx(codec, 0x49, 0x0049);
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x06, 0x2100);
 		alc_write_coef_idx(codec, 0x32, 0x4ea3);
 		break;
 	case 0x10ec0292:
 		alc_write_coef_idx(codec, 0x76, 0x000e);
 		alc_write_coef_idx(codec, 0x6c, 0x2400);
 		alc_write_coef_idx(codec, 0x6b, 0xc429);
 		alc_write_coef_idx(codec, 0x18, 0x7308);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0041);
 		alc_write_coef_idx(codec, 0x15, 0x0d40);
 		alc_write_coef_idx(codec, 0xb7, 0x802b);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
 }
 /* Iphone type */
 static void alc_headset_mode_ctia(struct hda_codec *codec)
 {
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		/* Set to CTIA type */
 		alc_write_coef_idx(codec, 0x45, 0xd489);
 		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
 		alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x45, 0xd429);
 		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
 		alc_write_coef_idx(codec, 0x32, 0x4ea3);
 		break;
 	case 0x10ec0292:
 		alc_write_coef_idx(codec, 0x6b, 0xd429);
 		alc_write_coef_idx(codec, 0x76, 0x0008);
 		alc_write_coef_idx(codec, 0x18, 0x7388);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0001);
 		alc_write_coef_idx(codec, 0x15, 0x0d60);
 		alc_write_coef_idx(codec, 0xc3, 0x0000);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
 }
 /* Nokia type */
 static void alc_headset_mode_omtp(struct hda_codec *codec)
 {
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		/* Set to OMTP Type */
 		alc_write_coef_idx(codec, 0x45, 0xe489);
 		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
 		alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x45, 0xe429);
 		alc_write_coef_idx(codec, 0x1b, 0x0c2b);
 		alc_write_coef_idx(codec, 0x32, 0x4ea3);
 		break;
 	case 0x10ec0292:
 		alc_write_coef_idx(codec, 0x6b, 0xe429);
 		alc_write_coef_idx(codec, 0x76, 0x0008);
 		alc_write_coef_idx(codec, 0x18, 0x7388);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0001);
 		alc_write_coef_idx(codec, 0x15, 0x0d50);
 		alc_write_coef_idx(codec, 0xc3, 0x0000);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
 }
 static void alc_determine_headset_type(struct hda_codec *codec)
 {
 	int val;
 	bool is_ctia = false;
 	struct alc_spec *spec = codec->spec;
 	switch (codec->vendor_id) {
 	case 0x10ec0255:
 		/* combo jack auto switch control(Check type)*/
 		alc_write_coef_idx(codec, 0x45, 0xd089);
 		/* combo jack auto switch control(Vref conteol) */
 		alc_write_coef_idx(codec, 0x49, 0x0149);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x0070) == 0x0070;
 		break;
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x45, 0xd029);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x0070) == 0x0070;
 		break;
 	case 0x10ec0292:
 		alc_write_coef_idx(codec, 0x6b, 0xd429);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0x6c);
 		is_ctia = (val & 0x001c) == 0x001c;
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0001);
 		alc_write_coef_idx(codec, 0xb7, 0x802b);
 		alc_write_coef_idx(codec, 0x15, 0x0d60);
 		alc_write_coef_idx(codec, 0xc3, 0x0c00);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0xbe);
 		is_ctia = (val & 0x1c02) == 0x1c02;
 		break;
 	}
 	codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
 		    is_ctia ? "yes" : "no");
 	spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
 }
 static void alc_update_headset_mode(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
 	hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
 	int new_headset_mode;
 	if (!snd_hda_jack_detect(codec, hp_pin))
 		new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
 	else if (mux_pin == spec->headset_mic_pin)
 		new_headset_mode = ALC_HEADSET_MODE_HEADSET;
 	else if (mux_pin == spec->headphone_mic_pin)
 		new_headset_mode = ALC_HEADSET_MODE_MIC;
 	else
 		new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
 	if (new_headset_mode == spec->current_headset_mode) {
 		snd_hda_gen_update_outputs(codec);
 		return;
 	}
 	switch (new_headset_mode) {
 	case ALC_HEADSET_MODE_UNPLUGGED:
 		alc_headset_mode_unplugged(codec);
 		spec->gen.hp_jack_present = false;
 		break;
 	case ALC_HEADSET_MODE_HEADSET:
 		if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
 			alc_determine_headset_type(codec);
 		if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
 			alc_headset_mode_ctia(codec);
 		else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
 			alc_headset_mode_omtp(codec);
 		spec->gen.hp_jack_present = true;
 		break;
 	case ALC_HEADSET_MODE_MIC:
 		alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
 		spec->gen.hp_jack_present = false;
 		break;
 	case ALC_HEADSET_MODE_HEADPHONE:
 		alc_headset_mode_default(codec);
 		spec->gen.hp_jack_present = true;
 		break;
 	}
 	if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
 		snd_hda_set_pin_ctl_cache(codec, hp_pin,
 					  AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
 		if (spec->headphone_mic_pin)
 			snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
 						  PIN_VREFHIZ);
 	}
 	spec->current_headset_mode = new_headset_mode;
 	snd_hda_gen_update_outputs(codec);
 }
 static void alc_update_headset_mode_hook(struct hda_codec *codec,
 					 struct snd_kcontrol *kcontrol,
 					 struct snd_ctl_elem_value *ucontrol)
 {
 	alc_update_headset_mode(codec);
 }
 static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)
 {
 	struct alc_spec *spec = codec->spec;
 	spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
 	snd_hda_gen_hp_automute(codec, jack);
 }
 static void alc_probe_headset_mode(struct hda_codec *codec)
 {
 	int i;
 	struct alc_spec *spec = codec->spec;
 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 	/* Find mic pins */
 	for (i = 0; i < cfg->num_inputs; i++) {
 		if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
 			spec->headset_mic_pin = cfg->inputs[i].pin;
 		if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
 			spec->headphone_mic_pin = cfg->inputs[i].pin;
 	}
 	spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
 	spec->gen.automute_hook = alc_update_headset_mode;
 	spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
 }
 static void alc_fixup_headset_mode(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
 		break;
 	case HDA_FIXUP_ACT_PROBE:
 		alc_probe_headset_mode(codec);
 		break;
 	case HDA_FIXUP_ACT_INIT:
 		spec->current_headset_mode = 0;
 		alc_update_headset_mode(codec);
 		break;
 	}
 }
 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
 	}
 	else
 		alc_fixup_headset_mode(codec, fix, action);
 }
 static void alc255_set_default_jack_type(struct hda_codec *codec)
 {
 	/* Set to iphone type */
 	alc_write_coef_idx(codec, 0x1b, 0x880b);
 	alc_write_coef_idx(codec, 0x45, 0xd089);
 	alc_write_coef_idx(codec, 0x1b, 0x080b);
 	alc_write_coef_idx(codec, 0x46, 0x0004);
 	alc_write_coef_idx(codec, 0x1b, 0x0c0b);
 	msleep(30);
 }
 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		alc255_set_default_jack_type(codec);
 	}
 	alc_fixup_headset_mode(codec, fix, action);
 }
 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
 		alc255_set_default_jack_type(codec);
 	}
 	else
 		alc_fixup_headset_mode(codec, fix, action);
 }
 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
 					const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		spec->gen.auto_mute_via_amp = 1;
 	}
 }
 static void alc_no_shutup(struct hda_codec *codec)
 {
 }
 static void alc_fixup_no_shutup(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		spec->shutup = alc_no_shutup;
 	}
 }
 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		int val;
 		alc_write_coef_idx(codec, 0xc4, 0x8000);
 		val = alc_read_coef_idx(codec, 0xc2);
 		alc_write_coef_idx(codec, 0xc2, val & 0xfe);
 		snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
 	}
 	alc_fixup_headset_mode(codec, fix, action);
 }
 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
 static int find_ext_mic_pin(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 	hda_nid_t nid;
 	unsigned int defcfg;
 	int i;
 	for (i = 0; i < cfg->num_inputs; i++) {
 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
 			continue;
 		nid = cfg->inputs[i].pin;
 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
 		if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
 			continue;
 		return nid;
 	}
 	return 0;
 }
 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
 				    const struct hda_fixup *fix,
 				    int action)
 {
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PROBE) {
 		int mic_pin = find_ext_mic_pin(codec);
 		int hp_pin = spec->gen.autocfg.hp_pins[0];
 		if (snd_BUG_ON(!mic_pin || !hp_pin))
 			return;
 		snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
 	}
 }
 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
 					     const struct hda_fixup *fix,
 					     int action)
 {
 	struct alc_spec *spec = codec->spec;
 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 	int i;
 	/* The mic boosts on level 2 and 3 are too noisy
 	   on the internal mic input.
 	   Therefore limit the boost to 0 or 1. */
 	if (action != HDA_FIXUP_ACT_PROBE)
 		return;
 	for (i = 0; i < cfg->num_inputs; i++) {
 		hda_nid_t nid = cfg->inputs[i].pin;
 		unsigned int defcfg;
 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
 			continue;
 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
 		if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
 			continue;
 		snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
 					  (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
 					  (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
 					  (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
 					  (0 << AC_AMPCAP_MUTE_SHIFT));
 	}
 }
 static void alc283_hp_automute_hook(struct hda_codec *codec,
 				    struct hda_jack_tbl *jack)
 {
 	struct alc_spec *spec = codec->spec;
 	int vref;
 	msleep(200);
 	snd_hda_gen_hp_automute(codec, jack);
 	vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
 	msleep(600);
 	snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 			    vref);
 }
 static void alc283_fixup_chromebook(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	int val;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		snd_hda_override_wcaps(codec, 0x03, 0);
 		/* Disable AA-loopback as it causes white noise */
 		spec->gen.mixer_nid = 0;
 		break;
 	case HDA_FIXUP_ACT_INIT:
+		/* MIC2-VREF control */
+		/* Set to manual mode */
+		val = alc_read_coef_idx(codec, 0x06);
+		alc_write_coef_idx(codec, 0x06, val & ~0x000c);
 		/* Enable Line1 input control by verb */
 		val = alc_read_coef_idx(codec, 0x1a);
 		alc_write_coef_idx(codec, 0x1a, val | (1 << 4));
 		break;
 	}
 }
 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	int val;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		spec->gen.hp_automute_hook = alc283_hp_automute_hook;
 		break;
 	case HDA_FIXUP_ACT_INIT:
 		/* MIC2-VREF control */
 		/* Set to manual mode */
 		val = alc_read_coef_idx(codec, 0x06);
 		alc_write_coef_idx(codec, 0x06, val & ~0x000c);
 		break;
 	}
 }
 /* mute tablet speaker pin (0x14) via dock plugging in addition */
 static void asus_tx300_automute(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	snd_hda_gen_update_outputs(codec);
 	if (snd_hda_jack_detect(codec, 0x1b))
 		spec->gen.mute_bits |= (1ULL << 0x14);
 }
 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	/* TX300 needs to set up GPIO2 for the speaker amp */
 	static const struct hda_verb gpio2_verbs[] = {
 		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
 		{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
 		{}
 	};
 	static const struct hda_pintbl dock_pins[] = {
 		{ 0x1b, 0x21114000 }, /* dock speaker pin */
 		{}
 	};
 	struct snd_kcontrol *kctl;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		snd_hda_add_verbs(codec, gpio2_verbs);
 		snd_hda_apply_pincfgs(codec, dock_pins);
 		spec->gen.auto_mute_via_amp = 1;
 		spec->gen.automute_hook = asus_tx300_automute;
 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
 						    HDA_GEN_HP_EVENT,
 						    snd_hda_gen_hp_automute);
 		break;
 	case HDA_FIXUP_ACT_BUILD:
 		/* this is a bit tricky; give more sane names for the main
 		 * (tablet) speaker and the dock speaker, respectively
 		 */
 		kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
 		if (kctl)
 			strcpy(kctl->id.name, "Dock Speaker Playback Switch");
 		kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
 		if (kctl)
 			strcpy(kctl->id.name, "Speaker Playback Switch");
 		break;
 	}
 }
 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		/* DAC node 0x03 is giving mono output. We therefore want to
 		   make sure 0x14 (front speaker) and 0x15 (headphones) use the
 		   stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
 		hda_nid_t conn1[2] = { 0x0c };
 		snd_hda_override_conn_list(codec, 0x14, 1, conn1);
 		snd_hda_override_conn_list(codec, 0x15, 1, conn1);
 	}
 }
 /* for hda_fixup_thinkpad_acpi() */
 #include "thinkpad_helper.c"
 enum {
 	ALC269_FIXUP_SONY_VAIO,
 	ALC275_FIXUP_SONY_VAIO_GPIO2,
 	ALC269_FIXUP_DELL_M101Z,
 	ALC269_FIXUP_SKU_IGNORE,
 	ALC269_FIXUP_ASUS_G73JW,
 	ALC269_FIXUP_LENOVO_EAPD,
 	ALC275_FIXUP_SONY_HWEQ,
 	ALC271_FIXUP_DMIC,
 	ALC269_FIXUP_PCM_44K,
 	ALC269_FIXUP_STEREO_DMIC,
 	ALC269_FIXUP_HEADSET_MIC,
 	ALC269_FIXUP_QUANTA_MUTE,
 	ALC269_FIXUP_LIFEBOOK,
 	ALC269_FIXUP_AMIC,
 	ALC269_FIXUP_DMIC,
 	ALC269VB_FIXUP_AMIC,
 	ALC269VB_FIXUP_DMIC,
 	ALC269_FIXUP_HP_MUTE_LED,
 	ALC269_FIXUP_HP_MUTE_LED_MIC1,
 	ALC269_FIXUP_HP_MUTE_LED_MIC2,
 	ALC269_FIXUP_HP_GPIO_LED,
 	ALC269_FIXUP_INV_DMIC,
 	ALC269_FIXUP_LENOVO_DOCK,
 	ALC269_FIXUP_NO_SHUTUP,
 	ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
 	ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
 	ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
 	ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
 	ALC269_FIXUP_HEADSET_MODE,
 	ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
 	ALC269_FIXUP_ASUS_X101_FUNC,
 	ALC269_FIXUP_ASUS_X101_VERB,
 	ALC269_FIXUP_ASUS_X101,
 	ALC271_FIXUP_AMIC_MIC2,
 	ALC271_FIXUP_HP_GATE_MIC_JACK,
 	ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
 	ALC269_FIXUP_ACER_AC700,
 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
 	ALC269VB_FIXUP_ASUS_ZENBOOK,
 	ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
 	ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
 	ALC269VB_FIXUP_ORDISSIMO_EVE2,
 	ALC283_FIXUP_CHROME_BOOK,
 	ALC283_FIXUP_SENSE_COMBO_JACK,
 	ALC282_FIXUP_ASUS_TX300,
 	ALC283_FIXUP_INT_MIC,
 	ALC290_FIXUP_MONO_SPEAKERS,
 	ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
 	ALC290_FIXUP_SUBWOOFER,
 	ALC290_FIXUP_SUBWOOFER_HSJACK,
 	ALC269_FIXUP_THINKPAD_ACPI,
 	ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
 	ALC255_FIXUP_HEADSET_MODE,
 	ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
 };
 static const struct hda_fixup alc269_fixups[] = {
 	[ALC269_FIXUP_SONY_VAIO] = {
 		.type = HDA_FIXUP_PINCTLS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{0x19, PIN_VREFGRD},
 			{}
 		}
 	},
 	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x01, AC_VERB_SET_GPIO_MASK, 0x04},
 			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
 			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_SONY_VAIO
 	},
 	[ALC269_FIXUP_DELL_M101Z] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* Enables internal speaker */
 			{0x20, AC_VERB_SET_COEF_INDEX, 13},
 			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
 			{}
 		}
 	},
 	[ALC269_FIXUP_SKU_IGNORE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_sku_ignore,
 	},
 	[ALC269_FIXUP_ASUS_G73JW] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x17, 0x99130111 }, /* subwoofer */
 			{ }
 		}
 	},
 	[ALC269_FIXUP_LENOVO_EAPD] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
 			{}
 		}
 	},
 	[ALC275_FIXUP_SONY_HWEQ] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hweq,
 		.chained = true,
 		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
 	},
 	[ALC271_FIXUP_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc271_fixup_dmic,
 	},
 	[ALC269_FIXUP_PCM_44K] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_pcm_44k,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
 	},
 	[ALC269_FIXUP_STEREO_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_stereo_dmic,
 	},
 	[ALC269_FIXUP_HEADSET_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_headset_mic,
 	},
 	[ALC269_FIXUP_QUANTA_MUTE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_quanta_mute,
 	},
 	[ALC269_FIXUP_LIFEBOOK] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1a, 0x2101103f }, /* dock line-out */
 			{ 0x1b, 0x23a11040 }, /* dock mic-in */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_QUANTA_MUTE
 	},
 	[ALC269_FIXUP_AMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x0121401f }, /* HP out */
 			{ 0x18, 0x01a19c20 }, /* mic */
 			{ 0x19, 0x99a3092f }, /* int-mic */
 			{ }
 		},
 	},
 	[ALC269_FIXUP_DMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x12, 0x99a3092f }, /* int-mic */
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x0121401f }, /* HP out */
 			{ 0x18, 0x01a19c20 }, /* mic */
 			{ }
 		},
 	},
 	[ALC269VB_FIXUP_AMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x18, 0x01a19c20 }, /* mic */
 			{ 0x19, 0x99a3092f }, /* int-mic */
 			{ 0x21, 0x0121401f }, /* HP out */
 			{ }
 		},
 	},
 	[ALC269VB_FIXUP_DMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x12, 0x99a3092f }, /* int-mic */
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x18, 0x01a19c20 }, /* mic */
 			{ 0x21, 0x0121401f }, /* HP out */
 			{ }
 		},
 	},
 	[ALC269_FIXUP_HP_MUTE_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_mute_led,
 	},
 	[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_mute_led_mic1,
 	},
 	[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_mute_led_mic2,
 	},
 	[ALC269_FIXUP_HP_GPIO_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_gpio_led,
 	},
 	[ALC269_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic_0x12,
 	},
 	[ALC269_FIXUP_NO_SHUTUP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_no_shutup,
 	},
 	[ALC269_FIXUP_LENOVO_DOCK] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x23a11040 }, /* dock mic */
 			{ 0x1b, 0x2121103f }, /* dock headphone */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
 	},
 	[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
 	},
 	[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE
 	},
 	[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x16, 0x21014020 }, /* dock line out */
 			{ 0x19, 0x21a19030 }, /* dock mic */
 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
 	},
 	[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
 	},
 	[ALC269_FIXUP_HEADSET_MODE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode,
 	},
 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_no_hp_mic,
 	},
 	[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MIC
 	},
 	[ALC269_FIXUP_ASUS_X101_FUNC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_x101_headset_mic,
 	},
 	[ALC269_FIXUP_ASUS_X101_VERB] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 			{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
 			{0x20, AC_VERB_SET_PROC_COEF,  0x0310},
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_ASUS_X101_FUNC
 	},
 	[ALC269_FIXUP_ASUS_X101] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x18, 0x04a1182c }, /* Headset mic */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_ASUS_X101_VERB
 	},
 	[ALC271_FIXUP_AMIC_MIC2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x19, 0x01a19c20 }, /* mic */
 			{ 0x1b, 0x99a7012f }, /* int-mic */
 			{ 0x21, 0x0121401f }, /* HP out */
 			{ }
 		},
 	},
 	[ALC271_FIXUP_HP_GATE_MIC_JACK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc271_hp_gate_mic_jack,
 		.chained = true,
 		.chain_id = ALC271_FIXUP_AMIC_MIC2,
 	},
 	[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_limit_int_mic_boost,
 		.chained = true,
 		.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
 	},
 	[ALC269_FIXUP_ACER_AC700] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x12, 0x99a3092f }, /* int-mic */
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x18, 0x03a11c20 }, /* mic */
 			{ 0x1e, 0x0346101e }, /* SPDIF1 */
 			{ 0x21, 0x0321101f }, /* HP out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC271_FIXUP_DMIC,
 	},
 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_limit_int_mic_boost,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
 	},
 	[ALC269VB_FIXUP_ASUS_ZENBOOK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_limit_int_mic_boost,
 		.chained = true,
 		.chain_id = ALC269VB_FIXUP_DMIC,
 	},
 	[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* class-D output amp +5dB */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
 	},
 	[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_limit_int_mic_boost,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
 	},
 	[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x12, 0x99a3092f }, /* int-mic */
 			{ 0x18, 0x03a11d20 }, /* mic */
 			{ 0x19, 0x411111f0 }, /* Unused bogus pin */
 			{ }
 		},
 	},
 	[ALC283_FIXUP_CHROME_BOOK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc283_fixup_chromebook,
 	},
 	[ALC283_FIXUP_SENSE_COMBO_JACK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc283_fixup_sense_combo_jack,
 		.chained = true,
 		.chain_id = ALC283_FIXUP_CHROME_BOOK,
 	},
 	[ALC282_FIXUP_ASUS_TX300] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc282_fixup_asus_tx300,
 	},
 	[ALC283_FIXUP_INT_MIC] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
 			{0x20, AC_VERB_SET_PROC_COEF, 0x0011},
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
 	},
 	[ALC290_FIXUP_SUBWOOFER_HSJACK] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x17, 0x90170112 }, /* subwoofer */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
 	},
 	[ALC290_FIXUP_SUBWOOFER] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x17, 0x90170112 }, /* subwoofer */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC290_FIXUP_MONO_SPEAKERS,
 	},
 	[ALC290_FIXUP_MONO_SPEAKERS] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc290_fixup_mono_speakers,
 	},
 	[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc290_fixup_mono_speakers,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
 	},
 	[ALC269_FIXUP_THINKPAD_ACPI] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = hda_fixup_thinkpad_acpi,
 	},
 	[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC255_FIXUP_HEADSET_MODE
 	},
 	[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
 	},
 	[ALC255_FIXUP_HEADSET_MODE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_alc255,
 	},
 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
 	},
 };
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
 	SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
 	SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
 	SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x060f, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0629, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0632, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x063e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0640, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x064d, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0651, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0652, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0653, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0657, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0658, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x065f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0662, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0668, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
 	SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
 	/* ALC282 */
 	SND_PCI_QUIRK(0x103c, 0x220f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2213, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2266, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2267, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2269, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x227a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x227b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22a0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c1, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22cd, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22ce, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22d0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	/* ALC290 */
 	SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2261, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2262, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x227d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x227e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2280, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2281, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2289, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c6, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c3, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
 	SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
 	SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
 	SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
 	SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
 	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
 	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
 	SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
 	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
 	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
 #if 0
 	/* Below is a quirk table taken from the old code.
 	 * Basically the device should work as is without the fixup table.
 	 * If BIOS doesn't give a proper info, enable the corresponding
 	 * fixup entry.
 	 */
 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
 		      ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
 #endif
 	{}
 };
 static const struct hda_model_fixup alc269_fixup_models[] = {
 	{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
 	{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
 	{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
 	{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
 	{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
 	{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
 	{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
 	{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
 	{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
 	{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
 	{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-chrome"},
 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
 	{}
 };
 static void alc269_fill_coef(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	int val;
 	if (spec->codec_variant != ALC269_TYPE_ALC269VB)
 		return;
 	if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
 		alc_write_coef_idx(codec, 0xf, 0x960b);
 		alc_write_coef_idx(codec, 0xe, 0x8817);
 	}
 	if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
 		alc_write_coef_idx(codec, 0xf, 0x960b);
 		alc_write_coef_idx(codec, 0xe, 0x8814);
 	}
 	if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
 		val = alc_read_coef_idx(codec, 0x04);
 		/* Power up output pin */
 		alc_write_coef_idx(codec, 0x04, val | (1<<11));
 	}
 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
 		val = alc_read_coef_idx(codec, 0xd);
 		if ((val & 0x0c00) >> 10 != 0x1) {
 			/* Capless ramp up clock control */
 			alc_write_coef_idx(codec, 0xd, val | (1<<10));
 		}
 		val = alc_read_coef_idx(codec, 0x17);
 		if ((val & 0x01c0) >> 6 != 0x4) {
 			/* Class D power on reset */
 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
 		}
 	}
 	val = alc_read_coef_idx(codec, 0xd); /* Class D */
 	alc_write_coef_idx(codec, 0xd, val | (1<<14));
 	val = alc_read_coef_idx(codec, 0x4); /* HP */
 	alc_write_coef_idx(codec, 0x4, val | (1<<11));
 }
 /*
  */
 static int patch_alc269(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.shared_mic_vref_pin = 0x18;
 	snd_hda_pick_fixup(codec, alc269_fixup_models,
 		       alc269_fixup_tbl, alc269_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	alc_auto_parse_customize_define(codec);
 	if (has_cdefine_beep(codec))
 		spec->gen.beep_nid = 0x01;
 	switch (codec->vendor_id) {
 	case 0x10ec0269:
 		spec->codec_variant = ALC269_TYPE_ALC269VA;
 		switch (alc_get_coef0(codec) & 0x00f0) {
 		case 0x0010:
 			if (codec->bus->pci &&
 			    codec->bus->pci->subsystem_vendor == 0x1025 &&
 			    spec->cdefine.platform_type == 1)
 				err = alc_codec_rename(codec, "ALC271X");
 			spec->codec_variant = ALC269_TYPE_ALC269VB;
 			break;
 		case 0x0020:
 			if (codec->bus->pci &&
 			    codec->bus->pci->subsystem_vendor == 0x17aa &&
 			    codec->bus->pci->subsystem_device == 0x21f3)
 				err = alc_codec_rename(codec, "ALC3202");
 			spec->codec_variant = ALC269_TYPE_ALC269VC;
 			break;
 		case 0x0030:
 			spec->codec_variant = ALC269_TYPE_ALC269VD;
 			break;
 		default:
 			alc_fix_pll_init(codec, 0x20, 0x04, 15);
 		}
 		if (err < 0)
 			goto error;
 		spec->init_hook = alc269_fill_coef;
 		alc269_fill_coef(codec);
 		break;
 	case 0x10ec0280:
 	case 0x10ec0290:
 		spec->codec_variant = ALC269_TYPE_ALC280;
 		break;
 	case 0x10ec0282:
 		spec->codec_variant = ALC269_TYPE_ALC282;
 		spec->shutup = alc282_shutup;
 		spec->init_hook = alc282_init;
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		spec->codec_variant = ALC269_TYPE_ALC283;
 		spec->shutup = alc283_shutup;
 		spec->init_hook = alc283_init;
 		break;
 	case 0x10ec0284:
 	case 0x10ec0292:
 		spec->codec_variant = ALC269_TYPE_ALC284;
 		break;
 	case 0x10ec0285:
 	case 0x10ec0293:
 		spec->codec_variant = ALC269_TYPE_ALC285;
 		break;
 	case 0x10ec0286:
 		spec->codec_variant = ALC269_TYPE_ALC286;
 		break;
 	case 0x10ec0255:
 		spec->codec_variant = ALC269_TYPE_ALC255;
 		break;
 	}
 	if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
 		spec->has_alc5505_dsp = 1;
 		spec->init_hook = alc5505_dsp_init;
 	}
 	/* automatic parse from the BIOS config */
 	err = alc269_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog && spec->gen.beep_nid)
 		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 #ifdef CONFIG_PM
 	codec->patch_ops.suspend = alc269_suspend;
 	codec->patch_ops.resume = alc269_resume;
 #endif
 	if (!spec->shutup)
 		spec->shutup = alc269_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC861
  */
 static int alc861_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
 	return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
 }
 /* Pin config fixes */
 enum {
 	ALC861_FIXUP_FSC_AMILO_PI1505,
 	ALC861_FIXUP_AMP_VREF_0F,
 	ALC861_FIXUP_NO_JACK_DETECT,
 	ALC861_FIXUP_ASUS_A6RP,
 	ALC660_FIXUP_ASUS_W7J,
 };
 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
 			const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	unsigned int val;
 	if (action != HDA_FIXUP_ACT_INIT)
 		return;
 	val = snd_hda_codec_get_pin_target(codec, 0x0f);
 	if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
 		val |= AC_PINCTL_IN_EN;
 	val |= AC_PINCTL_VREF_50;
 	snd_hda_set_pin_ctl(codec, 0x0f, val);
 	spec->gen.keep_vref_in_automute = 1;
 }
 /* suppress the jack-detection */
 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		codec->no_jack_detect = 1;
 }
 static const struct hda_fixup alc861_fixups[] = {
 	[ALC861_FIXUP_FSC_AMILO_PI1505] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x0b, 0x0221101f }, /* HP */
 			{ 0x0f, 0x90170310 }, /* speaker */
 			{ }
 		}
 	},
 	[ALC861_FIXUP_AMP_VREF_0F] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc861_fixup_asus_amp_vref_0f,
 	},
 	[ALC861_FIXUP_NO_JACK_DETECT] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_no_jack_detect,
 	},
 	[ALC861_FIXUP_ASUS_A6RP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc861_fixup_asus_amp_vref_0f,
 		.chained = true,
 		.chain_id = ALC861_FIXUP_NO_JACK_DETECT,
 	},
 	[ALC660_FIXUP_ASUS_W7J] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* ASUS W7J needs a magic pin setup on unused NID 0x10
 			 * for enabling outputs
 			 */
 			{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 			{ }
 		},
 	}
 };
 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
 	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
 	SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
 	SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
 	SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
 	{}
 };
 /*
  */
 static int patch_alc861(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x15);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.beep_nid = 0x23;
 	snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	/* automatic parse from the BIOS config */
 	err = alc861_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog)
 		set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
 	codec->patch_ops = alc_patch_ops;
 #ifdef CONFIG_PM
 	spec->power_hook = alc_power_eapd;
 #endif
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC861-VD support
  *
  * Based on ALC882
  *
  * In addition, an independent DAC
  */
 static int alc861vd_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
 }
 enum {
 	ALC660VD_FIX_ASUS_GPIO1,
 	ALC861VD_FIX_DALLAS,
 };
 /* exclude VREF80 */
 static void alc861vd_fixup_dallas(struct hda_codec *codec,
 				  const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
 		snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
 	}
 }
 static const struct hda_fixup alc861vd_fixups[] = {
 	[ALC660VD_FIX_ASUS_GPIO1] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* reset GPIO1 */
 			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 			{ }
 		}
 	},
 	[ALC861VD_FIX_DALLAS] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc861vd_fixup_dallas,
 	},
 };
 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
 	{}
 };
 /*
  */
 static int patch_alc861vd(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->gen.beep_nid = 0x23;
 	snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	/* automatic parse from the BIOS config */
 	err = alc861vd_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog)
 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 	codec->patch_ops = alc_patch_ops;
 	spec->shutup = alc_eapd_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC662 support
  *
  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
  * configuration.  Each pin widget can choose any input DACs and a mixer.
  * Each ADC is connected from a mixer of all inputs.  This makes possible
  * 6-channel independent captures.
  *
  * In addition, an independent DAC for the multi-playback (not used in this
  * driver yet).
  */
 /*
  * BIOS auto configuration
  */
 static int alc662_parse_auto_config(struct hda_codec *codec)
 {
 	static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
 	static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
 	static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
 	const hda_nid_t *ssids;
 	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
 	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||
 	    codec->vendor_id == 0x10ec0671)
 		ssids = alc663_ssids;
 	else
 		ssids = alc662_ssids;
 	return alc_parse_auto_config(codec, alc662_ignore, ssids);
 }
 static void alc272_fixup_mario(struct hda_codec *codec,
 			       const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
 				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
 				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
 				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 				      (0 << AC_AMPCAP_MUTE_SHIFT)))
 		codec_warn(codec, "failed to override amp caps for NID 0x2\n");
 }
 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
 	{ .channels = 2,
 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
 	{ .channels = 4,
 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
 	{ }
 };
 /* override the 2.1 chmap */
 static void alc_fixup_bass_chmap(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_BUILD) {
 		struct alc_spec *spec = codec->spec;
 		spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps;
 	}
 }
 /* turn on/off mute LED per vmaster hook */
 static void alc662_led_gpio1_mute_hook(void *private_data, int enabled)
 {
 	struct hda_codec *codec = private_data;
 	struct alc_spec *spec = codec->spec;
 	unsigned int oldval = spec->gpio_led;
 	if (enabled)
 		spec->gpio_led &= ~0x01;
 	else
 		spec->gpio_led |= 0x01;
 	if (spec->gpio_led != oldval)
 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 				    spec->gpio_led);
 }
 /* avoid D3 for keeping GPIO up */
 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
 					  hda_nid_t nid,
 					  unsigned int power_state)
 {
 	struct alc_spec *spec = codec->spec;
 	if (nid == codec->afg && power_state == AC_PWRST_D3 && spec->gpio_led)
 		return AC_PWRST_D0;
 	return power_state;
 }
 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	static const struct hda_verb gpio_init[] = {
 		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
 		{}
 	};
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.vmaster_mute.hook = alc662_led_gpio1_mute_hook;
 		spec->gpio_led = 0;
 		snd_hda_add_verbs(codec, gpio_init);
 		codec->power_filter = gpio_led_power_filter;
 	}
 }
 enum {
 	ALC662_FIXUP_ASPIRE,
 	ALC662_FIXUP_LED_GPIO1,
 	ALC662_FIXUP_IDEAPAD,
 	ALC272_FIXUP_MARIO,
 	ALC662_FIXUP_CZC_P10T,
 	ALC662_FIXUP_SKU_IGNORE,
 	ALC662_FIXUP_HP_RP5800,
 	ALC662_FIXUP_ASUS_MODE1,
 	ALC662_FIXUP_ASUS_MODE2,
 	ALC662_FIXUP_ASUS_MODE3,
 	ALC662_FIXUP_ASUS_MODE4,
 	ALC662_FIXUP_ASUS_MODE5,
 	ALC662_FIXUP_ASUS_MODE6,
 	ALC662_FIXUP_ASUS_MODE7,
 	ALC662_FIXUP_ASUS_MODE8,
 	ALC662_FIXUP_NO_JACK_DETECT,
 	ALC662_FIXUP_ZOTAC_Z68,
 	ALC662_FIXUP_INV_DMIC,
 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
 	ALC668_FIXUP_HEADSET_MODE,
 	ALC662_FIXUP_BASS_MODE4_CHMAP,
 	ALC662_FIXUP_BASS_16,
 	ALC662_FIXUP_BASS_1A,
 	ALC662_FIXUP_BASS_CHMAP,
 	ALC668_FIXUP_AUTO_MUTE,
 };
 static const struct hda_fixup alc662_fixups[] = {
 	[ALC662_FIXUP_ASPIRE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x15, 0x99130112 }, /* subwoofer */
 			{ }
 		}
 	},
 	[ALC662_FIXUP_LED_GPIO1] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc662_fixup_led_gpio1,
 	},
 	[ALC662_FIXUP_IDEAPAD] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x17, 0x99130112 }, /* subwoofer */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_LED_GPIO1,
 	},
 	[ALC272_FIXUP_MARIO] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc272_fixup_mario,
 	},
 	[ALC662_FIXUP_CZC_P10T] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
 			{}
 		}
 	},
 	[ALC662_FIXUP_SKU_IGNORE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_sku_ignore,
 	},
 	[ALC662_FIXUP_HP_RP5800] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x0221201f }, /* HP out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE1] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x18, 0x01a19c20 }, /* mic */
 			{ 0x19, 0x99a3092f }, /* int-mic */
 			{ 0x21, 0x0121401f }, /* HP out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x18, 0x01a19820 }, /* mic */
 			{ 0x19, 0x99a3092f }, /* int-mic */
 			{ 0x1b, 0x0121401f }, /* HP out */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE3] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x0121441f }, /* HP */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x19, 0x99a3094f }, /* int-mic */
 			{ 0x21, 0x01211420 }, /* HP2 */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE4] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x16, 0x99130111 }, /* speaker */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x19, 0x99a3094f }, /* int-mic */
 			{ 0x21, 0x0121441f }, /* HP */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE5] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x0121441f }, /* HP */
 			{ 0x16, 0x99130111 }, /* speaker */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x19, 0x99a3094f }, /* int-mic */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE6] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x15, 0x01211420 }, /* HP2 */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x19, 0x99a3094f }, /* int-mic */
 			{ 0x1b, 0x0121441f }, /* HP */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE7] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x17, 0x99130111 }, /* speaker */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x19, 0x99a3094f }, /* int-mic */
 			{ 0x1b, 0x01214020 }, /* HP */
 			{ 0x21, 0x0121401f }, /* HP */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_ASUS_MODE8] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x14, 0x99130110 }, /* speaker */
 			{ 0x12, 0x99a30970 }, /* int-mic */
 			{ 0x15, 0x01214020 }, /* HP */
 			{ 0x17, 0x99130111 }, /* speaker */
 			{ 0x18, 0x01a19840 }, /* mic */
 			{ 0x21, 0x0121401f }, /* HP */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_SKU_IGNORE
 	},
 	[ALC662_FIXUP_NO_JACK_DETECT] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_no_jack_detect,
 	},
 	[ALC662_FIXUP_ZOTAC_Z68] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1b, 0x02214020 }, /* Front HP */
 			{ }
 		}
 	},
 	[ALC662_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic_0x12,
 	},
 	[ALC668_FIXUP_AUTO_MUTE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_auto_mute_via_amp,
 		.chained = true,
 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
 	},
 	[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
 			{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC668_FIXUP_HEADSET_MODE
 	},
 	[ALC668_FIXUP_HEADSET_MODE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_alc668,
 	},
 	[ALC662_FIXUP_BASS_MODE4_CHMAP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_bass_chmap,
 		.chained = true,
 		.chain_id = ALC662_FIXUP_ASUS_MODE4
 	},
 	[ALC662_FIXUP_BASS_16] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{0x16, 0x80106111}, /* bass speaker */
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
 	},
 	[ALC662_FIXUP_BASS_1A] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{0x1a, 0x80106111}, /* bass speaker */
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_BASS_CHMAP,
 	},
 	[ALC662_FIXUP_BASS_CHMAP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_bass_chmap,
 	},
 };
 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
 	SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
 	SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
 	SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0623, "Dell", ALC668_FIXUP_AUTO_MUTE),
 	SND_PCI_QUIRK(0x1028, 0x0624, "Dell", ALC668_FIXUP_AUTO_MUTE),
 	SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0628, "Dell", ALC668_FIXUP_AUTO_MUTE),
 	SND_PCI_QUIRK(0x1028, 0x064e, "Dell", ALC668_FIXUP_AUTO_MUTE),
 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),
 	SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
 	SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
 	SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
 	SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
 	SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
 	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
 #if 0
 	/* Below is a quirk table taken from the old code.
 	 * Basically the device should work as is without the fixup table.
 	 * If BIOS doesn't give a proper info, enable the corresponding
 	 * fixup entry.
 	 */
 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
 #endif
 	{}
 };
 static const struct hda_model_fixup alc662_fixup_models[] = {
 	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
 	{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
 	{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
 	{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
 	{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
 	{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
 	{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
 	{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
 	{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
 	{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
 	{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
 	{}
 };
 static void alc662_fill_coef(struct hda_codec *codec)
 {
 	int val, coef;
 	coef = alc_get_coef0(codec);
 	switch (codec->vendor_id) {
 	case 0x10ec0662:
 		if ((coef & 0x00f0) == 0x0030) {
 			val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */
 			alc_write_coef_idx(codec, 0x4, val & ~(1<<10));
 		}
 		break;
 	case 0x10ec0272:
 	case 0x10ec0273:
 	case 0x10ec0663:
 	case 0x10ec0665:
 	case 0x10ec0670:
 	case 0x10ec0671:
 	case 0x10ec0672:
 		val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */
 		alc_write_coef_idx(codec, 0xd, val | (1<<14));
 		break;
 	}
 }
 /*
  */
 static int patch_alc662(struct hda_codec *codec)
 {
 	struct alc_spec *spec;
 	int err;
 	err = alc_alloc_spec(codec, 0x0b);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	/* handle multiple HPs as is */
 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
 	spec->init_hook = alc662_fill_coef;
 	alc662_fill_coef(codec);
 	snd_hda_pick_fixup(codec, alc662_fixup_models,
 		       alc662_fixup_tbl, alc662_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	alc_auto_parse_customize_define(codec);
 	if (has_cdefine_beep(codec))
 		spec->gen.beep_nid = 0x01;
 	if ((alc_get_coef0(codec) & (1 << 14)) &&
 	    codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
 	    spec->cdefine.platform_type == 1) {
 		err = alc_codec_rename(codec, "ALC272X");
 		if (err < 0)
 			goto error;
 	}
 	/* automatic parse from the BIOS config */
 	err = alc662_parse_auto_config(codec);
 	if (err < 0)
 		goto error;
 	if (!spec->gen.no_analog && spec->gen.beep_nid) {
 		switch (codec->vendor_id) {
 		case 0x10ec0662:
 			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 			break;
 		case 0x10ec0272:
 		case 0x10ec0663:
 		case 0x10ec0665:
 		case 0x10ec0668:
 			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
 			break;
 		case 0x10ec0273:
 			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
 			break;
 		}
 	}
 	codec->patch_ops = alc_patch_ops;
 	spec->shutup = alc_eapd_shutup;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC680 support
  */
 static int alc680_parse_auto_config(struct hda_codec *codec)
 {
 	return alc_parse_auto_config(codec, NULL, NULL);
 }
 /*
  */
 static int patch_alc680(struct hda_codec *codec)
 {
 	int err;
 	/* ALC680 has no aa-loopback mixer */
 	err = alc_alloc_spec(codec, 0);
 	if (err < 0)
 		return err;
 	/* automatic parse from the BIOS config */
 	err = alc680_parse_auto_config(codec);
 	if (err < 0) {
 		alc_free(codec);
 		return err;
 	}
 	codec->patch_ops = alc_patch_ops;
 	return 0;
 }
 /*
  * patch entries
  */
 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
 	{ .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
 	{ .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },
 	{ .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },
 	{ .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },
 	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
 	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
 	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
 	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
 	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
 	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
 	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
 	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
 	{ .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
 	{ .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
 	{ .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
 	{ .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
 	{ .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },
 	{ .id = 0x10ec0285, .name = "ALC285", .patch = patch_alc269 },
 	{ .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },
 	{ .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
 	{ .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
 	{ .id = 0x10ec0293, .name = "ALC293", .patch = patch_alc269 },
 	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
 	  .patch = patch_alc861 },
 	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
 	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
 	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
 	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
 	  .patch = patch_alc882 },
 	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
 	  .patch = patch_alc662 },
 	{ .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
 	  .patch = patch_alc662 },
 	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
 	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
 	{ .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
 	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
 	{ .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
 	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
 	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
 	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
 	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
 	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
 	  .patch = patch_alc882 },
 	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
 	  .patch = patch_alc882 },
 	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
 	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
 	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
 	  .patch = patch_alc882 },
 	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
 	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
 	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
 	{ .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
 	{ .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
 	{} /* terminator */
 };
 MODULE_ALIAS("snd-hda-codec-id:10ec*");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Realtek HD-audio codec");
 static struct hda_codec_preset_list realtek_list = {
 	.preset = snd_hda_preset_realtek,
 	.owner = THIS_MODULE,
 };
 static int __init patch_realtek_init(void)
 {
 	return snd_hda_add_codec_preset(&realtek_list);
 }
 static void __exit patch_realtek_exit(void)
 {
 	snd_hda_delete_codec_preset(&realtek_list);
 }
 module_init(patch_realtek_init)
 module_exit(patch_realtek_exit)