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 <linux/input.h>

32

#include <linux/input.h>

33

#include <sound/core.h>

33

#include <sound/core.h>

34

#include <sound/jack.h>

34

#include <sound/jack.h>

35

#include "hda_codec.h"

35

#include "hda_codec.h"

36

#include "hda_local.h"

36

#include "hda_local.h"

37

#include "hda_auto_parser.h"

37

#include "hda_auto_parser.h"

38

#include "hda_jack.h"

38

#include "hda_jack.h"

39

#include "hda_generic.h"

39

#include "hda_generic.h"

40

41

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

41

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

42

#define HALT_REALTEK_ALC5505

42

#define HALT_REALTEK_ALC5505

43

44

/* for GPIO Poll */

44

/* for GPIO Poll */

45

#define GPIO_MASK 0x03

45

#define GPIO_MASK 0x03

46

47

/* extra amp-initialization sequence types */

47

/* extra amp-initialization sequence types */

48

enum {

48

enum {

49

ALC_INIT_NONE,

49

ALC_INIT_NONE,

50

ALC_INIT_DEFAULT,

50

ALC_INIT_DEFAULT,

51

ALC_INIT_GPIO1,

51

ALC_INIT_GPIO1,

52

ALC_INIT_GPIO2,

52

ALC_INIT_GPIO2,

53

ALC_INIT_GPIO3,

53

ALC_INIT_GPIO3,

54

};

54

};

55

56

enum {

56

enum {

57

ALC_HEADSET_MODE_UNKNOWN,

57

ALC_HEADSET_MODE_UNKNOWN,

58

ALC_HEADSET_MODE_UNPLUGGED,

58

ALC_HEADSET_MODE_UNPLUGGED,

59

ALC_HEADSET_MODE_HEADSET,

59

ALC_HEADSET_MODE_HEADSET,

60

ALC_HEADSET_MODE_MIC,

60

ALC_HEADSET_MODE_MIC,

61

ALC_HEADSET_MODE_HEADPHONE,

61

ALC_HEADSET_MODE_HEADPHONE,

62

};

62

};

63

64

enum {

64

enum {

65

ALC_HEADSET_TYPE_UNKNOWN,

65

ALC_HEADSET_TYPE_UNKNOWN,

66

ALC_HEADSET_TYPE_CTIA,

66

ALC_HEADSET_TYPE_CTIA,

67

ALC_HEADSET_TYPE_OMTP,

67

ALC_HEADSET_TYPE_OMTP,

68

};

68

};

69

70

enum {

70

enum {

71

ALC_KEY_MICMUTE_INDEX,

71

ALC_KEY_MICMUTE_INDEX,

72

};

72

};

73

74

struct alc_customize_define {

74

struct alc_customize_define {

75

unsigned int sku_cfg;

75

unsigned int sku_cfg;

76

unsigned char port_connectivity;

76

unsigned char port_connectivity;

77

unsigned char check_sum;

77

unsigned char check_sum;

78

unsigned char customization;

78

unsigned char customization;

79

unsigned char external_amp;

79

unsigned char external_amp;

80

unsigned int enable_pcbeep:1;

80

unsigned int enable_pcbeep:1;

81

unsigned int platform_type:1;

81

unsigned int platform_type:1;

82

unsigned int swap:1;

82

unsigned int swap:1;

83

unsigned int override:1;

83

unsigned int override:1;

84

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

84

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

85

};

85

};

86

87

struct alc_spec {

87

struct alc_spec {

88

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

88

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

89

90

/* codec parameterization */

90

/* codec parameterization */

91

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

91

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

92

unsigned int num_mixers;

92

unsigned int num_mixers;

93

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

93

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

94

95

struct alc_customize_define cdefine;

95

struct alc_customize_define cdefine;

96

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

96

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

97

98

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

98

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

99

int mute_led_polarity;

99

int mute_led_polarity;

100

hda_nid_t mute_led_nid;

100

hda_nid_t mute_led_nid;

101

hda_nid_t cap_mute_led_nid;

101

hda_nid_t cap_mute_led_nid;

102

103

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

103

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

104

unsigned int gpio_mute_led_mask;

104

unsigned int gpio_mute_led_mask;

105

unsigned int gpio_mic_led_mask;

105

unsigned int gpio_mic_led_mask;

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

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

118

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

119

120

int init_amp;

120

int init_amp;

121

int codec_variant; /* flag for other variants */

121

int codec_variant; /* flag for other variants */

122

unsigned int has_alc5505_dsp:1;

122

unsigned int has_alc5505_dsp:1;

123

unsigned int no_depop_delay:1;

123

unsigned int no_depop_delay:1;

124

125

/* for PLL fix */

125

/* for PLL fix */

126

hda_nid_t pll_nid;

126

hda_nid_t pll_nid;

127

unsigned int pll_coef_idx, pll_coef_bit;

127

unsigned int pll_coef_idx, pll_coef_bit;

128

unsigned int coef0;

128

unsigned int coef0;

129

struct input_dev *kb_dev;

129

struct input_dev *kb_dev;

130

u8 alc_mute_keycode_map[1];

130

u8 alc_mute_keycode_map[1];

131

};

131

};

132

133

/*

133

/*

134

* COEF access helper functions

134

* COEF access helper functions

135

*/

135

*/

136

137

static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,

137

static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,

138

unsigned int coef_idx)

138

unsigned int coef_idx)

139

{

139

{

140

unsigned int val;

140

unsigned int val;

141

142

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);

142

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);

143

val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);

143

val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);

144

return val;

144

return val;

145

}

145

}

146

147

#define alc_read_coef_idx(codec, coef_idx) \

147

#define alc_read_coef_idx(codec, coef_idx) \

148

alc_read_coefex_idx(codec, 0x20, coef_idx)

148

alc_read_coefex_idx(codec, 0x20, coef_idx)

149

150

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

150

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

151

unsigned int coef_idx, unsigned int coef_val)

151

unsigned int coef_idx, unsigned int coef_val)

152

{

152

{

153

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);

153

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);

154

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);

154

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);

155

}

155

}

156

157

#define alc_write_coef_idx(codec, coef_idx, coef_val) \

157

#define alc_write_coef_idx(codec, coef_idx, coef_val) \

158

alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)

158

alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)

159

160

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

160

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

161

unsigned int coef_idx, unsigned int mask,

161

unsigned int coef_idx, unsigned int mask,

162

unsigned int bits_set)

162

unsigned int bits_set)

163

{

163

{

164

unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);

164

unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);

165

166

if (val != -1)

166

if (val != -1)

167

alc_write_coefex_idx(codec, nid, coef_idx,

167

alc_write_coefex_idx(codec, nid, coef_idx,

168

(val & ~mask) | bits_set);

168

(val & ~mask) | bits_set);

169

}

169

}

170

171

#define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \

171

#define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \

172

alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)

172

alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)

173

174

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

174

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

175

static unsigned int alc_get_coef0(struct hda_codec *codec)

175

static unsigned int alc_get_coef0(struct hda_codec *codec)

176

{

176

{

177

struct alc_spec *spec = codec->spec;

177

struct alc_spec *spec = codec->spec;

178

179

if (!spec->coef0)

179

if (!spec->coef0)

180

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

180

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

181

return spec->coef0;

181

return spec->coef0;

182

}

182

}

183

184

/* coef writes/updates batch */

184

/* coef writes/updates batch */

185

struct coef_fw {

185

struct coef_fw {

186

unsigned char nid;

186

unsigned char nid;

187

unsigned char idx;

187

unsigned char idx;

188

unsigned short mask;

188

unsigned short mask;

189

unsigned short val;

189

unsigned short val;

190

};

190

};

191

192

#define UPDATE_COEFEX(_nid, _idx, _mask, _val) \

192

#define UPDATE_COEFEX(_nid, _idx, _mask, _val) \

193

{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }

193

{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }

194

#define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)

194

#define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)

195

#define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)

195

#define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)

196

#define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)

196

#define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)

197

198

static void alc_process_coef_fw(struct hda_codec *codec,

198

static void alc_process_coef_fw(struct hda_codec *codec,

199

const struct coef_fw *fw)

199

const struct coef_fw *fw)

200

{

200

{

201

for (; fw->nid; fw++) {

201

for (; fw->nid; fw++) {

202

if (fw->mask == (unsigned short)-1)

202

if (fw->mask == (unsigned short)-1)

203

alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);

203

alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);

204

else

204

else

205

alc_update_coefex_idx(codec, fw->nid, fw->idx,

205

alc_update_coefex_idx(codec, fw->nid, fw->idx,

206

fw->mask, fw->val);

206

fw->mask, fw->val);

207

}

207

}

208

}

208

}

209

210

/*

210

/*

211

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

211

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

212

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

212

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

213

* called in init().

213

* called in init().

214

*/

214

*/

215

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

215

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

216

{

216

{

217

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

217

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

218

return;

218

return;

219

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

219

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

220

}

220

}

221

222

/*

222

/*

223

* GPIO setup tables, used in initialization

223

* GPIO setup tables, used in initialization

224

*/

224

*/

225

/* Enable GPIO mask and set output */

225

/* Enable GPIO mask and set output */

226

static const struct hda_verb alc_gpio1_init_verbs[] = {

226

static const struct hda_verb alc_gpio1_init_verbs[] = {

227

{0x01, AC_VERB_SET_GPIO_MASK, 0x01},

227

{0x01, AC_VERB_SET_GPIO_MASK, 0x01},

228

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

228

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

229

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

229

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

230

{ }

230

{ }

231

};

231

};

232

233

static const struct hda_verb alc_gpio2_init_verbs[] = {

233

static const struct hda_verb alc_gpio2_init_verbs[] = {

234

{0x01, AC_VERB_SET_GPIO_MASK, 0x02},

234

{0x01, AC_VERB_SET_GPIO_MASK, 0x02},

235

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},

235

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},

236

{0x01, AC_VERB_SET_GPIO_DATA, 0x02},

236

{0x01, AC_VERB_SET_GPIO_DATA, 0x02},

237

{ }

237

{ }

238

};

238

};

239

240

static const struct hda_verb alc_gpio3_init_verbs[] = {

240

static const struct hda_verb alc_gpio3_init_verbs[] = {

241

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

241

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

242

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},

242

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},

243

{0x01, AC_VERB_SET_GPIO_DATA, 0x03},

243

{0x01, AC_VERB_SET_GPIO_DATA, 0x03},

244

{ }

244

{ }

245

};

245

};

246

247

/*

247

/*

248

* Fix hardware PLL issue

248

* Fix hardware PLL issue

249

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

249

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

250

* the default value is 1.

250

* the default value is 1.

251

*/

251

*/

252

static void alc_fix_pll(struct hda_codec *codec)

252

static void alc_fix_pll(struct hda_codec *codec)

253

{

253

{

254

struct alc_spec *spec = codec->spec;

254

struct alc_spec *spec = codec->spec;

255

256

if (spec->pll_nid)

256

if (spec->pll_nid)

257

alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,

257

alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,

258

1 << spec->pll_coef_bit, 0);

258

1 << spec->pll_coef_bit, 0);

259

}

259

}

260

261

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

261

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

262

unsigned int coef_idx, unsigned int coef_bit)

262

unsigned int coef_idx, unsigned int coef_bit)

263

{

263

{

264

struct alc_spec *spec = codec->spec;

264

struct alc_spec *spec = codec->spec;

265

spec->pll_nid = nid;

265

spec->pll_nid = nid;

266

spec->pll_coef_idx = coef_idx;

266

spec->pll_coef_idx = coef_idx;

267

spec->pll_coef_bit = coef_bit;

267

spec->pll_coef_bit = coef_bit;

268

alc_fix_pll(codec);

268

alc_fix_pll(codec);

269

}

269

}

270

271

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

271

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

272

static void alc_update_knob_master(struct hda_codec *codec,

272

static void alc_update_knob_master(struct hda_codec *codec,

273

struct hda_jack_callback *jack)

273

struct hda_jack_callback *jack)

274

{

274

{

275

unsigned int val;

275

unsigned int val;

276

struct snd_kcontrol *kctl;

276

struct snd_kcontrol *kctl;

277

struct snd_ctl_elem_value *uctl;

277

struct snd_ctl_elem_value *uctl;

278

279

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

279

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

280

if (!kctl)

280

if (!kctl)

281

return;

281

return;

282

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

282

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

283

if (!uctl)

283

if (!uctl)

284

return;

284

return;

285

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

285

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

286

AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);

286

AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);

287

val &= HDA_AMP_VOLMASK;

287

val &= HDA_AMP_VOLMASK;

288

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

288

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

289

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

289

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

290

kctl->put(kctl, uctl);

290

kctl->put(kctl, uctl);

291

kfree(uctl);

291

kfree(uctl);

292

}

292

}

293

294

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

294

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

295

{

295

{

296

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

296

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

297

Here we adjust it properly. */

297

Here we adjust it properly. */

298

snd_hda_jack_unsol_event(codec, res >> 2);

298

snd_hda_jack_unsol_event(codec, res >> 2);

299

}

299

}

300

301

/* Change EAPD to verb control */

301

/* Change EAPD to verb control */

302

static void alc_fill_eapd_coef(struct hda_codec *codec)

302

static void alc_fill_eapd_coef(struct hda_codec *codec)

303

{

303

{

304

int coef;

304

int coef;

305

306

coef = alc_get_coef0(codec);

306

coef = alc_get_coef0(codec);

307

308

switch (codec->core.vendor_id) {

308

switch (codec->core.vendor_id) {

309

case 0x10ec0262:

309

case 0x10ec0262:

310

alc_update_coef_idx(codec, 0x7, 0, 1<<5);

310

alc_update_coef_idx(codec, 0x7, 0, 1<<5);

311

break;

311

break;

312

case 0x10ec0267:

312

case 0x10ec0267:

313

case 0x10ec0268:

313

case 0x10ec0268:

314

alc_update_coef_idx(codec, 0x7, 0, 1<<13);

314

alc_update_coef_idx(codec, 0x7, 0, 1<<13);

315

break;

315

break;

316

case 0x10ec0269:

316

case 0x10ec0269:

317

if ((coef & 0x00f0) == 0x0010)

317

if ((coef & 0x00f0) == 0x0010)

318

alc_update_coef_idx(codec, 0xd, 0, 1<<14);

318

alc_update_coef_idx(codec, 0xd, 0, 1<<14);

319

if ((coef & 0x00f0) == 0x0020)

319

if ((coef & 0x00f0) == 0x0020)

320

alc_update_coef_idx(codec, 0x4, 1<<15, 0);

320

alc_update_coef_idx(codec, 0x4, 1<<15, 0);

321

if ((coef & 0x00f0) == 0x0030)

321

if ((coef & 0x00f0) == 0x0030)

322

alc_update_coef_idx(codec, 0x10, 1<<9, 0);

322

alc_update_coef_idx(codec, 0x10, 1<<9, 0);

323

break;

323

break;

324

case 0x10ec0280:

324

case 0x10ec0280:

325

case 0x10ec0284:

325

case 0x10ec0284:

326

case 0x10ec0290:

326

case 0x10ec0290:

327

case 0x10ec0292:

327

case 0x10ec0292:

328

alc_update_coef_idx(codec, 0x4, 1<<15, 0);

328

alc_update_coef_idx(codec, 0x4, 1<<15, 0);

329

break;

329

break;

330

case 0x10ec0225:

330

case 0x10ec0225:

331

case 0x10ec0233:

331

case 0x10ec0233:

332

case 0x10ec0255:

332

case 0x10ec0255:

333

case 0x10ec0256:

333

case 0x10ec0256:

334

case 0x10ec0282:

334

case 0x10ec0282:

335

case 0x10ec0283:

335

case 0x10ec0283:

336

case 0x10ec0286:

336

case 0x10ec0286:

337

case 0x10ec0288:

337

case 0x10ec0288:

338

case 0x10ec0295:

338

case 0x10ec0295:

339

case 0x10ec0298:

339

case 0x10ec0298:

340

alc_update_coef_idx(codec, 0x10, 1<<9, 0);

340

alc_update_coef_idx(codec, 0x10, 1<<9, 0);

341

break;

341

break;

342

case 0x10ec0285:

342

case 0x10ec0285:

343

case 0x10ec0293:

343

case 0x10ec0293:

344

alc_update_coef_idx(codec, 0xa, 1<<13, 0);

344

alc_update_coef_idx(codec, 0xa, 1<<13, 0);

345

break;

345

break;

346

case 0x10ec0234:

346

case 0x10ec0234:

347

case 0x10ec0274:

347

case 0x10ec0274:

348

case 0x10ec0294:

348

case 0x10ec0294:

349

alc_update_coef_idx(codec, 0x10, 1<<15, 0);

349

alc_update_coef_idx(codec, 0x10, 1<<15, 0);

350

break;

350

break;

351

case 0x10ec0662:

351

case 0x10ec0662:

352

if ((coef & 0x00f0) == 0x0030)

352

if ((coef & 0x00f0) == 0x0030)

353

alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */

353

alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */

354

break;

354

break;

355

case 0x10ec0272:

355

case 0x10ec0272:

356

case 0x10ec0273:

356

case 0x10ec0273:

357

case 0x10ec0663:

357

case 0x10ec0663:

358

case 0x10ec0665:

358

case 0x10ec0665:

359

case 0x10ec0670:

359

case 0x10ec0670:

360

case 0x10ec0671:

360

case 0x10ec0671:

361

case 0x10ec0672:

361

case 0x10ec0672:

362

alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */

362

alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */

363

break;

363

break;

364

case 0x10ec0668:

364

case 0x10ec0668:

365

alc_update_coef_idx(codec, 0x7, 3<<13, 0);

365

alc_update_coef_idx(codec, 0x7, 3<<13, 0);

366

break;

366

break;

367

case 0x10ec0867:

367

case 0x10ec0867:

368

alc_update_coef_idx(codec, 0x4, 1<<10, 0);

368

alc_update_coef_idx(codec, 0x4, 1<<10, 0);

369

break;

369

break;

370

case 0x10ec0888:

370

case 0x10ec0888:

371

if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)

371

if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)

372

alc_update_coef_idx(codec, 0x7, 1<<5, 0);

372

alc_update_coef_idx(codec, 0x7, 1<<5, 0);

373

break;

373

break;

374

case 0x10ec0892:

374

case 0x10ec0892:

375

alc_update_coef_idx(codec, 0x7, 1<<5, 0);

375

alc_update_coef_idx(codec, 0x7, 1<<5, 0);

376

break;

376

break;

377

case 0x10ec0899:

377

case 0x10ec0899:

378

case 0x10ec0900:

378

case 0x10ec0900:

379

alc_update_coef_idx(codec, 0x7, 1<<1, 0);

379

alc_update_coef_idx(codec, 0x7, 1<<1, 0);

380

break;

380

break;

381

}

381

}

382

}

382

}

383

384

/* additional initialization for ALC888 variants */

384

/* additional initialization for ALC888 variants */

385

static void alc888_coef_init(struct hda_codec *codec)

385

static void alc888_coef_init(struct hda_codec *codec)

386

{

386

{

387

switch (alc_get_coef0(codec) & 0x00f0) {

387

switch (alc_get_coef0(codec) & 0x00f0) {

388

/* alc888-VA */

388

/* alc888-VA */

389

case 0x00:

389

case 0x00:

390

/* alc888-VB */

390

/* alc888-VB */

391

case 0x10:

391

case 0x10:

392

alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */

392

alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */

393

break;

393

break;

394

}

394

}

395

}

395

}

396

397

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

397

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

398

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

398

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

399

{

399

{

400

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

400

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

401

return;

401

return;

402

if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)

402

if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)

403

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,

403

snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,

404

on ? 2 : 0);

404

on ? 2 : 0);

405

}

405

}

406

407

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

407

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

408

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

408

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

409

{

409

{

410

/* We currently only handle front, HP */

410

/* We currently only handle front, HP */

411

static hda_nid_t pins[] = {

411

static hda_nid_t pins[] = {

412

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

412

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

413

};

413

};

414

hda_nid_t *p;

414

hda_nid_t *p;

415

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

415

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

416

set_eapd(codec, *p, on);

416

set_eapd(codec, *p, on);

417

}

417

}

418

419

/* generic shutup callback;

419

/* generic shutup callback;

420

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

420

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

421

*/

421

*/

422

static void alc_eapd_shutup(struct hda_codec *codec)

422

static void alc_eapd_shutup(struct hda_codec *codec)

423

{

423

{

424

struct alc_spec *spec = codec->spec;

424

struct alc_spec *spec = codec->spec;

425

426

alc_auto_setup_eapd(codec, false);

426

alc_auto_setup_eapd(codec, false);

427

if (!spec->no_depop_delay)

427

if (!spec->no_depop_delay)

428

msleep(200);

428

msleep(200);

429

snd_hda_shutup_pins(codec);

429

snd_hda_shutup_pins(codec);

430

}

430

}

431

432

/* generic EAPD initialization */

432

/* generic EAPD initialization */

433

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

433

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

434

{

434

{

435

alc_fill_eapd_coef(codec);

435

alc_fill_eapd_coef(codec);

436

alc_auto_setup_eapd(codec, true);

436

alc_auto_setup_eapd(codec, true);

437

switch (type) {

437

switch (type) {

438

case ALC_INIT_GPIO1:

438

case ALC_INIT_GPIO1:

439

snd_hda_sequence_write(codec, alc_gpio1_init_verbs);

439

snd_hda_sequence_write(codec, alc_gpio1_init_verbs);

440

break;

440

break;

441

case ALC_INIT_GPIO2:

441

case ALC_INIT_GPIO2:

442

snd_hda_sequence_write(codec, alc_gpio2_init_verbs);

442

snd_hda_sequence_write(codec, alc_gpio2_init_verbs);

443

break;

443

break;

444

case ALC_INIT_GPIO3:

444

case ALC_INIT_GPIO3:

445

snd_hda_sequence_write(codec, alc_gpio3_init_verbs);

445

snd_hda_sequence_write(codec, alc_gpio3_init_verbs);

446

break;

446

break;

447

case ALC_INIT_DEFAULT:

447

case ALC_INIT_DEFAULT:

448

switch (codec->core.vendor_id) {

448

switch (codec->core.vendor_id) {

449

case 0x10ec0260:

449

case 0x10ec0260:

450

alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);

450

alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);

451

break;

451

break;

452

case 0x10ec0880:

452

case 0x10ec0880:

453

case 0x10ec0882:

453

case 0x10ec0882:

454

case 0x10ec0883:

454

case 0x10ec0883:

455

case 0x10ec0885:

455

case 0x10ec0885:

456

alc_update_coef_idx(codec, 7, 0, 0x2030);

456

alc_update_coef_idx(codec, 7, 0, 0x2030);

457

break;

457

break;

458

case 0x10ec0888:

458

case 0x10ec0888:

459

alc888_coef_init(codec);

459

alc888_coef_init(codec);

460

break;

460

break;

461

}

461

}

462

break;

462

break;

463

}

463

}

464

}

464

}

465

466

467

/*

467

/*

468

* Realtek SSID verification

468

* Realtek SSID verification

469

*/

469

*/

470

471

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

471

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

472

* the driver to ignore any present sku defines.

472

* the driver to ignore any present sku defines.

473

*/

473

*/

474

#define ALC_FIXUP_SKU_IGNORE (2)

474

#define ALC_FIXUP_SKU_IGNORE (2)

475

476

static void alc_fixup_sku_ignore(struct hda_codec *codec,

476

static void alc_fixup_sku_ignore(struct hda_codec *codec,

477

const struct hda_fixup *fix, int action)

477

const struct hda_fixup *fix, int action)

478

{

478

{

479

struct alc_spec *spec = codec->spec;

479

struct alc_spec *spec = codec->spec;

480

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

480

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

481

spec->cdefine.fixup = 1;

481

spec->cdefine.fixup = 1;

482

spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;

482

spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;

483

}

483

}

484

}

484

}

485

486

static void alc_fixup_no_depop_delay(struct hda_codec *codec,

486

static void alc_fixup_no_depop_delay(struct hda_codec *codec,

487

const struct hda_fixup *fix, int action)

487

const struct hda_fixup *fix, int action)

488

{

488

{

489

struct alc_spec *spec = codec->spec;

489

struct alc_spec *spec = codec->spec;

490

491

if (action == HDA_FIXUP_ACT_PROBE) {

491

if (action == HDA_FIXUP_ACT_PROBE) {

492

spec->no_depop_delay = 1;

492

spec->no_depop_delay = 1;

493

codec->depop_delay = 0;

493

codec->depop_delay = 0;

494

}

494

}

495

}

495

}

496

497

static int alc_auto_parse_customize_define(struct hda_codec *codec)

497

static int alc_auto_parse_customize_define(struct hda_codec *codec)

498

{

498

{

499

unsigned int ass, tmp, i;

499

unsigned int ass, tmp, i;

500

unsigned nid = 0;

500

unsigned nid = 0;

501

struct alc_spec *spec = codec->spec;

501

struct alc_spec *spec = codec->spec;

502

503

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

503

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

504

505

if (spec->cdefine.fixup) {

505

if (spec->cdefine.fixup) {

506

ass = spec->cdefine.sku_cfg;

506

ass = spec->cdefine.sku_cfg;

507

if (ass == ALC_FIXUP_SKU_IGNORE)

507

if (ass == ALC_FIXUP_SKU_IGNORE)

508

return -1;

508

return -1;

509

goto do_sku;

509

goto do_sku;

510

}

510

}

511

512

if (!codec->bus->pci)

512

if (!codec->bus->pci)

513

return -1;

513

return -1;

514

ass = codec->core.subsystem_id & 0xffff;

514

ass = codec->core.subsystem_id & 0xffff;

515

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

515

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

516

goto do_sku;

516

goto do_sku;

517

518

nid = 0x1d;

518

nid = 0x1d;

519

if (codec->core.vendor_id == 0x10ec0260)

519

if (codec->core.vendor_id == 0x10ec0260)

520

nid = 0x17;

520

nid = 0x17;

521

ass = snd_hda_codec_get_pincfg(codec, nid);

521

ass = snd_hda_codec_get_pincfg(codec, nid);

522

523

if (!(ass & 1)) {

523

if (!(ass & 1)) {

524

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

524

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

525

codec->core.chip_name, ass);

525

codec->core.chip_name, ass);

526

return -1;

526

return -1;

527

}

527

}

528

529

/* check sum */

529

/* check sum */

530

tmp = 0;

530

tmp = 0;

531

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

531

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

532

if ((ass >> i) & 1)

532

if ((ass >> i) & 1)

533

tmp++;

533

tmp++;

534

}

534

}

535

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

535

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

536

return -1;

536

return -1;

537

538

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

538

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

539

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

539

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

540

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

540

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

541

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

541

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

542

do_sku:

542

do_sku:

543

spec->cdefine.sku_cfg = ass;

543

spec->cdefine.sku_cfg = ass;

544

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

544

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

545

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

545

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

546

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

546

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

547

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

547

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

548

549

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

549

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

550

nid, spec->cdefine.sku_cfg);

550

nid, spec->cdefine.sku_cfg);

551

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

551

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

552

spec->cdefine.port_connectivity);

552

spec->cdefine.port_connectivity);

553

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

553

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

554

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

554

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

555

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

555

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

556

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

556

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

557

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

557

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

558

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

558

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

559

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

559

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

560

561

return 0;

561

return 0;

562

}

562

}

563

564

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

564

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

565

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

565

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

566

{

566

{

567

int i;

567

int i;

568

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

568

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

569

if (list[i] == nid)

569

if (list[i] == nid)

570

return i;

570

return i;

571

return -1;

571

return -1;

572

}

572

}

573

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

573

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

574

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

574

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

575

{

575

{

576

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

576

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

577

}

577

}

578

579

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

579

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

580

* return 1 if initialized, 0 if invalid SSID

580

* return 1 if initialized, 0 if invalid SSID

581

*/

581

*/

582

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

582

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

583

* 31 ~ 16 : Manufacture ID

583

* 31 ~ 16 : Manufacture ID

584

* 15 ~ 8 : SKU ID

584

* 15 ~ 8 : SKU ID

585

* 7 ~ 0 : Assembly ID

585

* 7 ~ 0 : Assembly ID

586

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

586

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

587

*/

587

*/

588

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

588

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

589

{

589

{

590

unsigned int ass, tmp, i;

590

unsigned int ass, tmp, i;

591

unsigned nid;

591

unsigned nid;

592

struct alc_spec *spec = codec->spec;

592

struct alc_spec *spec = codec->spec;

593

594

if (spec->cdefine.fixup) {

594

if (spec->cdefine.fixup) {

595

ass = spec->cdefine.sku_cfg;

595

ass = spec->cdefine.sku_cfg;

596

if (ass == ALC_FIXUP_SKU_IGNORE)

596

if (ass == ALC_FIXUP_SKU_IGNORE)

597

return 0;

597

return 0;

598

goto do_sku;

598

goto do_sku;

599

}

599

}

600

601

ass = codec->core.subsystem_id & 0xffff;

601

ass = codec->core.subsystem_id & 0xffff;

602

if (codec->bus->pci &&

602

if (codec->bus->pci &&

603

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

603

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

604

goto do_sku;

604

goto do_sku;

605

606

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

606

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

607

/*

607

/*

608

* 31~30 : port connectivity

608

* 31~30 : port connectivity

609

* 29~21 : reserve

609

* 29~21 : reserve

610

* 20 : PCBEEP input

610

* 20 : PCBEEP input

611

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

611

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

612

* 15~1 : Custom

612

* 15~1 : Custom

613

* 0 : override

613

* 0 : override

614

*/

614

*/

615

nid = 0x1d;

615

nid = 0x1d;

616

if (codec->core.vendor_id == 0x10ec0260)

616

if (codec->core.vendor_id == 0x10ec0260)

617

nid = 0x17;

617

nid = 0x17;

618

ass = snd_hda_codec_get_pincfg(codec, nid);

618

ass = snd_hda_codec_get_pincfg(codec, nid);

619

codec_dbg(codec,

619

codec_dbg(codec,

620

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

620

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

621

ass, nid);

621

ass, nid);

622

if (!(ass & 1))

622

if (!(ass & 1))

623

return 0;

623

return 0;

624

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

624

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

625

return 0;

625

return 0;

626

627

/* check sum */

627

/* check sum */

628

tmp = 0;

628

tmp = 0;

629

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

629

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

630

if ((ass >> i) & 1)

630

if ((ass >> i) & 1)

631

tmp++;

631

tmp++;

632

}

632

}

633

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

633

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

634

return 0;

634

return 0;

635

do_sku:

635

do_sku:

636

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

636

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

637

ass & 0xffff, codec->core.vendor_id);

637

ass & 0xffff, codec->core.vendor_id);

638

/*

638

/*

639

* 0 : override

639

* 0 : override

640

* 1 : Swap Jack

640

* 1 : Swap Jack

641

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

641

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

642

* 3~5 : External Amplifier control

642

* 3~5 : External Amplifier control

643

* 7~6 : Reserved

643

* 7~6 : Reserved

644

*/

644

*/

645

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

645

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

646

switch (tmp) {

646

switch (tmp) {

647

case 1:

647

case 1:

648

spec->init_amp = ALC_INIT_GPIO1;

648

spec->init_amp = ALC_INIT_GPIO1;

649

break;

649

break;

650

case 3:

650

case 3:

651

spec->init_amp = ALC_INIT_GPIO2;

651

spec->init_amp = ALC_INIT_GPIO2;

652

break;

652

break;

653

case 7:

653

case 7:

654

spec->init_amp = ALC_INIT_GPIO3;

654

spec->init_amp = ALC_INIT_GPIO3;

655

break;

655

break;

656

case 5:

656

case 5:

657

default:

657

default:

658

spec->init_amp = ALC_INIT_DEFAULT;

658

spec->init_amp = ALC_INIT_DEFAULT;

659

break;

659

break;

660

}

660

}

661

662

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

662

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

663

* when the external headphone out jack is plugged"

663

* when the external headphone out jack is plugged"

664

*/

664

*/

665

if (!(ass & 0x8000))

665

if (!(ass & 0x8000))

666

return 1;

666

return 1;

667

/*

667

/*

668

* 10~8 : Jack location

668

* 10~8 : Jack location

669

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

669

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

670

* 14~13: Resvered

670

* 14~13: Resvered

671

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

671

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

672

* when the external headphone out jack is plugged"

672

* when the external headphone out jack is plugged"

673

*/

673

*/

674

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

674

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

675

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

675

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

676

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

676

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

677

hda_nid_t nid;

677

hda_nid_t nid;

678

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

678

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

679

nid = ports[tmp];

679

nid = ports[tmp];

680

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

680

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

681

spec->gen.autocfg.line_outs))

681

spec->gen.autocfg.line_outs))

682

return 1;

682

return 1;

683

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

683

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

684

}

684

}

685

return 1;

685

return 1;

686

}

686

}

687

688

/* Check the validity of ALC subsystem-id

688

/* Check the validity of ALC subsystem-id

689

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

689

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

690

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

690

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

691

{

691

{

692

if (!alc_subsystem_id(codec, ports)) {

692

if (!alc_subsystem_id(codec, ports)) {

693

struct alc_spec *spec = codec->spec;

693

struct alc_spec *spec = codec->spec;

694

codec_dbg(codec,

694

codec_dbg(codec,

695

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

695

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

696

spec->init_amp = ALC_INIT_DEFAULT;

696

spec->init_amp = ALC_INIT_DEFAULT;

697

}

697

}

698

}

698

}

699

700

/*

700

/*

701

*/

701

*/

702

703

static void alc_fixup_inv_dmic(struct hda_codec *codec,

703

static void alc_fixup_inv_dmic(struct hda_codec *codec,

704

const struct hda_fixup *fix, int action)

704

const struct hda_fixup *fix, int action)

705

{

705

{

706

struct alc_spec *spec = codec->spec;

706

struct alc_spec *spec = codec->spec;

707

708

spec->gen.inv_dmic_split = 1;

708

spec->gen.inv_dmic_split = 1;

709

}

709

}

710

711

712

#ifdef CONFIG_SND_HDA_INPUT_BEEP

712

#ifdef CONFIG_SND_HDA_INPUT_BEEP

713

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

713

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

714

static const struct snd_kcontrol_new alc_beep_mixer[] = {

714

static const struct snd_kcontrol_new alc_beep_mixer[] = {

715

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

715

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

716

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

716

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

717

{ } /* end */

717

{ } /* end */

718

};

718

};

719

#endif

719

#endif

720

721

static int alc_build_controls(struct hda_codec *codec)

721

static int alc_build_controls(struct hda_codec *codec)

722

{

722

{

723

struct alc_spec *spec = codec->spec;

723

struct alc_spec *spec = codec->spec;

724

int i, err;

724

int i, err;

725

726

err = snd_hda_gen_build_controls(codec);

726

err = snd_hda_gen_build_controls(codec);

727

if (err < 0)

727

if (err < 0)

728

return err;

728

return err;

729

730

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

730

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

731

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

731

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

732

if (err < 0)

732

if (err < 0)

733

return err;

733

return err;

734

}

734

}

735

736

#ifdef CONFIG_SND_HDA_INPUT_BEEP

736

#ifdef CONFIG_SND_HDA_INPUT_BEEP

737

/* create beep controls if needed */

737

/* create beep controls if needed */

738

if (spec->beep_amp) {

738

if (spec->beep_amp) {

739

const struct snd_kcontrol_new *knew;

739

const struct snd_kcontrol_new *knew;

740

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

740

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

741

struct snd_kcontrol *kctl;

741

struct snd_kcontrol *kctl;

742

kctl = snd_ctl_new1(knew, codec);

742

kctl = snd_ctl_new1(knew, codec);

743

if (!kctl)

743

if (!kctl)

744

return -ENOMEM;

744

return -ENOMEM;

745

kctl->private_value = spec->beep_amp;

745

kctl->private_value = spec->beep_amp;

746

err = snd_hda_ctl_add(codec, 0, kctl);

746

err = snd_hda_ctl_add(codec, 0, kctl);

747

if (err < 0)

747

if (err < 0)

748

return err;

748

return err;

749

}

749

}

750

}

750

}

751

#endif

751

#endif

752

753

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);

753

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);

754

return 0;

754

return 0;

755

}

755

}

756

757

758

/*

758

/*

759

* Common callbacks

759

* Common callbacks

760

*/

760

*/

761

762

static int alc_init(struct hda_codec *codec)

762

static int alc_init(struct hda_codec *codec)

763

{

763

{

764

struct alc_spec *spec = codec->spec;

764

struct alc_spec *spec = codec->spec;

765

766

if (spec->init_hook)

766

if (spec->init_hook)

767

spec->init_hook(codec);

767

spec->init_hook(codec);

768

769

alc_fix_pll(codec);

769

alc_fix_pll(codec);

770

alc_auto_init_amp(codec, spec->init_amp);

770

alc_auto_init_amp(codec, spec->init_amp);

771

772

snd_hda_gen_init(codec);

772

snd_hda_gen_init(codec);

773

774

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);

774

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);

775

776

return 0;

776

return 0;

777

}

777

}

778

779

static inline void alc_shutup(struct hda_codec *codec)

779

static inline void alc_shutup(struct hda_codec *codec)

780

{

780

{

781

struct alc_spec *spec = codec->spec;

781

struct alc_spec *spec = codec->spec;

782

783

if (spec && spec->shutup)

783

if (spec && spec->shutup)

784

spec->shutup(codec);

784

spec->shutup(codec);

785

else

785

else

786

snd_hda_shutup_pins(codec);

786

snd_hda_shutup_pins(codec);

787

}

787

}

788

789

static void alc_reboot_notify(struct hda_codec *codec)

789

static void alc_reboot_notify(struct hda_codec *codec)

790

{

790

{

791

struct alc_spec *spec = codec->spec;

791

struct alc_spec *spec = codec->spec;

792

793

if (spec && spec->reboot_notify)

793

if (spec && spec->reboot_notify)

794

spec->reboot_notify(codec);

794

spec->reboot_notify(codec);

795

else

795

else

796

alc_shutup(codec);

796

alc_shutup(codec);

797

}

797

}

798

799

/* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */

799

/* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */

800

static void alc_d3_at_reboot(struct hda_codec *codec)

800

static void alc_d3_at_reboot(struct hda_codec *codec)

801

{

801

{

802

snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);

802

snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);

803

snd_hda_codec_write(codec, codec->core.afg, 0,

803

snd_hda_codec_write(codec, codec->core.afg, 0,

804

AC_VERB_SET_POWER_STATE, AC_PWRST_D3);

804

AC_VERB_SET_POWER_STATE, AC_PWRST_D3);

805

msleep(10);

805

msleep(10);

806

}

806

}

807

808

#define alc_free snd_hda_gen_free

808

#define alc_free snd_hda_gen_free

809

810

#ifdef CONFIG_PM

810

#ifdef CONFIG_PM

811

static void alc_power_eapd(struct hda_codec *codec)

811

static void alc_power_eapd(struct hda_codec *codec)

812

{

812

{

813

alc_auto_setup_eapd(codec, false);

813

alc_auto_setup_eapd(codec, false);

814

}

814

}

815

816

static int alc_suspend(struct hda_codec *codec)

816

static int alc_suspend(struct hda_codec *codec)

817

{

817

{

818

struct alc_spec *spec = codec->spec;

818

struct alc_spec *spec = codec->spec;

819

alc_shutup(codec);

819

alc_shutup(codec);

820

if (spec && spec->power_hook)

820

if (spec && spec->power_hook)

821

spec->power_hook(codec);

821

spec->power_hook(codec);

822

return 0;

822

return 0;

823

}

823

}

824

#endif

824

#endif

825

826

#ifdef CONFIG_PM

826

#ifdef CONFIG_PM

827

static int alc_resume(struct hda_codec *codec)

827

static int alc_resume(struct hda_codec *codec)

828

{

828

{

829

struct alc_spec *spec = codec->spec;

829

struct alc_spec *spec = codec->spec;

830

831

if (!spec->no_depop_delay)

831

if (!spec->no_depop_delay)

832

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

832

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

833

codec->patch_ops.init(codec);

833

codec->patch_ops.init(codec);

834

regcache_sync(codec->core.regmap);

834

regcache_sync(codec->core.regmap);

835

hda_call_check_power_status(codec, 0x01);

835

hda_call_check_power_status(codec, 0x01);

836

return 0;

836

return 0;

837

}

837

}

838

#endif

838

#endif

839

840

/*

840

/*

841

*/

841

*/

842

static const struct hda_codec_ops alc_patch_ops = {

842

static const struct hda_codec_ops alc_patch_ops = {

843

.build_controls = alc_build_controls,

843

.build_controls = alc_build_controls,

844

.build_pcms = snd_hda_gen_build_pcms,

844

.build_pcms = snd_hda_gen_build_pcms,

845

.init = alc_init,

845

.init = alc_init,

846

.free = alc_free,

846

.free = alc_free,

847

.unsol_event = snd_hda_jack_unsol_event,

847

.unsol_event = snd_hda_jack_unsol_event,

848

#ifdef CONFIG_PM

848

#ifdef CONFIG_PM

849

.resume = alc_resume,

849

.resume = alc_resume,

850

.suspend = alc_suspend,

850

.suspend = alc_suspend,

851

.check_power_status = snd_hda_gen_check_power_status,

851

.check_power_status = snd_hda_gen_check_power_status,

852

#endif

852

#endif

853

.reboot_notify = alc_reboot_notify,

853

.reboot_notify = alc_reboot_notify,

854

};

854

};

855

856

857

#define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)

857

#define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)

858

859

/*

859

/*

860

* Rename codecs appropriately from COEF value or subvendor id

860

* Rename codecs appropriately from COEF value or subvendor id

861

*/

861

*/

862

struct alc_codec_rename_table {

862

struct alc_codec_rename_table {

863

unsigned int vendor_id;

863

unsigned int vendor_id;

864

unsigned short coef_mask;

864

unsigned short coef_mask;

865

unsigned short coef_bits;

865

unsigned short coef_bits;

866

const char *name;

866

const char *name;

867

};

867

};

868

869

struct alc_codec_rename_pci_table {

869

struct alc_codec_rename_pci_table {

870

unsigned int codec_vendor_id;

870

unsigned int codec_vendor_id;

871

unsigned short pci_subvendor;

871

unsigned short pci_subvendor;

872

unsigned short pci_subdevice;

872

unsigned short pci_subdevice;

873

const char *name;

873

const char *name;

874

};

874

};

875

876

static struct alc_codec_rename_table rename_tbl[] = {

876

static struct alc_codec_rename_table rename_tbl[] = {

877

{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },

877

{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },

878

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

878

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

879

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

879

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

880

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

880

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

881

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

881

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

882

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

882

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

883

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

883

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

884

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

884

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

885

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

885

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

886

{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },

886

{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },

887

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

887

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

888

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

888

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

889

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

889

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

890

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

890

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

891

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

891

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

892

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

892

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

893

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

893

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

894

{ } /* terminator */

894

{ } /* terminator */

895

};

895

};

896

897

static struct alc_codec_rename_pci_table rename_pci_tbl[] = {

897

static struct alc_codec_rename_pci_table rename_pci_tbl[] = {

898

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

898

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

899

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

899

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

900

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

900

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

901

{ 0x10ec0288, 0x1028, 0, "ALC3263" },

901

{ 0x10ec0288, 0x1028, 0, "ALC3263" },

902

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

902

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

903

{ 0x10ec0293, 0x1028, 0, "ALC3235" },

903

{ 0x10ec0293, 0x1028, 0, "ALC3235" },

904

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

904

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

905

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

905

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

906

{ 0x10ec0275, 0x1028, 0, "ALC3260" },

906

{ 0x10ec0275, 0x1028, 0, "ALC3260" },

907

{ 0x10ec0899, 0x1028, 0, "ALC3861" },

907

{ 0x10ec0899, 0x1028, 0, "ALC3861" },

908

{ 0x10ec0298, 0x1028, 0, "ALC3266" },

908

{ 0x10ec0298, 0x1028, 0, "ALC3266" },

909

{ 0x10ec0256, 0x1028, 0, "ALC3246" },

909

{ 0x10ec0256, 0x1028, 0, "ALC3246" },

910

{ 0x10ec0225, 0x1028, 0, "ALC3253" },

910

{ 0x10ec0225, 0x1028, 0, "ALC3253" },

911

{ 0x10ec0295, 0x1028, 0, "ALC3254" },

911

{ 0x10ec0295, 0x1028, 0, "ALC3254" },

912

{ 0x10ec0670, 0x1025, 0, "ALC669X" },

912

{ 0x10ec0670, 0x1025, 0, "ALC669X" },

913

{ 0x10ec0676, 0x1025, 0, "ALC679X" },

913

{ 0x10ec0676, 0x1025, 0, "ALC679X" },

914

{ 0x10ec0282, 0x1043, 0, "ALC3229" },

914

{ 0x10ec0282, 0x1043, 0, "ALC3229" },

915

{ 0x10ec0233, 0x1043, 0, "ALC3236" },

915

{ 0x10ec0233, 0x1043, 0, "ALC3236" },

916

{ 0x10ec0280, 0x103c, 0, "ALC3228" },

916

{ 0x10ec0280, 0x103c, 0, "ALC3228" },

917

{ 0x10ec0282, 0x103c, 0, "ALC3227" },

917

{ 0x10ec0282, 0x103c, 0, "ALC3227" },

918

{ 0x10ec0286, 0x103c, 0, "ALC3242" },

918

{ 0x10ec0286, 0x103c, 0, "ALC3242" },

919

{ 0x10ec0290, 0x103c, 0, "ALC3241" },

919

{ 0x10ec0290, 0x103c, 0, "ALC3241" },

920

{ 0x10ec0668, 0x103c, 0, "ALC3662" },

920

{ 0x10ec0668, 0x103c, 0, "ALC3662" },

921

{ 0x10ec0283, 0x17aa, 0, "ALC3239" },

921

{ 0x10ec0283, 0x17aa, 0, "ALC3239" },

922

{ 0x10ec0292, 0x17aa, 0, "ALC3232" },

922

{ 0x10ec0292, 0x17aa, 0, "ALC3232" },

923

{ } /* terminator */

923

{ } /* terminator */

924

};

924

};

925

926

static int alc_codec_rename_from_preset(struct hda_codec *codec)

926

static int alc_codec_rename_from_preset(struct hda_codec *codec)

927

{

927

{

928

const struct alc_codec_rename_table *p;

928

const struct alc_codec_rename_table *p;

929

const struct alc_codec_rename_pci_table *q;

929

const struct alc_codec_rename_pci_table *q;

930

931

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

931

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

932

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

932

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

933

continue;

933

continue;

934

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

934

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

935

return alc_codec_rename(codec, p->name);

935

return alc_codec_rename(codec, p->name);

936

}

936

}

937

938

if (!codec->bus->pci)

938

if (!codec->bus->pci)

939

return 0;

939

return 0;

940

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

940

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

941

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

941

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

942

continue;

942

continue;

943

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

943

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

944

continue;

944

continue;

945

if (!q->pci_subdevice ||

945

if (!q->pci_subdevice ||

946

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

946

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

947

return alc_codec_rename(codec, q->name);

947

return alc_codec_rename(codec, q->name);

948

}

948

}

949

950

return 0;

950

return 0;

951

}

951

}

952

953

954

/*

954

/*

955

* Digital-beep handlers

955

* Digital-beep handlers

956

*/

956

*/

957

#ifdef CONFIG_SND_HDA_INPUT_BEEP

957

#ifdef CONFIG_SND_HDA_INPUT_BEEP

958

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

958

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

959

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

959

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

960

961

static const struct snd_pci_quirk beep_white_list[] = {

961

static const struct snd_pci_quirk beep_white_list[] = {

962

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

962

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

963

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

963

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

964

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

964

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

965

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

965

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

966

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

966

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

967

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

967

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

968

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

968

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

969

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

969

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

970

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

970

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

971

{}

971

{}

972

};

972

};

973

974

static inline int has_cdefine_beep(struct hda_codec *codec)

974

static inline int has_cdefine_beep(struct hda_codec *codec)

975

{

975

{

976

struct alc_spec *spec = codec->spec;

976

struct alc_spec *spec = codec->spec;

977

const struct snd_pci_quirk *q;

977

const struct snd_pci_quirk *q;

978

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

978

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

979

if (q)

979

if (q)

980

return q->value;

980

return q->value;

981

return spec->cdefine.enable_pcbeep;

981

return spec->cdefine.enable_pcbeep;

982

}

982

}

983

#else

983

#else

984

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

984

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

985

#define has_cdefine_beep(codec) 0

985

#define has_cdefine_beep(codec) 0

986

#endif

986

#endif

987

988

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

988

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

989

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

989

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

990

* or a negative error code

990

* or a negative error code

991

*/

991

*/

992

static int alc_parse_auto_config(struct hda_codec *codec,

992

static int alc_parse_auto_config(struct hda_codec *codec,

993

const hda_nid_t *ignore_nids,

993

const hda_nid_t *ignore_nids,

994

const hda_nid_t *ssid_nids)

994

const hda_nid_t *ssid_nids)

995

{

995

{

996

struct alc_spec *spec = codec->spec;

996

struct alc_spec *spec = codec->spec;

997

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

997

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

998

int err;

998

int err;

999

1000

err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,

1000

err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,

1001

spec->parse_flags);

1001

spec->parse_flags);

1002

if (err < 0)

1002

if (err < 0)

1003

return err;

1003

return err;

1004

1005

if (ssid_nids)

1005

if (ssid_nids)

1006

alc_ssid_check(codec, ssid_nids);

1006

alc_ssid_check(codec, ssid_nids);

1007

1008

err = snd_hda_gen_parse_auto_config(codec, cfg);

1008

err = snd_hda_gen_parse_auto_config(codec, cfg);

1009

if (err < 0)

1009

if (err < 0)

1010

return err;

1010

return err;

1011

1012

return 1;

1012

return 1;

1013

}

1013

}

1014

1015

/* common preparation job for alc_spec */

1015

/* common preparation job for alc_spec */

1016

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

1016

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

1017

{

1017

{

1018

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

1018

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

1019

int err;

1019

int err;

1020

1021

if (!spec)

1021

if (!spec)

1022

return -ENOMEM;

1022

return -ENOMEM;

1023

codec->spec = spec;

1023

codec->spec = spec;

1024

snd_hda_gen_spec_init(&spec->gen);

1024

snd_hda_gen_spec_init(&spec->gen);

1025

spec->gen.mixer_nid = mixer_nid;

1025

spec->gen.mixer_nid = mixer_nid;

1026

spec->gen.own_eapd_ctl = 1;

1026

spec->gen.own_eapd_ctl = 1;

1027

codec->single_adc_amp = 1;

1027

codec->single_adc_amp = 1;

1028

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

1028

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

1029

codec->spdif_status_reset = 1;

1029

codec->spdif_status_reset = 1;

1030

codec->patch_ops = alc_patch_ops;

1030

codec->patch_ops = alc_patch_ops;

1031

1032

err = alc_codec_rename_from_preset(codec);

1032

err = alc_codec_rename_from_preset(codec);

1033

if (err < 0) {

1033

if (err < 0) {

1034

kfree(spec);

1034

kfree(spec);

1035

return err;

1035

return err;

1036

}

1036

}

1037

return 0;

1037

return 0;

1038

}

1038

}

1039

1040

static int alc880_parse_auto_config(struct hda_codec *codec)

1040

static int alc880_parse_auto_config(struct hda_codec *codec)

1041

{

1041

{

1042

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

1042

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

1043

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

1043

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

1044

return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);

1044

return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);

1045

}

1045

}

1046

1047

/*

1047

/*

1048

* ALC880 fix-ups

1048

* ALC880 fix-ups

1049

*/

1049

*/

1050

enum {

1050

enum {

1051

ALC880_FIXUP_GPIO1,

1051

ALC880_FIXUP_GPIO1,

1052

ALC880_FIXUP_GPIO2,

1052

ALC880_FIXUP_GPIO2,

1053

ALC880_FIXUP_MEDION_RIM,

1053

ALC880_FIXUP_MEDION_RIM,

1054

ALC880_FIXUP_LG,

1054

ALC880_FIXUP_LG,

1055

ALC880_FIXUP_LG_LW25,

1055

ALC880_FIXUP_LG_LW25,

1056

ALC880_FIXUP_W810,

1056

ALC880_FIXUP_W810,

1057

ALC880_FIXUP_EAPD_COEF,

1057

ALC880_FIXUP_EAPD_COEF,

1058

ALC880_FIXUP_TCL_S700,

1058

ALC880_FIXUP_TCL_S700,

1059

ALC880_FIXUP_VOL_KNOB,

1059

ALC880_FIXUP_VOL_KNOB,

1060

ALC880_FIXUP_FUJITSU,

1060

ALC880_FIXUP_FUJITSU,

1061

ALC880_FIXUP_F1734,

1061

ALC880_FIXUP_F1734,

1062

ALC880_FIXUP_UNIWILL,

1062

ALC880_FIXUP_UNIWILL,

1063

ALC880_FIXUP_UNIWILL_DIG,

1063

ALC880_FIXUP_UNIWILL_DIG,

1064

ALC880_FIXUP_Z71V,

1064

ALC880_FIXUP_Z71V,

1065

ALC880_FIXUP_ASUS_W5A,

1065

ALC880_FIXUP_ASUS_W5A,

1066

ALC880_FIXUP_3ST_BASE,

1066

ALC880_FIXUP_3ST_BASE,

1067

ALC880_FIXUP_3ST,

1067

ALC880_FIXUP_3ST,

1068

ALC880_FIXUP_3ST_DIG,

1068

ALC880_FIXUP_3ST_DIG,

1069

ALC880_FIXUP_5ST_BASE,

1069

ALC880_FIXUP_5ST_BASE,

1070

ALC880_FIXUP_5ST,

1070

ALC880_FIXUP_5ST,

1071

ALC880_FIXUP_5ST_DIG,

1071

ALC880_FIXUP_5ST_DIG,

1072

ALC880_FIXUP_6ST_BASE,

1072

ALC880_FIXUP_6ST_BASE,

1073

ALC880_FIXUP_6ST,

1073

ALC880_FIXUP_6ST,

1074

ALC880_FIXUP_6ST_DIG,

1074

ALC880_FIXUP_6ST_DIG,

1075

ALC880_FIXUP_6ST_AUTOMUTE,

1075

ALC880_FIXUP_6ST_AUTOMUTE,

1076

};

1076

};

1077

1078

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

1078

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

1079

static void alc880_fixup_vol_knob(struct hda_codec *codec,

1079

static void alc880_fixup_vol_knob(struct hda_codec *codec,

1080

const struct hda_fixup *fix, int action)

1080

const struct hda_fixup *fix, int action)

1081

{

1081

{

1082

if (action == HDA_FIXUP_ACT_PROBE)

1082

if (action == HDA_FIXUP_ACT_PROBE)

1083

snd_hda_jack_detect_enable_callback(codec, 0x21,

1083

snd_hda_jack_detect_enable_callback(codec, 0x21,

1084

alc_update_knob_master);

1084

alc_update_knob_master);

1085

}

1085

}

1086

1087

static const struct hda_fixup alc880_fixups[] = {

1087

static const struct hda_fixup alc880_fixups[] = {

1088

[ALC880_FIXUP_GPIO1] = {

1088

[ALC880_FIXUP_GPIO1] = {

1089

.type = HDA_FIXUP_VERBS,

1089

.type = HDA_FIXUP_VERBS,

1090

.v.verbs = alc_gpio1_init_verbs,

1090

.v.verbs = alc_gpio1_init_verbs,

1091

},

1091

},

1092

[ALC880_FIXUP_GPIO2] = {

1092

[ALC880_FIXUP_GPIO2] = {

1093

.type = HDA_FIXUP_VERBS,

1093

.type = HDA_FIXUP_VERBS,

1094

.v.verbs = alc_gpio2_init_verbs,

1094

.v.verbs = alc_gpio2_init_verbs,

1095

},

1095

},

1096

[ALC880_FIXUP_MEDION_RIM] = {

1096

[ALC880_FIXUP_MEDION_RIM] = {

1097

.type = HDA_FIXUP_VERBS,

1097

.type = HDA_FIXUP_VERBS,

1098

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

1098

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

1099

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1099

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1100

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1100

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1101

{ }

1101

{ }

1102

},

1102

},

1103

.chained = true,

1103

.chained = true,

1104

.chain_id = ALC880_FIXUP_GPIO2,

1104

.chain_id = ALC880_FIXUP_GPIO2,

1105

},

1105

},

1106

[ALC880_FIXUP_LG] = {

1106

[ALC880_FIXUP_LG] = {

1107

.type = HDA_FIXUP_PINS,

1107

.type = HDA_FIXUP_PINS,

1108

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

1108

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

1109

/* disable bogus unused pins */

1109

/* disable bogus unused pins */

1110

{ 0x16, 0x411111f0 },

1110

{ 0x16, 0x411111f0 },

1111

{ 0x18, 0x411111f0 },

1111

{ 0x18, 0x411111f0 },

1112

{ 0x1a, 0x411111f0 },

1112

{ 0x1a, 0x411111f0 },

1113

{ }

1113

{ }

1114

}

1114

}

1115

},

1115

},

1116

[ALC880_FIXUP_LG_LW25] = {

1116

[ALC880_FIXUP_LG_LW25] = {

1117

.type = HDA_FIXUP_PINS,

1117

.type = HDA_FIXUP_PINS,

1118

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

1118

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

1119

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

1119

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

1120

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

1120

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

1121

{ }

1121

{ }

1122

}

1122

}

1123

},

1123

},

1124

[ALC880_FIXUP_W810] = {

1124

[ALC880_FIXUP_W810] = {

1125

.type = HDA_FIXUP_PINS,

1125

.type = HDA_FIXUP_PINS,

1126

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

1126

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

1127

/* disable bogus unused pins */

1127

/* disable bogus unused pins */

1128

{ 0x17, 0x411111f0 },

1128

{ 0x17, 0x411111f0 },

1129

{ }

1129

{ }

1130

},

1130

},

1131

.chained = true,

1131

.chained = true,

1132

.chain_id = ALC880_FIXUP_GPIO2,

1132

.chain_id = ALC880_FIXUP_GPIO2,

1133

},

1133

},

1134

[ALC880_FIXUP_EAPD_COEF] = {

1134

[ALC880_FIXUP_EAPD_COEF] = {

1135

.type = HDA_FIXUP_VERBS,

1135

.type = HDA_FIXUP_VERBS,

1136

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

1136

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

1137

/* change to EAPD mode */

1137

/* change to EAPD mode */

1138

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1138

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1139

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1139

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

1140

{}

1140

{}

1141

},

1141

},

1142

},

1142

},

1143

[ALC880_FIXUP_TCL_S700] = {

1143

[ALC880_FIXUP_TCL_S700] = {

1144

.type = HDA_FIXUP_VERBS,

1144

.type = HDA_FIXUP_VERBS,

1145

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

1145

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

1146

/* change to EAPD mode */

1146

/* change to EAPD mode */

1147

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1147

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

1148

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

1148

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

1149

{}

1149

{}

1150

},

1150

},

1151

.chained = true,

1151

.chained = true,

1152

.chain_id = ALC880_FIXUP_GPIO2,

1152

.chain_id = ALC880_FIXUP_GPIO2,

1153

},

1153

},

1154

[ALC880_FIXUP_VOL_KNOB] = {

1154

[ALC880_FIXUP_VOL_KNOB] = {

1155

.type = HDA_FIXUP_FUNC,

1155

.type = HDA_FIXUP_FUNC,

1156

.v.func = alc880_fixup_vol_knob,

1156

.v.func = alc880_fixup_vol_knob,

1157

},

1157

},

1158

[ALC880_FIXUP_FUJITSU] = {

1158

[ALC880_FIXUP_FUJITSU] = {

1159

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

1159

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

1160

.type = HDA_FIXUP_PINS,

1160

.type = HDA_FIXUP_PINS,

1161

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

1161

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

1162

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

1162

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

1163

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

1163

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

1164

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

1164

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

1165

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

1165

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

1166

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

1166

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

1167

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

1167

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

1168

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

1168

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

1169

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

1169

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

1170

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

1170

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

1171

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

1171

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

1172

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

1172

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

1173

{ }

1173

{ }

1174

},

1174

},

1175

.chained = true,

1175

.chained = true,

1176

.chain_id = ALC880_FIXUP_VOL_KNOB,

1176

.chain_id = ALC880_FIXUP_VOL_KNOB,

1177

},

1177

},

1178

[ALC880_FIXUP_F1734] = {

1178

[ALC880_FIXUP_F1734] = {

1179

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

1179

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

1180

.type = HDA_FIXUP_PINS,

1180

.type = HDA_FIXUP_PINS,

1181

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

1181

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

1182

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

1182

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

1183

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

1183

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

1184

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

1184

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

1185

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

1185

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

1186

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

1186

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

1187

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

1187

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

1188

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

1188

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

1189

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

1189

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

1190

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

1190

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

1191

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

1191

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

1192

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

1192

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

1193

{ }

1193

{ }

1194

},

1194

},

1195

.chained = true,

1195

.chained = true,

1196

.chain_id = ALC880_FIXUP_VOL_KNOB,

1196

.chain_id = ALC880_FIXUP_VOL_KNOB,

1197

},

1197

},

1198

[ALC880_FIXUP_UNIWILL] = {

1198

[ALC880_FIXUP_UNIWILL] = {

1199

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

1199

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

1200

.type = HDA_FIXUP_PINS,

1200

.type = HDA_FIXUP_PINS,

1201

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

1201

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

1202

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

1202

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

1203

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

1203

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

1204

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

1204

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

1205

{ }

1205

{ }

1206

},

1206

},

1207

},

1207

},

1208

[ALC880_FIXUP_UNIWILL_DIG] = {

1208

[ALC880_FIXUP_UNIWILL_DIG] = {

1209

.type = HDA_FIXUP_PINS,

1209

.type = HDA_FIXUP_PINS,

1210

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

1210

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

1211

/* disable bogus unused pins */

1211

/* disable bogus unused pins */

1212

{ 0x17, 0x411111f0 },

1212

{ 0x17, 0x411111f0 },

1213

{ 0x19, 0x411111f0 },

1213

{ 0x19, 0x411111f0 },

1214

{ 0x1b, 0x411111f0 },

1214

{ 0x1b, 0x411111f0 },

1215

{ 0x1f, 0x411111f0 },

1215

{ 0x1f, 0x411111f0 },

1216

{ }

1216

{ }

1217

}

1217

}

1218

},

1218

},

1219

[ALC880_FIXUP_Z71V] = {

1219

[ALC880_FIXUP_Z71V] = {

1220

.type = HDA_FIXUP_PINS,

1220

.type = HDA_FIXUP_PINS,

1221

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

1221

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

1222

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

1222

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

1223

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

1223

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

1224

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

1224

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

1225

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

1225

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

1226

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

1226

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

1227

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

1227

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

1228

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

1228

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

1229

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

1229

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

1230

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

1230

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

1231

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

1231

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

1232

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

1232

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

1233

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

1233

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

1234

{ }

1234

{ }

1235

}

1235

}

1236

},

1236

},

1237

[ALC880_FIXUP_ASUS_W5A] = {

1237

[ALC880_FIXUP_ASUS_W5A] = {

1238

.type = HDA_FIXUP_PINS,

1238

.type = HDA_FIXUP_PINS,

1239

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

1239

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

1240

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

1240

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

1241

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

1241

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

1242

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

1242

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

1243

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

1243

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

1244

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

1244

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

1245

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

1245

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

1246

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

1246

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

1247

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

1247

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

1248

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

1248

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

1249

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

1249

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

1250

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

1250

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

1251

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

1251

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

1252

{ }

1252

{ }

1253

},

1253

},

1254

.chained = true,

1254

.chained = true,

1255

.chain_id = ALC880_FIXUP_GPIO1,

1255

.chain_id = ALC880_FIXUP_GPIO1,

1256

},

1256

},

1257

[ALC880_FIXUP_3ST_BASE] = {

1257

[ALC880_FIXUP_3ST_BASE] = {

1258

.type = HDA_FIXUP_PINS,

1258

.type = HDA_FIXUP_PINS,

1259

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

1259

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

1260

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

1260

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

1261

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

1261

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

1262

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

1262

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

1263

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

1263

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

1264

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

1264

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

1265

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

1265

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

1266

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

1266

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

1267

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

1267

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

1268

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

1268

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

1269

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

1269

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

1270

/* 0x1e is filled in below */

1270

/* 0x1e is filled in below */

1271

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

1271

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

1272

{ }

1272

{ }

1273

}

1273

}

1274

},

1274

},

1275

[ALC880_FIXUP_3ST] = {

1275

[ALC880_FIXUP_3ST] = {

1276

.type = HDA_FIXUP_PINS,

1276

.type = HDA_FIXUP_PINS,

1277

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

1277

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

1278

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

1278

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

1279

{ }

1279

{ }

1280

},

1280

},

1281

.chained = true,

1281

.chained = true,

1282

.chain_id = ALC880_FIXUP_3ST_BASE,

1282

.chain_id = ALC880_FIXUP_3ST_BASE,

1283

},

1283

},

1284

[ALC880_FIXUP_3ST_DIG] = {

1284

[ALC880_FIXUP_3ST_DIG] = {

1285

.type = HDA_FIXUP_PINS,

1285

.type = HDA_FIXUP_PINS,

1286

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

1286

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

1287

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

1287

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

1288

{ }

1288

{ }

1289

},

1289

},

1290

.chained = true,

1290

.chained = true,

1291

.chain_id = ALC880_FIXUP_3ST_BASE,

1291

.chain_id = ALC880_FIXUP_3ST_BASE,

1292

},

1292

},

1293

[ALC880_FIXUP_5ST_BASE] = {

1293

[ALC880_FIXUP_5ST_BASE] = {

1294

.type = HDA_FIXUP_PINS,

1294

.type = HDA_FIXUP_PINS,

1295

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

1295

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

1296

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

1296

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

1297

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

1297

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

1298

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

1298

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

1299

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

1299

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

1300

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

1300

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

1301

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

1301

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

1302

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

1302

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

1303

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

1303

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

1304

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

1304

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

1305

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

1305

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

1306

/* 0x1e is filled in below */

1306

/* 0x1e is filled in below */

1307

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

1307

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

1308

{ }

1308

{ }

1309

}

1309

}

1310

},

1310

},

1311

[ALC880_FIXUP_5ST] = {

1311

[ALC880_FIXUP_5ST] = {

1312

.type = HDA_FIXUP_PINS,

1312

.type = HDA_FIXUP_PINS,

1313

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

1313

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

1314

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

1314

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

1315

{ }

1315

{ }

1316

},

1316

},

1317

.chained = true,

1317

.chained = true,

1318

.chain_id = ALC880_FIXUP_5ST_BASE,

1318

.chain_id = ALC880_FIXUP_5ST_BASE,

1319

},

1319

},

1320

[ALC880_FIXUP_5ST_DIG] = {

1320

[ALC880_FIXUP_5ST_DIG] = {

1321

.type = HDA_FIXUP_PINS,

1321

.type = HDA_FIXUP_PINS,

1322

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

1322

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

1323

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

1323

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

1324

{ }

1324

{ }

1325

},

1325

},

1326

.chained = true,

1326

.chained = true,

1327

.chain_id = ALC880_FIXUP_5ST_BASE,

1327

.chain_id = ALC880_FIXUP_5ST_BASE,

1328

},

1328

},

1329

[ALC880_FIXUP_6ST_BASE] = {

1329

[ALC880_FIXUP_6ST_BASE] = {

1330

.type = HDA_FIXUP_PINS,

1330

.type = HDA_FIXUP_PINS,

1331

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

1331

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

1332

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

1332

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

1333

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

1333

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

1334

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

1334

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

1335

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

1335

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

1336

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

1336

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

1337

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

1337

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

1338

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

1338

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

1339

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

1339

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

1340

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

1340

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

1341

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

1341

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

1342

/* 0x1e is filled in below */

1342

/* 0x1e is filled in below */

1343

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

1343

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

1344

{ }

1344

{ }

1345

}

1345

}

1346

},

1346

},

1347

[ALC880_FIXUP_6ST] = {

1347

[ALC880_FIXUP_6ST] = {

1348

.type = HDA_FIXUP_PINS,

1348

.type = HDA_FIXUP_PINS,

1349

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

1349

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

1350

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

1350

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

1351

{ }

1351

{ }

1352

},

1352

},

1353

.chained = true,

1353

.chained = true,

1354

.chain_id = ALC880_FIXUP_6ST_BASE,

1354

.chain_id = ALC880_FIXUP_6ST_BASE,

1355

},

1355

},

1356

[ALC880_FIXUP_6ST_DIG] = {

1356

[ALC880_FIXUP_6ST_DIG] = {

1357

.type = HDA_FIXUP_PINS,

1357

.type = HDA_FIXUP_PINS,

1358

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

1358

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

1359

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

1359

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

1360

{ }

1360

{ }

1361

},

1361

},

1362

.chained = true,

1362

.chained = true,

1363

.chain_id = ALC880_FIXUP_6ST_BASE,

1363

.chain_id = ALC880_FIXUP_6ST_BASE,

1364

},

1364

},

1365

[ALC880_FIXUP_6ST_AUTOMUTE] = {

1365

[ALC880_FIXUP_6ST_AUTOMUTE] = {

1366

.type = HDA_FIXUP_PINS,

1366

.type = HDA_FIXUP_PINS,

1367

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

1367

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

1368

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

1368

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

1369

{ }

1369

{ }

1370

},

1370

},

1371

.chained_before = true,

1371

.chained_before = true,

1372

.chain_id = ALC880_FIXUP_6ST_BASE,

1372

.chain_id = ALC880_FIXUP_6ST_BASE,

1373

},

1373

},

1374

};

1374

};

1375

1376

static const struct snd_pci_quirk alc880_fixup_tbl[] = {

1376

static const struct snd_pci_quirk alc880_fixup_tbl[] = {

1377

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

1377

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

1378

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

1378

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

1379

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

1379

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

1380

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

1380

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

1381

SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),

1381

SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),

1382

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

1382

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

1383

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

1383

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

1384

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

1384

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

1385

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

1385

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

1386

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

1386

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

1387

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

1387

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

1388

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

1388

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

1389

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

1389

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

1390

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

1390

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

1391

SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),

1391

SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),

1392

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

1392

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

1393

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

1393

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

1394

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

1394

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

1395

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

1395

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

1396

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

1396

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

1397

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

1397

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

1398

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

1398

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

1399

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

1399

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

1400

1401

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

1401

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

1402

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

1402

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

1403

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

1403

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

1404

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

1404

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

1405

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

1405

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

1406

*/

1406

*/

1407

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

1407

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

1408

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

1408

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

1409

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

1409

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

1410

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

1410

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

1411

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

1411

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

1412

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

1412

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

1413

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

1413

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

1414

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

1414

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

1415

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

1415

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

1416

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

1416

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

1417

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

1417

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

1418

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

1418

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

1419

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

1419

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

1420

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

1420

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

1421

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

1421

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

1422

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

1422

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

1423

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

1423

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

1424

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

1424

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

1425

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

1425

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

1426

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

1426

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

1427

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

1427

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

1428

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

1428

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

1429

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

1429

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

1430

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

1430

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

1431

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

1431

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

1432

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

1432

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

1433

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

1433

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

1434

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

1434

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

1435

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

1435

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

1436

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

1436

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

1437

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

1437

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

1438

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

1438

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

1439

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

1439

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

1440

/* default Intel */

1440

/* default Intel */

1441

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

1441

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

1442

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

1442

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

1443

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

1443

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

1444

{}

1444

{}

1445

};

1445

};

1446

1447

static const struct hda_model_fixup alc880_fixup_models[] = {

1447

static const struct hda_model_fixup alc880_fixup_models[] = {

1448

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

1448

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

1449

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

1449

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

1450

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

1450

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

1451

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

1451

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

1452

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

1452

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

1453

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

1453

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

1454

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

1454

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

1455

{}

1455

{}

1456

};

1456

};

1457

1458

1459

/*

1459

/*

1460

* OK, here we have finally the patch for ALC880

1460

* OK, here we have finally the patch for ALC880

1461

*/

1461

*/

1462

static int patch_alc880(struct hda_codec *codec)

1462

static int patch_alc880(struct hda_codec *codec)

1463

{

1463

{

1464

struct alc_spec *spec;

1464

struct alc_spec *spec;

1465

int err;

1465

int err;

1466

1467

err = alc_alloc_spec(codec, 0x0b);

1467

err = alc_alloc_spec(codec, 0x0b);

1468

if (err < 0)

1468

if (err < 0)

1469

return err;

1469

return err;

1470

1471

spec = codec->spec;

1471

spec = codec->spec;

1472

spec->gen.need_dac_fix = 1;

1472

spec->gen.need_dac_fix = 1;

1473

spec->gen.beep_nid = 0x01;

1473

spec->gen.beep_nid = 0x01;

1474

1475

codec->patch_ops.unsol_event = alc880_unsol_event;

1475

codec->patch_ops.unsol_event = alc880_unsol_event;

1476

1477

snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,

1477

snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,

1478

alc880_fixups);

1478

alc880_fixups);

1479

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1479

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1480

1481

/* automatic parse from the BIOS config */

1481

/* automatic parse from the BIOS config */

1482

err = alc880_parse_auto_config(codec);

1482

err = alc880_parse_auto_config(codec);

1483

if (err < 0)

1483

if (err < 0)

1484

goto error;

1484

goto error;

1485

1486

if (!spec->gen.no_analog)

1486

if (!spec->gen.no_analog)

1487

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

1487

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

1488

1489

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1489

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1490

1491

return 0;

1491

return 0;

1492

1493

error:

1493

error:

1494

alc_free(codec);

1494

alc_free(codec);

1495

return err;

1495

return err;

1496

}

1496

}

1497

1498

1499

/*

1499

/*

1500

* ALC260 support

1500

* ALC260 support

1501

*/

1501

*/

1502

static int alc260_parse_auto_config(struct hda_codec *codec)

1502

static int alc260_parse_auto_config(struct hda_codec *codec)

1503

{

1503

{

1504

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

1504

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

1505

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

1505

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

1506

return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);

1506

return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);

1507

}

1507

}

1508

1509

/*

1509

/*

1510

* Pin config fixes

1510

* Pin config fixes

1511

*/

1511

*/

1512

enum {

1512

enum {

1513

ALC260_FIXUP_HP_DC5750,

1513

ALC260_FIXUP_HP_DC5750,

1514

ALC260_FIXUP_HP_PIN_0F,

1514

ALC260_FIXUP_HP_PIN_0F,

1515

ALC260_FIXUP_COEF,

1515

ALC260_FIXUP_COEF,

1516

ALC260_FIXUP_GPIO1,

1516

ALC260_FIXUP_GPIO1,

1517

ALC260_FIXUP_GPIO1_TOGGLE,

1517

ALC260_FIXUP_GPIO1_TOGGLE,

1518

ALC260_FIXUP_REPLACER,

1518

ALC260_FIXUP_REPLACER,

1519

ALC260_FIXUP_HP_B1900,

1519

ALC260_FIXUP_HP_B1900,

1520

ALC260_FIXUP_KN1,

1520

ALC260_FIXUP_KN1,

1521

ALC260_FIXUP_FSC_S7020,

1521

ALC260_FIXUP_FSC_S7020,

1522

ALC260_FIXUP_FSC_S7020_JWSE,

1522

ALC260_FIXUP_FSC_S7020_JWSE,

1523

ALC260_FIXUP_VAIO_PINS,

1523

ALC260_FIXUP_VAIO_PINS,

1524

};

1524

};

1525

1526

static void alc260_gpio1_automute(struct hda_codec *codec)

1526

static void alc260_gpio1_automute(struct hda_codec *codec)

1527

{

1527

{

1528

struct alc_spec *spec = codec->spec;

1528

struct alc_spec *spec = codec->spec;

1529

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

1529

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

1530

spec->gen.hp_jack_present);

1530

spec->gen.hp_jack_present);

1531

}

1531

}

1532

1533

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,

1533

static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,

1534

const struct hda_fixup *fix, int action)

1534

const struct hda_fixup *fix, int action)

1535

{

1535

{

1536

struct alc_spec *spec = codec->spec;

1536

struct alc_spec *spec = codec->spec;

1537

if (action == HDA_FIXUP_ACT_PROBE) {

1537

if (action == HDA_FIXUP_ACT_PROBE) {

1538

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

1538

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

1539

* toggle GPIO1 according to the jack state

1539

* toggle GPIO1 according to the jack state

1540

*/

1540

*/

1541

spec->gen.automute_hook = alc260_gpio1_automute;

1541

spec->gen.automute_hook = alc260_gpio1_automute;

1542

spec->gen.detect_hp = 1;

1542

spec->gen.detect_hp = 1;

1543

spec->gen.automute_speaker = 1;

1543

spec->gen.automute_speaker = 1;

1544

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

1544

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

1545

snd_hda_jack_detect_enable_callback(codec, 0x0f,

1545

snd_hda_jack_detect_enable_callback(codec, 0x0f,

1546

snd_hda_gen_hp_automute);

1546

snd_hda_gen_hp_automute);

1547

snd_hda_add_verbs(codec, alc_gpio1_init_verbs);

1547

snd_hda_add_verbs(codec, alc_gpio1_init_verbs);

1548

}

1548

}

1549

}

1549

}

1550

1551

static void alc260_fixup_kn1(struct hda_codec *codec,

1551

static void alc260_fixup_kn1(struct hda_codec *codec,

1552

const struct hda_fixup *fix, int action)

1552

const struct hda_fixup *fix, int action)

1553

{

1553

{

1554

struct alc_spec *spec = codec->spec;

1554

struct alc_spec *spec = codec->spec;

1555

static const struct hda_pintbl pincfgs[] = {

1555

static const struct hda_pintbl pincfgs[] = {

1556

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

1556

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

1557

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

1557

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

1558

{ 0x13, 0x02a19000 }, /* ext mic */

1558

{ 0x13, 0x02a19000 }, /* ext mic */

1559

{ 0x18, 0x01446000 }, /* SPDIF out */

1559

{ 0x18, 0x01446000 }, /* SPDIF out */

1560

/* disable bogus I/O pins */

1560

/* disable bogus I/O pins */

1561

{ 0x10, 0x411111f0 },

1561

{ 0x10, 0x411111f0 },

1562

{ 0x11, 0x411111f0 },

1562

{ 0x11, 0x411111f0 },

1563

{ 0x14, 0x411111f0 },

1563

{ 0x14, 0x411111f0 },

1564

{ 0x15, 0x411111f0 },

1564

{ 0x15, 0x411111f0 },

1565

{ 0x16, 0x411111f0 },

1565

{ 0x16, 0x411111f0 },

1566

{ 0x17, 0x411111f0 },

1566

{ 0x17, 0x411111f0 },

1567

{ 0x19, 0x411111f0 },

1567

{ 0x19, 0x411111f0 },

1568

{ }

1568

{ }

1569

};

1569

};

1570

1571

switch (action) {

1571

switch (action) {

1572

case HDA_FIXUP_ACT_PRE_PROBE:

1572

case HDA_FIXUP_ACT_PRE_PROBE:

1573

snd_hda_apply_pincfgs(codec, pincfgs);

1573

snd_hda_apply_pincfgs(codec, pincfgs);

1574

break;

1574

break;

1575

case HDA_FIXUP_ACT_PROBE:

1575

case HDA_FIXUP_ACT_PROBE:

1576

spec->init_amp = ALC_INIT_NONE;

1576

spec->init_amp = ALC_INIT_NONE;

1577

break;

1577

break;

1578

}

1578

}

1579

}

1579

}

1580

1581

static void alc260_fixup_fsc_s7020(struct hda_codec *codec,

1581

static void alc260_fixup_fsc_s7020(struct hda_codec *codec,

1582

const struct hda_fixup *fix, int action)

1582

const struct hda_fixup *fix, int action)

1583

{

1583

{

1584

struct alc_spec *spec = codec->spec;

1584

struct alc_spec *spec = codec->spec;

1585

if (action == HDA_FIXUP_ACT_PROBE)

1585

if (action == HDA_FIXUP_ACT_PROBE)

1586

spec->init_amp = ALC_INIT_NONE;

1586

spec->init_amp = ALC_INIT_NONE;

1587

}

1587

}

1588

1589

static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,

1589

static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,

1590

const struct hda_fixup *fix, int action)

1590

const struct hda_fixup *fix, int action)

1591

{

1591

{

1592

struct alc_spec *spec = codec->spec;

1592

struct alc_spec *spec = codec->spec;

1593

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1593

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1594

spec->gen.add_jack_modes = 1;

1594

spec->gen.add_jack_modes = 1;

1595

spec->gen.hp_mic = 1;

1595

spec->gen.hp_mic = 1;

1596

}

1596

}

1597

}

1597

}

1598

1599

static const struct hda_fixup alc260_fixups[] = {

1599

static const struct hda_fixup alc260_fixups[] = {

1600

[ALC260_FIXUP_HP_DC5750] = {

1600

[ALC260_FIXUP_HP_DC5750] = {

1601

.type = HDA_FIXUP_PINS,

1601

.type = HDA_FIXUP_PINS,

1602

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

1602

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

1603

{ 0x11, 0x90130110 }, /* speaker */

1603

{ 0x11, 0x90130110 }, /* speaker */

1604

{ }

1604

{ }

1605

}

1605

}

1606

},

1606

},

1607

[ALC260_FIXUP_HP_PIN_0F] = {

1607

[ALC260_FIXUP_HP_PIN_0F] = {

1608

.type = HDA_FIXUP_PINS,

1608

.type = HDA_FIXUP_PINS,

1609

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

1609

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

1610

{ 0x0f, 0x01214000 }, /* HP */

1610

{ 0x0f, 0x01214000 }, /* HP */

1611

{ }

1611

{ }

1612

}

1612

}

1613

},

1613

},

1614

[ALC260_FIXUP_COEF] = {

1614

[ALC260_FIXUP_COEF] = {

1615

.type = HDA_FIXUP_VERBS,

1615

.type = HDA_FIXUP_VERBS,

1616

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

1616

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

1617

{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },

1617

{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },

1618

{ 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },

1618

{ 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },

1619

{ }

1619

{ }

1620

},

1620

},

1621

},

1621

},

1622

[ALC260_FIXUP_GPIO1] = {

1622

[ALC260_FIXUP_GPIO1] = {

1623

.type = HDA_FIXUP_VERBS,

1623

.type = HDA_FIXUP_VERBS,

1624

.v.verbs = alc_gpio1_init_verbs,

1624

.v.verbs = alc_gpio1_init_verbs,

1625

},

1625

},

1626

[ALC260_FIXUP_GPIO1_TOGGLE] = {

1626

[ALC260_FIXUP_GPIO1_TOGGLE] = {

1627

.type = HDA_FIXUP_FUNC,

1627

.type = HDA_FIXUP_FUNC,

1628

.v.func = alc260_fixup_gpio1_toggle,

1628

.v.func = alc260_fixup_gpio1_toggle,

1629

.chained = true,

1629

.chained = true,

1630

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1630

.chain_id = ALC260_FIXUP_HP_PIN_0F,

1631

},

1631

},

1632

[ALC260_FIXUP_REPLACER] = {

1632

[ALC260_FIXUP_REPLACER] = {

1633

.type = HDA_FIXUP_VERBS,

1633

.type = HDA_FIXUP_VERBS,

1634

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

1634

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

1635

{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },

1635

{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },

1636

{ 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },

1636

{ 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },

1637

{ }

1637

{ }

1638

},

1638

},

1639

.chained = true,

1639

.chained = true,

1640

.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,

1640

.chain_id = ALC260_FIXUP_GPIO1_TOGGLE,

1641

},

1641

},

1642

[ALC260_FIXUP_HP_B1900] = {

1642

[ALC260_FIXUP_HP_B1900] = {

1643

.type = HDA_FIXUP_FUNC,

1643

.type = HDA_FIXUP_FUNC,

1644

.v.func = alc260_fixup_gpio1_toggle,

1644

.v.func = alc260_fixup_gpio1_toggle,

1645

.chained = true,

1645

.chained = true,

1646

.chain_id = ALC260_FIXUP_COEF,

1646

.chain_id = ALC260_FIXUP_COEF,

1647

},

1647

},

1648

[ALC260_FIXUP_KN1] = {

1648

[ALC260_FIXUP_KN1] = {

1649

.type = HDA_FIXUP_FUNC,

1649

.type = HDA_FIXUP_FUNC,

1650

.v.func = alc260_fixup_kn1,

1650

.v.func = alc260_fixup_kn1,

1651

},

1651

},

1652

[ALC260_FIXUP_FSC_S7020] = {

1652

[ALC260_FIXUP_FSC_S7020] = {

1653

.type = HDA_FIXUP_FUNC,

1653

.type = HDA_FIXUP_FUNC,

1654

.v.func = alc260_fixup_fsc_s7020,

1654

.v.func = alc260_fixup_fsc_s7020,

1655

},

1655

},

1656

[ALC260_FIXUP_FSC_S7020_JWSE] = {

1656

[ALC260_FIXUP_FSC_S7020_JWSE] = {

1657

.type = HDA_FIXUP_FUNC,

1657

.type = HDA_FIXUP_FUNC,

1658

.v.func = alc260_fixup_fsc_s7020_jwse,

1658

.v.func = alc260_fixup_fsc_s7020_jwse,

1659

.chained = true,

1659

.chained = true,

1660

.chain_id = ALC260_FIXUP_FSC_S7020,

1660

.chain_id = ALC260_FIXUP_FSC_S7020,

1661

},

1661

},

1662

[ALC260_FIXUP_VAIO_PINS] = {

1662

[ALC260_FIXUP_VAIO_PINS] = {

1663

.type = HDA_FIXUP_PINS,

1663

.type = HDA_FIXUP_PINS,

1664

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

1664

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

1665

/* Pin configs are missing completely on some VAIOs */

1665

/* Pin configs are missing completely on some VAIOs */

1666

{ 0x0f, 0x01211020 },

1666

{ 0x0f, 0x01211020 },

1667

{ 0x10, 0x0001003f },

1667

{ 0x10, 0x0001003f },

1668

{ 0x11, 0x411111f0 },

1668

{ 0x11, 0x411111f0 },

1669

{ 0x12, 0x01a15930 },

1669

{ 0x12, 0x01a15930 },

1670

{ 0x13, 0x411111f0 },

1670

{ 0x13, 0x411111f0 },

1671

{ 0x14, 0x411111f0 },

1671

{ 0x14, 0x411111f0 },

1672

{ 0x15, 0x411111f0 },

1672

{ 0x15, 0x411111f0 },

1673

{ 0x16, 0x411111f0 },

1673

{ 0x16, 0x411111f0 },

1674

{ 0x17, 0x411111f0 },

1674

{ 0x17, 0x411111f0 },

1675

{ 0x18, 0x411111f0 },

1675

{ 0x18, 0x411111f0 },

1676

{ 0x19, 0x411111f0 },

1676

{ 0x19, 0x411111f0 },

1677

{ }

1677

{ }

1678

}

1678

}

1679

},

1679

},

1680

};

1680

};

1681

1682

static const struct snd_pci_quirk alc260_fixup_tbl[] = {

1682

static const struct snd_pci_quirk alc260_fixup_tbl[] = {

1683

SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),

1683

SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),

1684

SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),

1684

SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),

1685

SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),

1685

SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),

1686

SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),

1686

SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),

1687

SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),

1687

SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),

1688

SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),

1688

SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),

1689

SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),

1689

SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),

1690

SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),

1690

SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),

1691

SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),

1691

SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),

1692

SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),

1692

SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),

1693

SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),

1693

SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),

1694

SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),

1694

SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),

1695

{}

1695

{}

1696

};

1696

};

1697

1698

static const struct hda_model_fixup alc260_fixup_models[] = {

1698

static const struct hda_model_fixup alc260_fixup_models[] = {

1699

{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},

1699

{.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},

1700

{.id = ALC260_FIXUP_COEF, .name = "coef"},

1700

{.id = ALC260_FIXUP_COEF, .name = "coef"},

1701

{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},

1701

{.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},

1702

{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},

1702

{.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},

1703

{}

1703

{}

1704

};

1704

};

1705

1706

/*

1706

/*

1707

*/

1707

*/

1708

static int patch_alc260(struct hda_codec *codec)

1708

static int patch_alc260(struct hda_codec *codec)

1709

{

1709

{

1710

struct alc_spec *spec;

1710

struct alc_spec *spec;

1711

int err;

1711

int err;

1712

1713

err = alc_alloc_spec(codec, 0x07);

1713

err = alc_alloc_spec(codec, 0x07);

1714

if (err < 0)

1714

if (err < 0)

1715

return err;

1715

return err;

1716

1717

spec = codec->spec;

1717

spec = codec->spec;

1718

/* as quite a few machines require HP amp for speaker outputs,

1718

/* as quite a few machines require HP amp for speaker outputs,

1719

* it's easier to enable it unconditionally; even if it's unneeded,

1719

* it's easier to enable it unconditionally; even if it's unneeded,

1720

* it's almost harmless.

1720

* it's almost harmless.

1721

*/

1721

*/

1722

spec->gen.prefer_hp_amp = 1;

1722

spec->gen.prefer_hp_amp = 1;

1723

spec->gen.beep_nid = 0x01;

1723

spec->gen.beep_nid = 0x01;

1724

1725

spec->shutup = alc_eapd_shutup;

1725

spec->shutup = alc_eapd_shutup;

1726

1727

snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,

1727

snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,

1728

alc260_fixups);

1728

alc260_fixups);

1729

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1729

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1730

1731

/* automatic parse from the BIOS config */

1731

/* automatic parse from the BIOS config */

1732

err = alc260_parse_auto_config(codec);

1732

err = alc260_parse_auto_config(codec);

1733

if (err < 0)

1733

if (err < 0)

1734

goto error;

1734

goto error;

1735

1736

if (!spec->gen.no_analog)

1736

if (!spec->gen.no_analog)

1737

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

1737

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

1738

1739

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1739

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1740

1741

return 0;

1741

return 0;

1742

1743

error:

1743

error:

1744

alc_free(codec);

1744

alc_free(codec);

1745

return err;

1745

return err;

1746

}

1746

}

1747

1748

1749

/*

1749

/*

1750

* ALC882/883/885/888/889 support

1750

* ALC882/883/885/888/889 support

1751

*

1751

*

1752

* ALC882 is almost identical with ALC880 but has cleaner and more flexible

1752

* ALC882 is almost identical with ALC880 but has cleaner and more flexible

1753

* configuration. Each pin widget can choose any input DACs and a mixer.

1753

* configuration. Each pin widget can choose any input DACs and a mixer.

1754

* Each ADC is connected from a mixer of all inputs. This makes possible

1754

* Each ADC is connected from a mixer of all inputs. This makes possible

1755

* 6-channel independent captures.

1755

* 6-channel independent captures.

1756

*

1756

*

1757

* In addition, an independent DAC for the multi-playback (not used in this

1757

* In addition, an independent DAC for the multi-playback (not used in this

1758

* driver yet).

1758

* driver yet).

1759

*/

1759

*/

1760

1761

/*

1761

/*

1762

* Pin config fixes

1762

* Pin config fixes

1763

*/

1763

*/

1764

enum {

1764

enum {

1765

ALC882_FIXUP_ABIT_AW9D_MAX,

1765

ALC882_FIXUP_ABIT_AW9D_MAX,

1766

ALC882_FIXUP_LENOVO_Y530,

1766

ALC882_FIXUP_LENOVO_Y530,

1767

ALC882_FIXUP_PB_M5210,

1767

ALC882_FIXUP_PB_M5210,

1768

ALC882_FIXUP_ACER_ASPIRE_7736,

1768

ALC882_FIXUP_ACER_ASPIRE_7736,

1769

ALC882_FIXUP_ASUS_W90V,

1769

ALC882_FIXUP_ASUS_W90V,

1770

ALC889_FIXUP_CD,

1770

ALC889_FIXUP_CD,

1771

ALC889_FIXUP_FRONT_HP_NO_PRESENCE,

1771

ALC889_FIXUP_FRONT_HP_NO_PRESENCE,

1772

ALC889_FIXUP_VAIO_TT,

1772

ALC889_FIXUP_VAIO_TT,

1773

ALC888_FIXUP_EEE1601,

1773

ALC888_FIXUP_EEE1601,

1774

ALC882_FIXUP_EAPD,

1774

ALC882_FIXUP_EAPD,

1775

ALC883_FIXUP_EAPD,

1775

ALC883_FIXUP_EAPD,

1776

ALC883_FIXUP_ACER_EAPD,

1776

ALC883_FIXUP_ACER_EAPD,

1777

ALC882_FIXUP_GPIO1,

1777

ALC882_FIXUP_GPIO1,

1778

ALC882_FIXUP_GPIO2,

1778

ALC882_FIXUP_GPIO2,

1779

ALC882_FIXUP_GPIO3,

1779

ALC882_FIXUP_GPIO3,

1780

ALC889_FIXUP_COEF,

1780

ALC889_FIXUP_COEF,

1781

ALC882_FIXUP_ASUS_W2JC,

1781

ALC882_FIXUP_ASUS_W2JC,

1782

ALC882_FIXUP_ACER_ASPIRE_4930G,

1782

ALC882_FIXUP_ACER_ASPIRE_4930G,

1783

ALC882_FIXUP_ACER_ASPIRE_8930G,

1783

ALC882_FIXUP_ACER_ASPIRE_8930G,

1784

ALC882_FIXUP_ASPIRE_8930G_VERBS,

1784

ALC882_FIXUP_ASPIRE_8930G_VERBS,

1785

ALC885_FIXUP_MACPRO_GPIO,

1785

ALC885_FIXUP_MACPRO_GPIO,

1786

ALC889_FIXUP_DAC_ROUTE,

1786

ALC889_FIXUP_DAC_ROUTE,

1787

ALC889_FIXUP_MBP_VREF,

1787

ALC889_FIXUP_MBP_VREF,

1788

ALC889_FIXUP_IMAC91_VREF,

1788

ALC889_FIXUP_IMAC91_VREF,

1789

ALC889_FIXUP_MBA11_VREF,

1789

ALC889_FIXUP_MBA11_VREF,

1790

ALC889_FIXUP_MBA21_VREF,

1790

ALC889_FIXUP_MBA21_VREF,

1791

ALC889_FIXUP_MP11_VREF,

1791

ALC889_FIXUP_MP11_VREF,

1792

ALC889_FIXUP_MP41_VREF,

1792

ALC889_FIXUP_MP41_VREF,

1793

ALC882_FIXUP_INV_DMIC,

1793

ALC882_FIXUP_INV_DMIC,

1794

ALC882_FIXUP_NO_PRIMARY_HP,

1794

ALC882_FIXUP_NO_PRIMARY_HP,

1795

ALC887_FIXUP_ASUS_BASS,

1795

ALC887_FIXUP_ASUS_BASS,

1796

ALC887_FIXUP_BASS_CHMAP,

1796

ALC887_FIXUP_BASS_CHMAP,

1797

};

1797

};

1798

1799

static void alc889_fixup_coef(struct hda_codec *codec,

1799

static void alc889_fixup_coef(struct hda_codec *codec,

1800

const struct hda_fixup *fix, int action)

1800

const struct hda_fixup *fix, int action)

1801

{

1801

{

1802

if (action != HDA_FIXUP_ACT_INIT)

1802

if (action != HDA_FIXUP_ACT_INIT)

1803

return;

1803

return;

1804

alc_update_coef_idx(codec, 7, 0, 0x2030);

1804

alc_update_coef_idx(codec, 7, 0, 0x2030);

1805

}

1805

}

1806

1807

/* toggle speaker-output according to the hp-jack state */

1807

/* toggle speaker-output according to the hp-jack state */

1808

static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)

1808

static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)

1809

{

1809

{

1810

unsigned int gpiostate, gpiomask, gpiodir;

1810

unsigned int gpiostate, gpiomask, gpiodir;

1811

1812

gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,

1812

gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,

1813

AC_VERB_GET_GPIO_DATA, 0);

1813

AC_VERB_GET_GPIO_DATA, 0);

1814

1815

if (!muted)

1815

if (!muted)

1816

gpiostate |= (1 << pin);

1816

gpiostate |= (1 << pin);

1817

else

1817

else

1818

gpiostate &= ~(1 << pin);

1818

gpiostate &= ~(1 << pin);

1819

1820

gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,

1820

gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,

1821

AC_VERB_GET_GPIO_MASK, 0);

1821

AC_VERB_GET_GPIO_MASK, 0);

1822

gpiomask |= (1 << pin);

1822

gpiomask |= (1 << pin);

1823

1824

gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,

1824

gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,

1825

AC_VERB_GET_GPIO_DIRECTION, 0);

1825

AC_VERB_GET_GPIO_DIRECTION, 0);

1826

gpiodir |= (1 << pin);

1826

gpiodir |= (1 << pin);

1827

1828

1829

snd_hda_codec_write(codec, codec->core.afg, 0,

1829

snd_hda_codec_write(codec, codec->core.afg, 0,

1830

AC_VERB_SET_GPIO_MASK, gpiomask);

1830

AC_VERB_SET_GPIO_MASK, gpiomask);

1831

snd_hda_codec_write(codec, codec->core.afg, 0,

1831

snd_hda_codec_write(codec, codec->core.afg, 0,

1832

AC_VERB_SET_GPIO_DIRECTION, gpiodir);

1832

AC_VERB_SET_GPIO_DIRECTION, gpiodir);

1833

1834

msleep(1);

1834

msleep(1);

1835

1836

snd_hda_codec_write(codec, codec->core.afg, 0,

1836

snd_hda_codec_write(codec, codec->core.afg, 0,

1837

AC_VERB_SET_GPIO_DATA, gpiostate);

1837

AC_VERB_SET_GPIO_DATA, gpiostate);

1838

}

1838

}

1839

1840

/* set up GPIO at initialization */

1840

/* set up GPIO at initialization */

1841

static void alc885_fixup_macpro_gpio(struct hda_codec *codec,

1841

static void alc885_fixup_macpro_gpio(struct hda_codec *codec,

1842

const struct hda_fixup *fix, int action)

1842

const struct hda_fixup *fix, int action)

1843

{

1843

{

1844

if (action != HDA_FIXUP_ACT_INIT)

1844

if (action != HDA_FIXUP_ACT_INIT)

1845

return;

1845

return;

1846

alc882_gpio_mute(codec, 0, 0);

1846

alc882_gpio_mute(codec, 0, 0);

1847

alc882_gpio_mute(codec, 1, 0);

1847

alc882_gpio_mute(codec, 1, 0);

1848

}

1848

}

1849

1850

/* Fix the connection of some pins for ALC889:

1850

/* Fix the connection of some pins for ALC889:

1851

* At least, Acer Aspire 5935 shows the connections to DAC3/4 don't

1851

* At least, Acer Aspire 5935 shows the connections to DAC3/4 don't

1852

* work correctly (bko#42740)

1852

* work correctly (bko#42740)

1853

*/

1853

*/

1854

static void alc889_fixup_dac_route(struct hda_codec *codec,

1854

static void alc889_fixup_dac_route(struct hda_codec *codec,

1855

const struct hda_fixup *fix, int action)

1855

const struct hda_fixup *fix, int action)

1856

{

1856

{

1857

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1857

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1858

/* fake the connections during parsing the tree */

1858

/* fake the connections during parsing the tree */

1859

hda_nid_t conn1[2] = { 0x0c, 0x0d };

1859

hda_nid_t conn1[2] = { 0x0c, 0x0d };

1860

hda_nid_t conn2[2] = { 0x0e, 0x0f };

1860

hda_nid_t conn2[2] = { 0x0e, 0x0f };

1861

snd_hda_override_conn_list(codec, 0x14, 2, conn1);

1861

snd_hda_override_conn_list(codec, 0x14, 2, conn1);

1862

snd_hda_override_conn_list(codec, 0x15, 2, conn1);

1862

snd_hda_override_conn_list(codec, 0x15, 2, conn1);

1863

snd_hda_override_conn_list(codec, 0x18, 2, conn2);

1863

snd_hda_override_conn_list(codec, 0x18, 2, conn2);

1864

snd_hda_override_conn_list(codec, 0x1a, 2, conn2);

1864

snd_hda_override_conn_list(codec, 0x1a, 2, conn2);

1865

} else if (action == HDA_FIXUP_ACT_PROBE) {

1865

} else if (action == HDA_FIXUP_ACT_PROBE) {

1866

/* restore the connections */

1866

/* restore the connections */

1867

hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };

1867

hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };

1868

snd_hda_override_conn_list(codec, 0x14, 5, conn);

1868

snd_hda_override_conn_list(codec, 0x14, 5, conn);

1869

snd_hda_override_conn_list(codec, 0x15, 5, conn);

1869

snd_hda_override_conn_list(codec, 0x15, 5, conn);

1870

snd_hda_override_conn_list(codec, 0x18, 5, conn);

1870

snd_hda_override_conn_list(codec, 0x18, 5, conn);

1871

snd_hda_override_conn_list(codec, 0x1a, 5, conn);

1871

snd_hda_override_conn_list(codec, 0x1a, 5, conn);

1872

}

1872

}

1873

}

1873

}

1874

1875

/* Set VREF on HP pin */

1875

/* Set VREF on HP pin */

1876

static void alc889_fixup_mbp_vref(struct hda_codec *codec,

1876

static void alc889_fixup_mbp_vref(struct hda_codec *codec,

1877

const struct hda_fixup *fix, int action)

1877

const struct hda_fixup *fix, int action)

1878

{

1878

{

1879

struct alc_spec *spec = codec->spec;

1879

struct alc_spec *spec = codec->spec;

1880

static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };

1880

static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };

1881

int i;

1881

int i;

1882

1883

if (action != HDA_FIXUP_ACT_INIT)

1883

if (action != HDA_FIXUP_ACT_INIT)

1884

return;

1884

return;

1885

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

1885

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

1886

unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);

1886

unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);

1887

if (get_defcfg_device(val) != AC_JACK_HP_OUT)

1887

if (get_defcfg_device(val) != AC_JACK_HP_OUT)

1888

continue;

1888

continue;

1889

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1889

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1890

val |= AC_PINCTL_VREF_80;

1890

val |= AC_PINCTL_VREF_80;

1891

snd_hda_set_pin_ctl(codec, nids[i], val);

1891

snd_hda_set_pin_ctl(codec, nids[i], val);

1892

spec->gen.keep_vref_in_automute = 1;

1892

spec->gen.keep_vref_in_automute = 1;

1893

break;

1893

break;

1894

}

1894

}

1895

}

1895

}

1896

1897

static void alc889_fixup_mac_pins(struct hda_codec *codec,

1897

static void alc889_fixup_mac_pins(struct hda_codec *codec,

1898

const hda_nid_t *nids, int num_nids)

1898

const hda_nid_t *nids, int num_nids)

1899

{

1899

{

1900

struct alc_spec *spec = codec->spec;

1900

struct alc_spec *spec = codec->spec;

1901

int i;

1901

int i;

1902

1903

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

1903

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

1904

unsigned int val;

1904

unsigned int val;

1905

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1905

val = snd_hda_codec_get_pin_target(codec, nids[i]);

1906

val |= AC_PINCTL_VREF_50;

1906

val |= AC_PINCTL_VREF_50;

1907

snd_hda_set_pin_ctl(codec, nids[i], val);

1907

snd_hda_set_pin_ctl(codec, nids[i], val);

1908

}

1908

}

1909

spec->gen.keep_vref_in_automute = 1;

1909

spec->gen.keep_vref_in_automute = 1;

1910

}

1910

}

1911

1912

/* Set VREF on speaker pins on imac91 */

1912

/* Set VREF on speaker pins on imac91 */

1913

static void alc889_fixup_imac91_vref(struct hda_codec *codec,

1913

static void alc889_fixup_imac91_vref(struct hda_codec *codec,

1914

const struct hda_fixup *fix, int action)

1914

const struct hda_fixup *fix, int action)

1915

{

1915

{

1916

static hda_nid_t nids[2] = { 0x18, 0x1a };

1916

static hda_nid_t nids[2] = { 0x18, 0x1a };

1917

1918

if (action == HDA_FIXUP_ACT_INIT)

1918

if (action == HDA_FIXUP_ACT_INIT)

1919

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1919

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1920

}

1920

}

1921

1922

/* Set VREF on speaker pins on mba11 */

1922

/* Set VREF on speaker pins on mba11 */

1923

static void alc889_fixup_mba11_vref(struct hda_codec *codec,

1923

static void alc889_fixup_mba11_vref(struct hda_codec *codec,

1924

const struct hda_fixup *fix, int action)

1924

const struct hda_fixup *fix, int action)

1925

{

1925

{

1926

static hda_nid_t nids[1] = { 0x18 };

1926

static hda_nid_t nids[1] = { 0x18 };

1927

1928

if (action == HDA_FIXUP_ACT_INIT)

1928

if (action == HDA_FIXUP_ACT_INIT)

1929

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1929

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1930

}

1930

}

1931

1932

/* Set VREF on speaker pins on mba21 */

1932

/* Set VREF on speaker pins on mba21 */

1933

static void alc889_fixup_mba21_vref(struct hda_codec *codec,

1933

static void alc889_fixup_mba21_vref(struct hda_codec *codec,

1934

const struct hda_fixup *fix, int action)

1934

const struct hda_fixup *fix, int action)

1935

{

1935

{

1936

static hda_nid_t nids[2] = { 0x18, 0x19 };

1936

static hda_nid_t nids[2] = { 0x18, 0x19 };

1937

1938

if (action == HDA_FIXUP_ACT_INIT)

1938

if (action == HDA_FIXUP_ACT_INIT)

1939

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1939

alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));

1940

}

1940

}

1941

1942

/* Don't take HP output as primary

1942

/* Don't take HP output as primary

1943

* Strangely, the speaker output doesn't work on Vaio Z and some Vaio

1943

* Strangely, the speaker output doesn't work on Vaio Z and some Vaio

1944

* all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05

1944

* all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05

1945

*/

1945

*/

1946

static void alc882_fixup_no_primary_hp(struct hda_codec *codec,

1946

static void alc882_fixup_no_primary_hp(struct hda_codec *codec,

1947

const struct hda_fixup *fix, int action)

1947

const struct hda_fixup *fix, int action)

1948

{

1948

{

1949

struct alc_spec *spec = codec->spec;

1949

struct alc_spec *spec = codec->spec;

1950

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1950

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

1951

spec->gen.no_primary_hp = 1;

1951

spec->gen.no_primary_hp = 1;

1952

spec->gen.no_multi_io = 1;

1952

spec->gen.no_multi_io = 1;

1953

}

1953

}

1954

}

1954

}

1955

1956

static void alc_fixup_bass_chmap(struct hda_codec *codec,

1956

static void alc_fixup_bass_chmap(struct hda_codec *codec,

1957

const struct hda_fixup *fix, int action);

1957

const struct hda_fixup *fix, int action);

1958

1959

static const struct hda_fixup alc882_fixups[] = {

1959

static const struct hda_fixup alc882_fixups[] = {

1960

[ALC882_FIXUP_ABIT_AW9D_MAX] = {

1960

[ALC882_FIXUP_ABIT_AW9D_MAX] = {

1961

.type = HDA_FIXUP_PINS,

1961

.type = HDA_FIXUP_PINS,

1962

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

1962

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

1963

{ 0x15, 0x01080104 }, /* side */

1963

{ 0x15, 0x01080104 }, /* side */

1964

{ 0x16, 0x01011012 }, /* rear */

1964

{ 0x16, 0x01011012 }, /* rear */

1965

{ 0x17, 0x01016011 }, /* clfe */

1965

{ 0x17, 0x01016011 }, /* clfe */

1966

{ }

1966

{ }

1967

}

1967

}

1968

},

1968

},

1969

[ALC882_FIXUP_LENOVO_Y530] = {

1969

[ALC882_FIXUP_LENOVO_Y530] = {

1970

.type = HDA_FIXUP_PINS,

1970

.type = HDA_FIXUP_PINS,

1971

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

1971

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

1972

{ 0x15, 0x99130112 }, /* rear int speakers */

1972

{ 0x15, 0x99130112 }, /* rear int speakers */

1973

{ 0x16, 0x99130111 }, /* subwoofer */

1973

{ 0x16, 0x99130111 }, /* subwoofer */

1974

{ }

1974

{ }

1975

}

1975

}

1976

},

1976

},

1977

[ALC882_FIXUP_PB_M5210] = {

1977

[ALC882_FIXUP_PB_M5210] = {

1978

.type = HDA_FIXUP_PINCTLS,

1978

.type = HDA_FIXUP_PINCTLS,

1979

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

1979

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

1980

{ 0x19, PIN_VREF50 },

1980

{ 0x19, PIN_VREF50 },

1981

{}

1981

{}

1982

}

1982

}

1983

},

1983

},

1984

[ALC882_FIXUP_ACER_ASPIRE_7736] = {

1984

[ALC882_FIXUP_ACER_ASPIRE_7736] = {

1985

.type = HDA_FIXUP_FUNC,

1985

.type = HDA_FIXUP_FUNC,

1986

.v.func = alc_fixup_sku_ignore,

1986

.v.func = alc_fixup_sku_ignore,

1987

},

1987

},

1988

[ALC882_FIXUP_ASUS_W90V] = {

1988

[ALC882_FIXUP_ASUS_W90V] = {

1989

.type = HDA_FIXUP_PINS,

1989

.type = HDA_FIXUP_PINS,

1990

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

1990

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

1991

{ 0x16, 0x99130110 }, /* fix sequence for CLFE */

1991

{ 0x16, 0x99130110 }, /* fix sequence for CLFE */

1992

{ }

1992

{ }

1993

}

1993

}

1994

},

1994

},

1995

[ALC889_FIXUP_CD] = {

1995

[ALC889_FIXUP_CD] = {

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

{ 0x1c, 0x993301f0 }, /* CD */

1998

{ 0x1c, 0x993301f0 }, /* CD */

1999

{ }

1999

{ }

2000

}

2000

}

2001

},

2001

},

2002

[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {

2002

[ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {

2003

.type = HDA_FIXUP_PINS,

2003

.type = HDA_FIXUP_PINS,

2004

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

2004

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

2005

{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */

2005

{ 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */

2006

{ }

2006

{ }

2007

},

2007

},

2008

.chained = true,

2008

.chained = true,

2009

.chain_id = ALC889_FIXUP_CD,

2009

.chain_id = ALC889_FIXUP_CD,

2010

},

2010

},

2011

[ALC889_FIXUP_VAIO_TT] = {

2011

[ALC889_FIXUP_VAIO_TT] = {

2012

.type = HDA_FIXUP_PINS,

2012

.type = HDA_FIXUP_PINS,

2013

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

2013

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

2014

{ 0x17, 0x90170111 }, /* hidden surround speaker */

2014

{ 0x17, 0x90170111 }, /* hidden surround speaker */

2015

{ }

2015

{ }

2016

}

2016

}

2017

},

2017

},

2018

[ALC888_FIXUP_EEE1601] = {

2018

[ALC888_FIXUP_EEE1601] = {

2019

.type = HDA_FIXUP_VERBS,

2019

.type = HDA_FIXUP_VERBS,

2020

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

2020

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

2021

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2021

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2022

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },

2022

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },

2023

{ }

2023

{ }

2024

}

2024

}

2025

},

2025

},

2026

[ALC882_FIXUP_EAPD] = {

2026

[ALC882_FIXUP_EAPD] = {

2027

.type = HDA_FIXUP_VERBS,

2027

.type = HDA_FIXUP_VERBS,

2028

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

2028

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

2029

/* change to EAPD mode */

2029

/* change to EAPD mode */

2030

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2030

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2031

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

2031

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },

2032

{ }

2032

{ }

2033

}

2033

}

2034

},

2034

},

2035

[ALC883_FIXUP_EAPD] = {

2035

[ALC883_FIXUP_EAPD] = {

2036

.type = HDA_FIXUP_VERBS,

2036

.type = HDA_FIXUP_VERBS,

2037

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

2037

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

2038

/* change to EAPD mode */

2038

/* change to EAPD mode */

2039

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2039

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2040

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2040

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2041

{ }

2041

{ }

2042

}

2042

}

2043

},

2043

},

2044

[ALC883_FIXUP_ACER_EAPD] = {

2044

[ALC883_FIXUP_ACER_EAPD] = {

2045

.type = HDA_FIXUP_VERBS,

2045

.type = HDA_FIXUP_VERBS,

2046

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

2046

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

2047

/* eanable EAPD on Acer laptops */

2047

/* eanable EAPD on Acer laptops */

2048

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2048

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2049

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2049

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2050

{ }

2050

{ }

2051

}

2051

}

2052

},

2052

},

2053

[ALC882_FIXUP_GPIO1] = {

2053

[ALC882_FIXUP_GPIO1] = {

2054

.type = HDA_FIXUP_VERBS,

2054

.type = HDA_FIXUP_VERBS,

2055

.v.verbs = alc_gpio1_init_verbs,

2055

.v.verbs = alc_gpio1_init_verbs,

2056

},

2056

},

2057

[ALC882_FIXUP_GPIO2] = {

2057

[ALC882_FIXUP_GPIO2] = {

2058

.type = HDA_FIXUP_VERBS,

2058

.type = HDA_FIXUP_VERBS,

2059

.v.verbs = alc_gpio2_init_verbs,

2059

.v.verbs = alc_gpio2_init_verbs,

2060

},

2060

},

2061

[ALC882_FIXUP_GPIO3] = {

2061

[ALC882_FIXUP_GPIO3] = {

2062

.type = HDA_FIXUP_VERBS,

2062

.type = HDA_FIXUP_VERBS,

2063

.v.verbs = alc_gpio3_init_verbs,

2063

.v.verbs = alc_gpio3_init_verbs,

2064

},

2064

},

2065

[ALC882_FIXUP_ASUS_W2JC] = {

2065

[ALC882_FIXUP_ASUS_W2JC] = {

2066

.type = HDA_FIXUP_VERBS,

2066

.type = HDA_FIXUP_VERBS,

2067

.v.verbs = alc_gpio1_init_verbs,

2067

.v.verbs = alc_gpio1_init_verbs,

2068

.chained = true,

2068

.chained = true,

2069

.chain_id = ALC882_FIXUP_EAPD,

2069

.chain_id = ALC882_FIXUP_EAPD,

2070

},

2070

},

2071

[ALC889_FIXUP_COEF] = {

2071

[ALC889_FIXUP_COEF] = {

2072

.type = HDA_FIXUP_FUNC,

2072

.type = HDA_FIXUP_FUNC,

2073

.v.func = alc889_fixup_coef,

2073

.v.func = alc889_fixup_coef,

2074

},

2074

},

2075

[ALC882_FIXUP_ACER_ASPIRE_4930G] = {

2075

[ALC882_FIXUP_ACER_ASPIRE_4930G] = {

2076

.type = HDA_FIXUP_PINS,

2076

.type = HDA_FIXUP_PINS,

2077

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

2077

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

2078

{ 0x16, 0x99130111 }, /* CLFE speaker */

2078

{ 0x16, 0x99130111 }, /* CLFE speaker */

2079

{ 0x17, 0x99130112 }, /* surround speaker */

2079

{ 0x17, 0x99130112 }, /* surround speaker */

2080

{ }

2080

{ }

2081

},

2081

},

2082

.chained = true,

2082

.chained = true,

2083

.chain_id = ALC882_FIXUP_GPIO1,

2083

.chain_id = ALC882_FIXUP_GPIO1,

2084

},

2084

},

2085

[ALC882_FIXUP_ACER_ASPIRE_8930G] = {

2085

[ALC882_FIXUP_ACER_ASPIRE_8930G] = {

2086

.type = HDA_FIXUP_PINS,

2086

.type = HDA_FIXUP_PINS,

2087

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

2087

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

2088

{ 0x16, 0x99130111 }, /* CLFE speaker */

2088

{ 0x16, 0x99130111 }, /* CLFE speaker */

2089

{ 0x1b, 0x99130112 }, /* surround speaker */

2089

{ 0x1b, 0x99130112 }, /* surround speaker */

2090

{ }

2090

{ }

2091

},

2091

},

2092

.chained = true,

2092

.chained = true,

2093

.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,

2093

.chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,

2094

},

2094

},

2095

[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {

2095

[ALC882_FIXUP_ASPIRE_8930G_VERBS] = {

2096

/* additional init verbs for Acer Aspire 8930G */

2096

/* additional init verbs for Acer Aspire 8930G */

2097

.type = HDA_FIXUP_VERBS,

2097

.type = HDA_FIXUP_VERBS,

2098

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

2098

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

2099

/* Enable all DACs */

2099

/* Enable all DACs */

2100

/* DAC DISABLE/MUTE 1? */

2100

/* DAC DISABLE/MUTE 1? */

2101

/* setting bits 1-5 disables DAC nids 0x02-0x06

2101

/* setting bits 1-5 disables DAC nids 0x02-0x06

2102

* apparently. Init=0x38 */

2102

* apparently. Init=0x38 */

2103

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },

2103

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },

2104

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2104

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2105

/* DAC DISABLE/MUTE 2? */

2105

/* DAC DISABLE/MUTE 2? */

2106

/* some bit here disables the other DACs.

2106

/* some bit here disables the other DACs.

2107

* Init=0x4900 */

2107

* Init=0x4900 */

2108

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },

2108

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },

2109

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2109

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },

2110

/* DMIC fix

2110

/* DMIC fix

2111

* This laptop has a stereo digital microphone.

2111

* This laptop has a stereo digital microphone.

2112

* The mics are only 1cm apart which makes the stereo

2112

* The mics are only 1cm apart which makes the stereo

2113

* useless. However, either the mic or the ALC889

2113

* useless. However, either the mic or the ALC889

2114

* makes the signal become a difference/sum signal

2114

* makes the signal become a difference/sum signal

2115

* instead of standard stereo, which is annoying.

2115

* instead of standard stereo, which is annoying.

2116

* So instead we flip this bit which makes the

2116

* So instead we flip this bit which makes the

2117

* codec replicate the sum signal to both channels,

2117

* codec replicate the sum signal to both channels,

2118

* turning it into a normal mono mic.

2118

* turning it into a normal mono mic.

2119

*/

2119

*/

2120

/* DMIC_CONTROL? Init value = 0x0001 */

2120

/* DMIC_CONTROL? Init value = 0x0001 */

2121

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2121

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },

2122

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },

2122

{ 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },

2123

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2123

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2124

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2124

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2125

{ }

2125

{ }

2126

},

2126

},

2127

.chained = true,

2127

.chained = true,

2128

.chain_id = ALC882_FIXUP_GPIO1,

2128

.chain_id = ALC882_FIXUP_GPIO1,

2129

},

2129

},

2130

[ALC885_FIXUP_MACPRO_GPIO] = {

2130

[ALC885_FIXUP_MACPRO_GPIO] = {

2131

.type = HDA_FIXUP_FUNC,

2131

.type = HDA_FIXUP_FUNC,

2132

.v.func = alc885_fixup_macpro_gpio,

2132

.v.func = alc885_fixup_macpro_gpio,

2133

},

2133

},

2134

[ALC889_FIXUP_DAC_ROUTE] = {

2134

[ALC889_FIXUP_DAC_ROUTE] = {

2135

.type = HDA_FIXUP_FUNC,

2135

.type = HDA_FIXUP_FUNC,

2136

.v.func = alc889_fixup_dac_route,

2136

.v.func = alc889_fixup_dac_route,

2137

},

2137

},

2138

[ALC889_FIXUP_MBP_VREF] = {

2138

[ALC889_FIXUP_MBP_VREF] = {

2139

.type = HDA_FIXUP_FUNC,

2139

.type = HDA_FIXUP_FUNC,

2140

.v.func = alc889_fixup_mbp_vref,

2140

.v.func = alc889_fixup_mbp_vref,

2141

.chained = true,

2141

.chained = true,

2142

.chain_id = ALC882_FIXUP_GPIO1,

2142

.chain_id = ALC882_FIXUP_GPIO1,

2143

},

2143

},

2144

[ALC889_FIXUP_IMAC91_VREF] = {

2144

[ALC889_FIXUP_IMAC91_VREF] = {

2145

.type = HDA_FIXUP_FUNC,

2145

.type = HDA_FIXUP_FUNC,

2146

.v.func = alc889_fixup_imac91_vref,

2146

.v.func = alc889_fixup_imac91_vref,

2147

.chained = true,

2147

.chained = true,

2148

.chain_id = ALC882_FIXUP_GPIO1,

2148

.chain_id = ALC882_FIXUP_GPIO1,

2149

},

2149

},

2150

[ALC889_FIXUP_MBA11_VREF] = {

2150

[ALC889_FIXUP_MBA11_VREF] = {

2151

.type = HDA_FIXUP_FUNC,

2151

.type = HDA_FIXUP_FUNC,

2152

.v.func = alc889_fixup_mba11_vref,

2152

.v.func = alc889_fixup_mba11_vref,

2153

.chained = true,

2153

.chained = true,

2154

.chain_id = ALC889_FIXUP_MBP_VREF,

2154

.chain_id = ALC889_FIXUP_MBP_VREF,

2155

},

2155

},

2156

[ALC889_FIXUP_MBA21_VREF] = {

2156

[ALC889_FIXUP_MBA21_VREF] = {

2157

.type = HDA_FIXUP_FUNC,

2157

.type = HDA_FIXUP_FUNC,

2158

.v.func = alc889_fixup_mba21_vref,

2158

.v.func = alc889_fixup_mba21_vref,

2159

.chained = true,

2159

.chained = true,

2160

.chain_id = ALC889_FIXUP_MBP_VREF,

2160

.chain_id = ALC889_FIXUP_MBP_VREF,

2161

},

2161

},

2162

[ALC889_FIXUP_MP11_VREF] = {

2162

[ALC889_FIXUP_MP11_VREF] = {

2163

.type = HDA_FIXUP_FUNC,

2163

.type = HDA_FIXUP_FUNC,

2164

.v.func = alc889_fixup_mba11_vref,

2164

.v.func = alc889_fixup_mba11_vref,

2165

.chained = true,

2165

.chained = true,

2166

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2166

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2167

},

2167

},

2168

[ALC889_FIXUP_MP41_VREF] = {

2168

[ALC889_FIXUP_MP41_VREF] = {

2169

.type = HDA_FIXUP_FUNC,

2169

.type = HDA_FIXUP_FUNC,

2170

.v.func = alc889_fixup_mbp_vref,

2170

.v.func = alc889_fixup_mbp_vref,

2171

.chained = true,

2171

.chained = true,

2172

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2172

.chain_id = ALC885_FIXUP_MACPRO_GPIO,

2173

},

2173

},

2174

[ALC882_FIXUP_INV_DMIC] = {

2174

[ALC882_FIXUP_INV_DMIC] = {

2175

.type = HDA_FIXUP_FUNC,

2175

.type = HDA_FIXUP_FUNC,

2176

.v.func = alc_fixup_inv_dmic,

2176

.v.func = alc_fixup_inv_dmic,

2177

},

2177

},

2178

[ALC882_FIXUP_NO_PRIMARY_HP] = {

2178

[ALC882_FIXUP_NO_PRIMARY_HP] = {

2179

.type = HDA_FIXUP_FUNC,

2179

.type = HDA_FIXUP_FUNC,

2180

.v.func = alc882_fixup_no_primary_hp,

2180

.v.func = alc882_fixup_no_primary_hp,

2181

},

2181

},

2182

[ALC887_FIXUP_ASUS_BASS] = {

2182

[ALC887_FIXUP_ASUS_BASS] = {

2183

.type = HDA_FIXUP_PINS,

2183

.type = HDA_FIXUP_PINS,

2184

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

2184

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

2185

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

2185

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

2186

{}

2186

{}

2187

},

2187

},

2188

.chained = true,

2188

.chained = true,

2189

.chain_id = ALC887_FIXUP_BASS_CHMAP,

2189

.chain_id = ALC887_FIXUP_BASS_CHMAP,

2190

},

2190

},

2191

[ALC887_FIXUP_BASS_CHMAP] = {

2191

[ALC887_FIXUP_BASS_CHMAP] = {

2192

.type = HDA_FIXUP_FUNC,

2192

.type = HDA_FIXUP_FUNC,

2193

.v.func = alc_fixup_bass_chmap,

2193

.v.func = alc_fixup_bass_chmap,

2194

},

2194

},

2195

};

2195

};

2196

2197

static const struct snd_pci_quirk alc882_fixup_tbl[] = {

2197

static const struct snd_pci_quirk alc882_fixup_tbl[] = {

2198

SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),

2198

SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),

2199

SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2199

SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2200

SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2200

SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2201

SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),

2201

SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),

2202

SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2202

SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),

2203

SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),

2203

SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),

2204

SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),

2204

SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),

2205

SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",

2205

SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",

2206

ALC882_FIXUP_ACER_ASPIRE_4930G),

2206

ALC882_FIXUP_ACER_ASPIRE_4930G),

2207

SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",

2207

SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",

2208

ALC882_FIXUP_ACER_ASPIRE_4930G),

2208

ALC882_FIXUP_ACER_ASPIRE_4930G),

2209

SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",

2209

SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",

2210

ALC882_FIXUP_ACER_ASPIRE_8930G),

2210

ALC882_FIXUP_ACER_ASPIRE_8930G),

2211

SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",

2211

SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",

2212

ALC882_FIXUP_ACER_ASPIRE_8930G),

2212

ALC882_FIXUP_ACER_ASPIRE_8930G),

2213

SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",

2213

SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",

2214

ALC882_FIXUP_ACER_ASPIRE_4930G),

2214

ALC882_FIXUP_ACER_ASPIRE_4930G),

2215

SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",

2215

SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",

2216

ALC882_FIXUP_ACER_ASPIRE_4930G),

2216

ALC882_FIXUP_ACER_ASPIRE_4930G),

2217

SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",

2217

SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",

2218

ALC882_FIXUP_ACER_ASPIRE_4930G),

2218

ALC882_FIXUP_ACER_ASPIRE_4930G),

2219

SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),

2219

SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),

2220

SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",

2220

SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",

2221

ALC882_FIXUP_ACER_ASPIRE_4930G),

2221

ALC882_FIXUP_ACER_ASPIRE_4930G),

2222

SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),

2222

SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),

2223

SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),

2223

SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),

2224

SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),

2224

SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),

2225

SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),

2225

SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),

2226

SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),

2226

SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),

2227

SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),

2227

SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),

2228

SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),

2228

SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),

2229

SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),

2229

SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),

2230

SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),

2230

SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),

2231

SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),

2231

SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),

2232

SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),

2232

SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),

2233

SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),

2233

SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),

2234

2235

/* All Apple entries are in codec SSIDs */

2235

/* All Apple entries are in codec SSIDs */

2236

SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),

2236

SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),

2237

SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),

2237

SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),

2238

SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2238

SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2239

SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),

2239

SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),

2240

SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),

2240

SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),

2241

SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),

2241

SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),

2242

SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),

2242

SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),

2243

SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),

2243

SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),

2244

SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),

2244

SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),

2245

SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),

2245

SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),

2246

SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),

2246

SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),

2247

SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),

2247

SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),

2248

SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2248

SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),

2249

SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),

2249

SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),

2250

SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),

2250

SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),

2251

SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),

2251

SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),

2252

SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),

2252

SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),

2253

SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),

2253

SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),

2254

SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),

2254

SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),

2255

SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),

2255

SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),

2256

SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),

2256

SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),

2257

SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),

2257

SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),

2258

2259

SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),

2259

SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),

2260

SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),

2260

SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),

2261

SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),

2261

SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),

2262

SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),

2262

SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),

2263

SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),

2263

SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),

2264

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),

2264

SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),

2265

SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),

2265

SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),

2266

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),

2266

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),

2267

SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),

2267

SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),

2268

{}

2268

{}

2269

};

2269

};

2270

2271

static const struct hda_model_fixup alc882_fixup_models[] = {

2271

static const struct hda_model_fixup alc882_fixup_models[] = {

2272

{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},

2272

{.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},

2273

{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},

2273

{.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},

2274

{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},

2274

{.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},

2275

{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},

2275

{.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},

2276

{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},

2276

{.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},

2277

{}

2277

{}

2278

};

2278

};

2279

2280

/*

2280

/*

2281

* BIOS auto configuration

2281

* BIOS auto configuration

2282

*/

2282

*/

2283

/* almost identical with ALC880 parser... */

2283

/* almost identical with ALC880 parser... */

2284

static int alc882_parse_auto_config(struct hda_codec *codec)

2284

static int alc882_parse_auto_config(struct hda_codec *codec)

2285

{

2285

{

2286

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

2286

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

2287

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

2287

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

2288

return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);

2288

return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);

2289

}

2289

}

2290

2291

/*

2291

/*

2292

*/

2292

*/

2293

static int patch_alc882(struct hda_codec *codec)

2293

static int patch_alc882(struct hda_codec *codec)

2294

{

2294

{

2295

struct alc_spec *spec;

2295

struct alc_spec *spec;

2296

int err;

2296

int err;

2297

2298

err = alc_alloc_spec(codec, 0x0b);

2298

err = alc_alloc_spec(codec, 0x0b);

2299

if (err < 0)

2299

if (err < 0)

2300

return err;

2300

return err;

2301

2302

spec = codec->spec;

2302

spec = codec->spec;

2303

2304

switch (codec->core.vendor_id) {

2304

switch (codec->core.vendor_id) {

2305

case 0x10ec0882:

2305

case 0x10ec0882:

2306

case 0x10ec0885:

2306

case 0x10ec0885:

2307

case 0x10ec0900:

2307

case 0x10ec0900:

2308

break;

2308

break;

2309

default:

2309

default:

2310

/* ALC883 and variants */

2310

/* ALC883 and variants */

2311

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2311

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2312

break;

2312

break;

2313

}

2313

}

2314

2315

snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,

2315

snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,

2316

alc882_fixups);

2316

alc882_fixups);

2317

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2317

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2318

2319

alc_auto_parse_customize_define(codec);

2319

alc_auto_parse_customize_define(codec);

2320

2321

if (has_cdefine_beep(codec))

2321

if (has_cdefine_beep(codec))

2322

spec->gen.beep_nid = 0x01;

2322

spec->gen.beep_nid = 0x01;

2323

2324

/* automatic parse from the BIOS config */

2324

/* automatic parse from the BIOS config */

2325

err = alc882_parse_auto_config(codec);

2325

err = alc882_parse_auto_config(codec);

2326

if (err < 0)

2326

if (err < 0)

2327

goto error;

2327

goto error;

2328

2329

if (!spec->gen.no_analog && spec->gen.beep_nid)

2329

if (!spec->gen.no_analog && spec->gen.beep_nid)

2330

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

2330

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

2331

2332

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2332

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2333

2334

return 0;

2334

return 0;

2335

2336

error:

2336

error:

2337

alc_free(codec);

2337

alc_free(codec);

2338

return err;

2338

return err;

2339

}

2339

}

2340

2341

2342

/*

2342

/*

2343

* ALC262 support

2343

* ALC262 support

2344

*/

2344

*/

2345

static int alc262_parse_auto_config(struct hda_codec *codec)

2345

static int alc262_parse_auto_config(struct hda_codec *codec)

2346

{

2346

{

2347

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

2347

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

2348

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

2348

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

2349

return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);

2349

return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);

2350

}

2350

}

2351

2352

/*

2352

/*

2353

* Pin config fixes

2353

* Pin config fixes

2354

*/

2354

*/

2355

enum {

2355

enum {

2356

ALC262_FIXUP_FSC_H270,

2356

ALC262_FIXUP_FSC_H270,

2357

ALC262_FIXUP_FSC_S7110,

2357

ALC262_FIXUP_FSC_S7110,

2358

ALC262_FIXUP_HP_Z200,

2358

ALC262_FIXUP_HP_Z200,

2359

ALC262_FIXUP_TYAN,

2359

ALC262_FIXUP_TYAN,

2360

ALC262_FIXUP_LENOVO_3000,

2360

ALC262_FIXUP_LENOVO_3000,

2361

ALC262_FIXUP_BENQ,

2361

ALC262_FIXUP_BENQ,

2362

ALC262_FIXUP_BENQ_T31,

2362

ALC262_FIXUP_BENQ_T31,

2363

ALC262_FIXUP_INV_DMIC,

2363

ALC262_FIXUP_INV_DMIC,

2364

ALC262_FIXUP_INTEL_BAYLEYBAY,

2364

ALC262_FIXUP_INTEL_BAYLEYBAY,

2365

};

2365

};

2366

2367

static const struct hda_fixup alc262_fixups[] = {

2367

static const struct hda_fixup alc262_fixups[] = {

2368

[ALC262_FIXUP_FSC_H270] = {

2368

[ALC262_FIXUP_FSC_H270] = {

2369

.type = HDA_FIXUP_PINS,

2369

.type = HDA_FIXUP_PINS,

2370

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

2370

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

2371

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

2371

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

2372

{ 0x15, 0x0221142f }, /* front HP */

2372

{ 0x15, 0x0221142f }, /* front HP */

2373

{ 0x1b, 0x0121141f }, /* rear HP */

2373

{ 0x1b, 0x0121141f }, /* rear HP */

2374

{ }

2374

{ }

2375

}

2375

}

2376

},

2376

},

2377

[ALC262_FIXUP_FSC_S7110] = {

2377

[ALC262_FIXUP_FSC_S7110] = {

2378

.type = HDA_FIXUP_PINS,

2378

.type = HDA_FIXUP_PINS,

2379

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

2379

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

2380

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

2380

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

2381

{ }

2381

{ }

2382

},

2382

},

2383

.chained = true,

2383

.chained = true,

2384

.chain_id = ALC262_FIXUP_BENQ,

2384

.chain_id = ALC262_FIXUP_BENQ,

2385

},

2385

},

2386

[ALC262_FIXUP_HP_Z200] = {

2386

[ALC262_FIXUP_HP_Z200] = {

2387

.type = HDA_FIXUP_PINS,

2387

.type = HDA_FIXUP_PINS,

2388

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

2388

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

2389

{ 0x16, 0x99130120 }, /* internal speaker */

2389

{ 0x16, 0x99130120 }, /* internal speaker */

2390

{ }

2390

{ }

2391

}

2391

}

2392

},

2392

},

2393

[ALC262_FIXUP_TYAN] = {

2393

[ALC262_FIXUP_TYAN] = {

2394

.type = HDA_FIXUP_PINS,

2394

.type = HDA_FIXUP_PINS,

2395

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

2395

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

2396

{ 0x14, 0x1993e1f0 }, /* int AUX */

2396

{ 0x14, 0x1993e1f0 }, /* int AUX */

2397

{ }

2397

{ }

2398

}

2398

}

2399

},

2399

},

2400

[ALC262_FIXUP_LENOVO_3000] = {

2400

[ALC262_FIXUP_LENOVO_3000] = {

2401

.type = HDA_FIXUP_PINCTLS,

2401

.type = HDA_FIXUP_PINCTLS,

2402

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

2402

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

2403

{ 0x19, PIN_VREF50 },

2403

{ 0x19, PIN_VREF50 },

2404

{}

2404

{}

2405

},

2405

},

2406

.chained = true,

2406

.chained = true,

2407

.chain_id = ALC262_FIXUP_BENQ,

2407

.chain_id = ALC262_FIXUP_BENQ,

2408

},

2408

},

2409

[ALC262_FIXUP_BENQ] = {

2409

[ALC262_FIXUP_BENQ] = {

2410

.type = HDA_FIXUP_VERBS,

2410

.type = HDA_FIXUP_VERBS,

2411

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

2411

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

2412

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2412

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2413

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2413

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },

2414

{}

2414

{}

2415

}

2415

}

2416

},

2416

},

2417

[ALC262_FIXUP_BENQ_T31] = {

2417

[ALC262_FIXUP_BENQ_T31] = {

2418

.type = HDA_FIXUP_VERBS,

2418

.type = HDA_FIXUP_VERBS,

2419

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

2419

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

2420

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2420

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },

2421

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2421

{ 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },

2422

{}

2422

{}

2423

}

2423

}

2424

},

2424

},

2425

[ALC262_FIXUP_INV_DMIC] = {

2425

[ALC262_FIXUP_INV_DMIC] = {

2426

.type = HDA_FIXUP_FUNC,

2426

.type = HDA_FIXUP_FUNC,

2427

.v.func = alc_fixup_inv_dmic,

2427

.v.func = alc_fixup_inv_dmic,

2428

},

2428

},

2429

[ALC262_FIXUP_INTEL_BAYLEYBAY] = {

2429

[ALC262_FIXUP_INTEL_BAYLEYBAY] = {

2430

.type = HDA_FIXUP_FUNC,

2430

.type = HDA_FIXUP_FUNC,

2431

.v.func = alc_fixup_no_depop_delay,

2431

.v.func = alc_fixup_no_depop_delay,

2432

},

2432

},

2433

};

2433

};

2434

2435

static const struct snd_pci_quirk alc262_fixup_tbl[] = {

2435

static const struct snd_pci_quirk alc262_fixup_tbl[] = {

2436

SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),

2436

SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),

2437

SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),

2437

SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),

2438

SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),

2438

SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),

2439

SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),

2439

SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),

2440

SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),

2440

SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),

2441

SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),

2441

SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),

2442

SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),

2442

SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),

2443

SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),

2443

SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),

2444

SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),

2444

SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),

2445

{}

2445

{}

2446

};

2446

};

2447

2448

static const struct hda_model_fixup alc262_fixup_models[] = {

2448

static const struct hda_model_fixup alc262_fixup_models[] = {

2449

{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},

2449

{.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},

2450

{}

2450

{}

2451

};

2451

};

2452

2453

/*

2453

/*

2454

*/

2454

*/

2455

static int patch_alc262(struct hda_codec *codec)

2455

static int patch_alc262(struct hda_codec *codec)

2456

{

2456

{

2457

struct alc_spec *spec;

2457

struct alc_spec *spec;

2458

int err;

2458

int err;

2459

2460

err = alc_alloc_spec(codec, 0x0b);

2460

err = alc_alloc_spec(codec, 0x0b);

2461

if (err < 0)

2461

if (err < 0)

2462

return err;

2462

return err;

2463

2464

spec = codec->spec;

2464

spec = codec->spec;

2465

spec->gen.shared_mic_vref_pin = 0x18;

2465

spec->gen.shared_mic_vref_pin = 0x18;

2466

2467

spec->shutup = alc_eapd_shutup;

2467

spec->shutup = alc_eapd_shutup;

2468

2469

#if 0

2469

#if 0

2470

/* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is

2470

/* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is

2471

* under-run

2471

* under-run

2472

*/

2472

*/

2473

alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);

2473

alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);

2474

#endif

2474

#endif

2475

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2475

alc_fix_pll_init(codec, 0x20, 0x0a, 10);

2476

2477

snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,

2477

snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,

2478

alc262_fixups);

2478

alc262_fixups);

2479

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2479

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2480

2481

alc_auto_parse_customize_define(codec);

2481

alc_auto_parse_customize_define(codec);

2482

2483

if (has_cdefine_beep(codec))

2483

if (has_cdefine_beep(codec))

2484

spec->gen.beep_nid = 0x01;

2484

spec->gen.beep_nid = 0x01;

2485

2486

/* automatic parse from the BIOS config */

2486

/* automatic parse from the BIOS config */

2487

err = alc262_parse_auto_config(codec);

2487

err = alc262_parse_auto_config(codec);

2488

if (err < 0)

2488

if (err < 0)

2489

goto error;

2489

goto error;

2490

2491

if (!spec->gen.no_analog && spec->gen.beep_nid)

2491

if (!spec->gen.no_analog && spec->gen.beep_nid)

2492

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

2492

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

2493

2494

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2494

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2495

2496

return 0;

2496

return 0;

2497

2498

error:

2498

error:

2499

alc_free(codec);

2499

alc_free(codec);

2500

return err;

2500

return err;

2501

}

2501

}

2502

2503

/*

2503

/*

2504

* ALC268

2504

* ALC268

2505

*/

2505

*/

2506

/* bind Beep switches of both NID 0x0f and 0x10 */

2506

/* bind Beep switches of both NID 0x0f and 0x10 */

2507

static const struct hda_bind_ctls alc268_bind_beep_sw = {

2507

static const struct hda_bind_ctls alc268_bind_beep_sw = {

2508

.ops = &snd_hda_bind_sw,

2508

.ops = &snd_hda_bind_sw,

2509

.values = {

2509

.values = {

2510

HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),

2510

HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),

2511

HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),

2511

HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),

2512

0

2512

0

2513

},

2513

},

2514

};

2514

};

2515

2516

static const struct snd_kcontrol_new alc268_beep_mixer[] = {

2516

static const struct snd_kcontrol_new alc268_beep_mixer[] = {

2517

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

2517

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

2518

HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),

2518

HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),

2519

{ }

2519

{ }

2520

};

2520

};

2521

2522

/* set PCBEEP vol = 0, mute connections */

2522

/* set PCBEEP vol = 0, mute connections */

2523

static const struct hda_verb alc268_beep_init_verbs[] = {

2523

static const struct hda_verb alc268_beep_init_verbs[] = {

2524

{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},

2524

{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},

2525

{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2525

{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2526

{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2526

{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},

2527

{ }

2527

{ }

2528

};

2528

};

2529

2530

enum {

2530

enum {

2531

ALC268_FIXUP_INV_DMIC,

2531

ALC268_FIXUP_INV_DMIC,

2532

ALC268_FIXUP_HP_EAPD,

2532

ALC268_FIXUP_HP_EAPD,

2533

ALC268_FIXUP_SPDIF,

2533

ALC268_FIXUP_SPDIF,

2534

};

2534

};

2535

2536

static const struct hda_fixup alc268_fixups[] = {

2536

static const struct hda_fixup alc268_fixups[] = {

2537

[ALC268_FIXUP_INV_DMIC] = {

2537

[ALC268_FIXUP_INV_DMIC] = {

2538

.type = HDA_FIXUP_FUNC,

2538

.type = HDA_FIXUP_FUNC,

2539

.v.func = alc_fixup_inv_dmic,

2539

.v.func = alc_fixup_inv_dmic,

2540

},

2540

},

2541

[ALC268_FIXUP_HP_EAPD] = {

2541

[ALC268_FIXUP_HP_EAPD] = {

2542

.type = HDA_FIXUP_VERBS,

2542

.type = HDA_FIXUP_VERBS,

2543

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

2543

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

2544

{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},

2544

{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},

2545

{}

2545

{}

2546

}

2546

}

2547

},

2547

},

2548

[ALC268_FIXUP_SPDIF] = {

2548

[ALC268_FIXUP_SPDIF] = {

2549

.type = HDA_FIXUP_PINS,

2549

.type = HDA_FIXUP_PINS,

2550

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

2550

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

2551

{ 0x1e, 0x014b1180 }, /* enable SPDIF out */

2551

{ 0x1e, 0x014b1180 }, /* enable SPDIF out */

2552

{}

2552

{}

2553

}

2553

}

2554

},

2554

},

2555

};

2555

};

2556

2557

static const struct hda_model_fixup alc268_fixup_models[] = {

2557

static const struct hda_model_fixup alc268_fixup_models[] = {

2558

{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},

2558

{.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},

2559

{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},

2559

{.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},

2560

{}

2560

{}

2561

};

2561

};

2562

2563

static const struct snd_pci_quirk alc268_fixup_tbl[] = {

2563

static const struct snd_pci_quirk alc268_fixup_tbl[] = {

2564

SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),

2564

SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),

2565

SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),

2565

SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),

2566

/* below is codec SSID since multiple Toshiba laptops have the

2566

/* below is codec SSID since multiple Toshiba laptops have the

2567

* same PCI SSID 1179:ff00

2567

* same PCI SSID 1179:ff00

2568

*/

2568

*/

2569

SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),

2569

SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),

2570

{}

2570

{}

2571

};

2571

};

2572

2573

/*

2573

/*

2574

* BIOS auto configuration

2574

* BIOS auto configuration

2575

*/

2575

*/

2576

static int alc268_parse_auto_config(struct hda_codec *codec)

2576

static int alc268_parse_auto_config(struct hda_codec *codec)

2577

{

2577

{

2578

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

2578

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

2579

return alc_parse_auto_config(codec, NULL, alc268_ssids);

2579

return alc_parse_auto_config(codec, NULL, alc268_ssids);

2580

}

2580

}

2581

2582

/*

2582

/*

2583

*/

2583

*/

2584

static int patch_alc268(struct hda_codec *codec)

2584

static int patch_alc268(struct hda_codec *codec)

2585

{

2585

{

2586

struct alc_spec *spec;

2586

struct alc_spec *spec;

2587

int err;

2587

int err;

2588

2589

/* ALC268 has no aa-loopback mixer */

2589

/* ALC268 has no aa-loopback mixer */

2590

err = alc_alloc_spec(codec, 0);

2590

err = alc_alloc_spec(codec, 0);

2591

if (err < 0)

2591

if (err < 0)

2592

return err;

2592

return err;

2593

2594

spec = codec->spec;

2594

spec = codec->spec;

2595

spec->gen.beep_nid = 0x01;

2595

spec->gen.beep_nid = 0x01;

2596

2597

spec->shutup = alc_eapd_shutup;

2597

spec->shutup = alc_eapd_shutup;

2598

2599

snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);

2599

snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);

2600

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2600

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

2601

2602

/* automatic parse from the BIOS config */

2602

/* automatic parse from the BIOS config */

2603

err = alc268_parse_auto_config(codec);

2603

err = alc268_parse_auto_config(codec);

2604

if (err < 0)

2604

if (err < 0)

2605

goto error;

2605

goto error;

2606

2607

if (err > 0 && !spec->gen.no_analog &&

2607

if (err > 0 && !spec->gen.no_analog &&

2608

spec->gen.autocfg.speaker_pins[0] != 0x1d) {

2608

spec->gen.autocfg.speaker_pins[0] != 0x1d) {

2609

add_mixer(spec, alc268_beep_mixer);

2609

add_mixer(spec, alc268_beep_mixer);

2610

snd_hda_add_verbs(codec, alc268_beep_init_verbs);

2610

snd_hda_add_verbs(codec, alc268_beep_init_verbs);

2611

if (!query_amp_caps(codec, 0x1d, HDA_INPUT))

2611

if (!query_amp_caps(codec, 0x1d, HDA_INPUT))

2612

/* override the amp caps for beep generator */

2612

/* override the amp caps for beep generator */

2613

snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,

2613

snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,

2614

(0x0c << AC_AMPCAP_OFFSET_SHIFT) |

2614

(0x0c << AC_AMPCAP_OFFSET_SHIFT) |

2615

(0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |

2615

(0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |

2616

(0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |

2616

(0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |

2617

(0 << AC_AMPCAP_MUTE_SHIFT));

2617

(0 << AC_AMPCAP_MUTE_SHIFT));

2618

}

2618

}

2619

2620

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2620

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

2621

2622

return 0;

2622

return 0;

2623

2624

error:

2624

error:

2625

alc_free(codec);

2625

alc_free(codec);

2626

return err;

2626

return err;

2627

}

2627

}

2628

2629

/*

2629

/*

2630

* ALC269

2630

* ALC269

2631

*/

2631

*/

2632

2633

static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {

2633

static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {

2634

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2634

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2635

};

2635

};

2636

2637

static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {

2637

static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {

2638

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2638

.rates = SNDRV_PCM_RATE_44100, /* fixed rate */

2639

};

2639

};

2640

2641

/* different alc269-variants */

2641

/* different alc269-variants */

2642

enum {

2642

enum {

2643

ALC269_TYPE_ALC269VA,

2643

ALC269_TYPE_ALC269VA,

2644

ALC269_TYPE_ALC269VB,

2644

ALC269_TYPE_ALC269VB,

2645

ALC269_TYPE_ALC269VC,

2645

ALC269_TYPE_ALC269VC,

2646

ALC269_TYPE_ALC269VD,

2646

ALC269_TYPE_ALC269VD,

2647

ALC269_TYPE_ALC280,

2647

ALC269_TYPE_ALC280,

2648

ALC269_TYPE_ALC282,

2648

ALC269_TYPE_ALC282,

2649

ALC269_TYPE_ALC283,

2649

ALC269_TYPE_ALC283,

2650

ALC269_TYPE_ALC284,

2650

ALC269_TYPE_ALC284,

2651

ALC269_TYPE_ALC285,

2651

ALC269_TYPE_ALC285,

2652

ALC269_TYPE_ALC286,

2652

ALC269_TYPE_ALC286,

2653

ALC269_TYPE_ALC298,

2653

ALC269_TYPE_ALC298,

2654

ALC269_TYPE_ALC255,

2654

ALC269_TYPE_ALC255,

2655

ALC269_TYPE_ALC256,

2655

ALC269_TYPE_ALC256,

2656

ALC269_TYPE_ALC225,

2656

ALC269_TYPE_ALC225,

2657

ALC269_TYPE_ALC294,

2657

ALC269_TYPE_ALC294,

2658

};

2658

};

2659

2660

/*

2660

/*

2661

* BIOS auto configuration

2661

* BIOS auto configuration

2662

*/

2662

*/

2663

static int alc269_parse_auto_config(struct hda_codec *codec)

2663

static int alc269_parse_auto_config(struct hda_codec *codec)

2664

{

2664

{

2665

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

2665

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

2666

static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };

2666

static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };

2667

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

2667

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

2668

struct alc_spec *spec = codec->spec;

2668

struct alc_spec *spec = codec->spec;

2669

const hda_nid_t *ssids;

2669

const hda_nid_t *ssids;

2670

2671

switch (spec->codec_variant) {

2671

switch (spec->codec_variant) {

2672

case ALC269_TYPE_ALC269VA:

2672

case ALC269_TYPE_ALC269VA:

2673

case ALC269_TYPE_ALC269VC:

2673

case ALC269_TYPE_ALC269VC:

2674

case ALC269_TYPE_ALC280:

2674

case ALC269_TYPE_ALC280:

2675

case ALC269_TYPE_ALC284:

2675

case ALC269_TYPE_ALC284:

2676

case ALC269_TYPE_ALC285:

2676

case ALC269_TYPE_ALC285:

2677

ssids = alc269va_ssids;

2677

ssids = alc269va_ssids;

2678

break;

2678

break;

2679

case ALC269_TYPE_ALC269VB:

2679

case ALC269_TYPE_ALC269VB:

2680

case ALC269_TYPE_ALC269VD:

2680

case ALC269_TYPE_ALC269VD:

2681

case ALC269_TYPE_ALC282:

2681

case ALC269_TYPE_ALC282:

2682

case ALC269_TYPE_ALC283:

2682

case ALC269_TYPE_ALC283:

2683

case ALC269_TYPE_ALC286:

2683

case ALC269_TYPE_ALC286:

2684

case ALC269_TYPE_ALC298:

2684

case ALC269_TYPE_ALC298:

2685

case ALC269_TYPE_ALC255:

2685

case ALC269_TYPE_ALC255:

2686

case ALC269_TYPE_ALC256:

2686

case ALC269_TYPE_ALC256:

2687

case ALC269_TYPE_ALC225:

2687

case ALC269_TYPE_ALC225:

2688

case ALC269_TYPE_ALC294:

2688

case ALC269_TYPE_ALC294:

2689

ssids = alc269_ssids;

2689

ssids = alc269_ssids;

2690

break;

2690

break;

2691

default:

2691

default:

2692

ssids = alc269_ssids;

2692

ssids = alc269_ssids;

2693

break;

2693

break;

2694

}

2694

}

2695

2696

return alc_parse_auto_config(codec, alc269_ignore, ssids);

2696

return alc_parse_auto_config(codec, alc269_ignore, ssids);

2697

}

2697

}

2698

2699

static int find_ext_mic_pin(struct hda_codec *codec);

2699

static int find_ext_mic_pin(struct hda_codec *codec);

2700

2701

static void alc286_shutup(struct hda_codec *codec)

2701

static void alc286_shutup(struct hda_codec *codec)

2702

{

2702

{

2703

int i;

2703

int i;

2704

int mic_pin = find_ext_mic_pin(codec);

2704

int mic_pin = find_ext_mic_pin(codec);

2705

/* don't shut up pins when unloading the driver; otherwise it breaks

2705

/* don't shut up pins when unloading the driver; otherwise it breaks

2706

* the default pin setup at the next load of the driver

2706

* the default pin setup at the next load of the driver

2707

*/

2707

*/

2708

if (codec->bus->shutdown)

2708

if (codec->bus->shutdown)

2709

return;

2709

return;

2710

for (i = 0; i < codec->init_pins.used; i++) {

2710

for (i = 0; i < codec->init_pins.used; i++) {

2711

struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);

2711

struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);

2712

/* use read here for syncing after issuing each verb */

2712

/* use read here for syncing after issuing each verb */

2713

if (pin->nid != mic_pin)

2713

if (pin->nid != mic_pin)

2714

snd_hda_codec_read(codec, pin->nid, 0,

2714

snd_hda_codec_read(codec, pin->nid, 0,

2715

AC_VERB_SET_PIN_WIDGET_CONTROL, 0);

2715

AC_VERB_SET_PIN_WIDGET_CONTROL, 0);

2716

}

2716

}

2717

codec->pins_shutup = 1;

2717

codec->pins_shutup = 1;

2718

}

2718

}

2719

2720

static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)

2720

static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)

2721

{

2721

{

2722

alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);

2722

alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);

2723

}

2723

}

2724

2725

static void alc269_shutup(struct hda_codec *codec)

2725

static void alc269_shutup(struct hda_codec *codec)

2726

{

2726

{

2727

struct alc_spec *spec = codec->spec;

2727

struct alc_spec *spec = codec->spec;

2728

2729

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

2729

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

2730

alc269vb_toggle_power_output(codec, 0);

2730

alc269vb_toggle_power_output(codec, 0);

2731

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

2731

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

2732

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

2732

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

2733

msleep(150);

2733

msleep(150);

2734

}

2734

}

2735

snd_hda_shutup_pins(codec);

2735

snd_hda_shutup_pins(codec);

2736

}

2736

}

2737

2738

static struct coef_fw alc282_coefs[] = {

2738

static struct coef_fw alc282_coefs[] = {

2739

WRITE_COEF(0x03, 0x0002), /* Power Down Control */

2739

WRITE_COEF(0x03, 0x0002), /* Power Down Control */

2740

UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */

2740

UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */

2741

WRITE_COEF(0x07, 0x0200), /* DMIC control */

2741

WRITE_COEF(0x07, 0x0200), /* DMIC control */

2742

UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */

2742

UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */

2743

UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */

2743

UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */

2744

WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */

2744

WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */

2745

WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */

2745

WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */

2746

WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */

2746

WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */

2747

UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */

2747

UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */

2748

UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */

2748

UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */

2749

WRITE_COEF(0x6f, 0x0), /* Class D test 4 */

2749

WRITE_COEF(0x6f, 0x0), /* Class D test 4 */

2750

UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */

2750

UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */

2751

WRITE_COEF(0x34, 0xa0c0), /* ANC */

2751

WRITE_COEF(0x34, 0xa0c0), /* ANC */

2752

UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */

2752

UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */

2753

UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */

2753

UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */

2754

UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */

2754

UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */

2755

WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */

2755

WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */

2756

WRITE_COEF(0x63, 0x2902), /* PLL */

2756

WRITE_COEF(0x63, 0x2902), /* PLL */

2757

WRITE_COEF(0x68, 0xa080), /* capless control 2 */

2757

WRITE_COEF(0x68, 0xa080), /* capless control 2 */

2758

WRITE_COEF(0x69, 0x3400), /* capless control 3 */

2758

WRITE_COEF(0x69, 0x3400), /* capless control 3 */

2759

WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */

2759

WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */

2760

WRITE_COEF(0x6b, 0x0), /* capless control 5 */

2760

WRITE_COEF(0x6b, 0x0), /* capless control 5 */

2761

UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */

2761

UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */

2762

WRITE_COEF(0x6e, 0x110a), /* class D test 3 */

2762

WRITE_COEF(0x6e, 0x110a), /* class D test 3 */

2763

UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */

2763

UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */

2764

WRITE_COEF(0x71, 0x0014), /* class D test 6 */

2764

WRITE_COEF(0x71, 0x0014), /* class D test 6 */

2765

WRITE_COEF(0x72, 0xc2ba), /* classD OCP */

2765

WRITE_COEF(0x72, 0xc2ba), /* classD OCP */

2766

UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */

2766

UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */

2767

WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */

2767

WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */

2768

{}

2768

{}

2769

};

2769

};

2770

2771

static void alc282_restore_default_value(struct hda_codec *codec)

2771

static void alc282_restore_default_value(struct hda_codec *codec)

2772

{

2772

{

2773

alc_process_coef_fw(codec, alc282_coefs);

2773

alc_process_coef_fw(codec, alc282_coefs);

2774

}

2774

}

2775

2776

static void alc282_init(struct hda_codec *codec)

2776

static void alc282_init(struct hda_codec *codec)

2777

{

2777

{

2778

struct alc_spec *spec = codec->spec;

2778

struct alc_spec *spec = codec->spec;

2779

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

2779

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

2780

bool hp_pin_sense;

2780

bool hp_pin_sense;

2781

int coef78;

2781

int coef78;

2782

2783

alc282_restore_default_value(codec);

2783

alc282_restore_default_value(codec);

2784

2785

if (!hp_pin)

2785

if (!hp_pin)

2786

return;

2786

return;

2787

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2787

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2788

coef78 = alc_read_coef_idx(codec, 0x78);

2788

coef78 = alc_read_coef_idx(codec, 0x78);

2789

2790

/* Index 0x78 Direct Drive HP AMP LPM Control 1 */

2790

/* Index 0x78 Direct Drive HP AMP LPM Control 1 */

2791

/* Headphone capless set to high power mode */

2791

/* Headphone capless set to high power mode */

2792

alc_write_coef_idx(codec, 0x78, 0x9004);

2792

alc_write_coef_idx(codec, 0x78, 0x9004);

2793

2794

if (hp_pin_sense)

2794

if (hp_pin_sense)

2795

msleep(2);

2795

msleep(2);

2796

2797

snd_hda_codec_write(codec, hp_pin, 0,

2797

snd_hda_codec_write(codec, hp_pin, 0,

2798

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2798

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2799

2800

if (hp_pin_sense)

2800

if (hp_pin_sense)

2801

msleep(85);

2801

msleep(85);

2802

2803

snd_hda_codec_write(codec, hp_pin, 0,

2803

snd_hda_codec_write(codec, hp_pin, 0,

2804

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2804

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2805

2806

if (hp_pin_sense)

2806

if (hp_pin_sense)

2807

msleep(100);

2807

msleep(100);

2808

2809

/* Headphone capless set to normal mode */

2809

/* Headphone capless set to normal mode */

2810

alc_write_coef_idx(codec, 0x78, coef78);

2810

alc_write_coef_idx(codec, 0x78, coef78);

2811

}

2811

}

2812

2813

static void alc282_shutup(struct hda_codec *codec)

2813

static void alc282_shutup(struct hda_codec *codec)

2814

{

2814

{

2815

struct alc_spec *spec = codec->spec;

2815

struct alc_spec *spec = codec->spec;

2816

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

2816

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

2817

bool hp_pin_sense;

2817

bool hp_pin_sense;

2818

int coef78;

2818

int coef78;

2819

2820

if (!hp_pin) {

2820

if (!hp_pin) {

2821

alc269_shutup(codec);

2821

alc269_shutup(codec);

2822

return;

2822

return;

2823

}

2823

}

2824

2825

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2825

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2826

coef78 = alc_read_coef_idx(codec, 0x78);

2826

coef78 = alc_read_coef_idx(codec, 0x78);

2827

alc_write_coef_idx(codec, 0x78, 0x9004);

2827

alc_write_coef_idx(codec, 0x78, 0x9004);

2828

2829

if (hp_pin_sense)

2829

if (hp_pin_sense)

2830

msleep(2);

2830

msleep(2);

2831

2832

snd_hda_codec_write(codec, hp_pin, 0,

2832

snd_hda_codec_write(codec, hp_pin, 0,

2833

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2833

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2834

2835

if (hp_pin_sense)

2835

if (hp_pin_sense)

2836

msleep(85);

2836

msleep(85);

2837

2838

snd_hda_codec_write(codec, hp_pin, 0,

2838

snd_hda_codec_write(codec, hp_pin, 0,

2839

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2839

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2840

2841

if (hp_pin_sense)

2841

if (hp_pin_sense)

2842

msleep(100);

2842

msleep(100);

2843

2844

alc_auto_setup_eapd(codec, false);

2844

alc_auto_setup_eapd(codec, false);

2845

snd_hda_shutup_pins(codec);

2845

snd_hda_shutup_pins(codec);

2846

alc_write_coef_idx(codec, 0x78, coef78);

2846

alc_write_coef_idx(codec, 0x78, coef78);

2847

}

2847

}

2848

2849

static struct coef_fw alc283_coefs[] = {

2849

static struct coef_fw alc283_coefs[] = {

2850

WRITE_COEF(0x03, 0x0002), /* Power Down Control */

2850

WRITE_COEF(0x03, 0x0002), /* Power Down Control */

2851

UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */

2851

UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */

2852

WRITE_COEF(0x07, 0x0200), /* DMIC control */

2852

WRITE_COEF(0x07, 0x0200), /* DMIC control */

2853

UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */

2853

UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */

2854

UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */

2854

UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */

2855

WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */

2855

WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */

2856

WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */

2856

WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */

2857

WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */

2857

WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */

2858

UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */

2858

UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */

2859

UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */

2859

UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */

2860

WRITE_COEF(0x3a, 0x0), /* Class D test 4 */

2860

WRITE_COEF(0x3a, 0x0), /* Class D test 4 */

2861

UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */

2861

UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */

2862

WRITE_COEF(0x22, 0xa0c0), /* ANC */

2862

WRITE_COEF(0x22, 0xa0c0), /* ANC */

2863

UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */

2863

UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */

2864

UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */

2864

UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */

2865

UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */

2865

UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */

2866

WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */

2866

WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */

2867

WRITE_COEF(0x2e, 0x2902), /* PLL */

2867

WRITE_COEF(0x2e, 0x2902), /* PLL */

2868

WRITE_COEF(0x33, 0xa080), /* capless control 2 */

2868

WRITE_COEF(0x33, 0xa080), /* capless control 2 */

2869

WRITE_COEF(0x34, 0x3400), /* capless control 3 */

2869

WRITE_COEF(0x34, 0x3400), /* capless control 3 */

2870

WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */

2870

WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */

2871

WRITE_COEF(0x36, 0x0), /* capless control 5 */

2871

WRITE_COEF(0x36, 0x0), /* capless control 5 */

2872

UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */

2872

UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */

2873

WRITE_COEF(0x39, 0x110a), /* class D test 3 */

2873

WRITE_COEF(0x39, 0x110a), /* class D test 3 */

2874

UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */

2874

UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */

2875

WRITE_COEF(0x3c, 0x0014), /* class D test 6 */

2875

WRITE_COEF(0x3c, 0x0014), /* class D test 6 */

2876

WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */

2876

WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */

2877

UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */

2877

UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */

2878

WRITE_COEF(0x49, 0x0), /* test mode */

2878

WRITE_COEF(0x49, 0x0), /* test mode */

2879

UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */

2879

UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */

2880

UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */

2880

UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */

2881

WRITE_COEF(0x37, 0xfc06), /* Class D amp control */

2881

WRITE_COEF(0x37, 0xfc06), /* Class D amp control */

2882

UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */

2882

UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */

2883

{}

2883

{}

2884

};

2884

};

2885

2886

static void alc283_restore_default_value(struct hda_codec *codec)

2886

static void alc283_restore_default_value(struct hda_codec *codec)

2887

{

2887

{

2888

alc_process_coef_fw(codec, alc283_coefs);

2888

alc_process_coef_fw(codec, alc283_coefs);

2889

}

2889

}

2890

2891

static void alc283_init(struct hda_codec *codec)

2891

static void alc283_init(struct hda_codec *codec)

2892

{

2892

{

2893

struct alc_spec *spec = codec->spec;

2893

struct alc_spec *spec = codec->spec;

2894

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

2894

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

2895

bool hp_pin_sense;

2895

bool hp_pin_sense;

2896

2897

if (!spec->gen.autocfg.hp_outs) {

2897

if (!spec->gen.autocfg.hp_outs) {

2898

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

2898

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

2899

hp_pin = spec->gen.autocfg.line_out_pins[0];

2899

hp_pin = spec->gen.autocfg.line_out_pins[0];

2900

}

2900

}

2901

2902

alc283_restore_default_value(codec);

2902

alc283_restore_default_value(codec);

2903

2904

if (!hp_pin)

2904

if (!hp_pin)

2905

return;

2905

return;

2906

2907

msleep(30);

2907

msleep(30);

2908

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2908

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2909

2910

/* Index 0x43 Direct Drive HP AMP LPM Control 1 */

2910

/* Index 0x43 Direct Drive HP AMP LPM Control 1 */

2911

/* Headphone capless set to high power mode */

2911

/* Headphone capless set to high power mode */

2912

alc_write_coef_idx(codec, 0x43, 0x9004);

2912

alc_write_coef_idx(codec, 0x43, 0x9004);

2913

2914

snd_hda_codec_write(codec, hp_pin, 0,

2914

snd_hda_codec_write(codec, hp_pin, 0,

2915

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2915

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2916

2917

if (hp_pin_sense)

2917

if (hp_pin_sense)

2918

msleep(85);

2918

msleep(85);

2919

2920

snd_hda_codec_write(codec, hp_pin, 0,

2920

snd_hda_codec_write(codec, hp_pin, 0,

2921

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2921

AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

2922

2923

if (hp_pin_sense)

2923

if (hp_pin_sense)

2924

msleep(85);

2924

msleep(85);

2925

/* Index 0x46 Combo jack auto switch control 2 */

2925

/* Index 0x46 Combo jack auto switch control 2 */

2926

/* 3k pull low control for Headset jack. */

2926

/* 3k pull low control for Headset jack. */

2927

alc_update_coef_idx(codec, 0x46, 3 << 12, 0);

2927

alc_update_coef_idx(codec, 0x46, 3 << 12, 0);

2928

/* Headphone capless set to normal mode */

2928

/* Headphone capless set to normal mode */

2929

alc_write_coef_idx(codec, 0x43, 0x9614);

2929

alc_write_coef_idx(codec, 0x43, 0x9614);

2930

}

2930

}

2931

2932

static void alc283_shutup(struct hda_codec *codec)

2932

static void alc283_shutup(struct hda_codec *codec)

2933

{

2933

{

2934

struct alc_spec *spec = codec->spec;

2934

struct alc_spec *spec = codec->spec;

2935

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

2935

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

2936

bool hp_pin_sense;

2936

bool hp_pin_sense;

2937

2938

if (!spec->gen.autocfg.hp_outs) {

2938

if (!spec->gen.autocfg.hp_outs) {

2939

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

2939

if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)

2940

hp_pin = spec->gen.autocfg.line_out_pins[0];

2940

hp_pin = spec->gen.autocfg.line_out_pins[0];

2941

}

2941

}

2942

2943

if (!hp_pin) {

2943

if (!hp_pin) {

2944

alc269_shutup(codec);

2944

alc269_shutup(codec);

2945

return;

2945

return;

2946

}

2946

}

2947

2948

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2948

hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);

2949

2950

alc_write_coef_idx(codec, 0x43, 0x9004);

2950

alc_write_coef_idx(codec, 0x43, 0x9004);

2951

2952

/*depop hp during suspend*/

2952

/*depop hp during suspend*/

2953

alc_write_coef_idx(codec, 0x06, 0x2100);

2953

alc_write_coef_idx(codec, 0x06, 0x2100);

2954

2955

snd_hda_codec_write(codec, hp_pin, 0,

2955

snd_hda_codec_write(codec, hp_pin, 0,

2956

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2956

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

2957

2958

if (hp_pin_sense)

2958

if (hp_pin_sense)

2959

msleep(100);

2959

msleep(100);

2960

2961

snd_hda_codec_write(codec, hp_pin, 0,

2961

snd_hda_codec_write(codec, hp_pin, 0,

2962

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2962

AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);

2963

2964

alc_update_coef_idx(codec, 0x46, 0, 3 << 12);

2964

alc_update_coef_idx(codec, 0x46, 0, 3 << 12);

2965

2966

if (hp_pin_sense)

2966

if (hp_pin_sense)

2967

msleep(100);

2967

msleep(100);

2968

alc_auto_setup_eapd(codec, false);

2968

alc_auto_setup_eapd(codec, false);

2969

snd_hda_shutup_pins(codec);

2969

snd_hda_shutup_pins(codec);

2970

alc_write_coef_idx(codec, 0x43, 0x9614);

2970

alc_write_coef_idx(codec, 0x43, 0x9614);

2971

}

2971

}

2972

2973

static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,

2973

static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,

2974

unsigned int val)

2974

unsigned int val)

2975

{

2975

{

2976

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

2976

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

2977

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */

2977

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */

2978

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */

2978

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */

2979

}

2979

}

2980

2981

static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)

2981

static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)

2982

{

2982

{

2983

unsigned int val;

2983

unsigned int val;

2984

2985

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

2985

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);

2986

val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

2986

val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

2987

& 0xffff;

2987

& 0xffff;

2988

val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

2988

val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)

2989

<< 16;

2989

<< 16;

2990

return val;

2990

return val;

2991

}

2991

}

2992

2993

static void alc5505_dsp_halt(struct hda_codec *codec)

2993

static void alc5505_dsp_halt(struct hda_codec *codec)

2994

{

2994

{

2995

unsigned int val;

2995

unsigned int val;

2996

2997

alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */

2997

alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */

2998

alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */

2998

alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */

2999

alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */

2999

alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */

3000

alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */

3000

alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */

3001

alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */

3001

alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */

3002

alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */

3002

alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */

3003

alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */

3003

alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */

3004

val = alc5505_coef_get(codec, 0x6220);

3004

val = alc5505_coef_get(codec, 0x6220);

3005

alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */

3005

alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */

3006

}

3006

}

3007

3008

static void alc5505_dsp_back_from_halt(struct hda_codec *codec)

3008

static void alc5505_dsp_back_from_halt(struct hda_codec *codec)

3009

{

3009

{

3010

alc5505_coef_set(codec, 0x61b8, 0x04133302);

3010

alc5505_coef_set(codec, 0x61b8, 0x04133302);

3011

alc5505_coef_set(codec, 0x61b0, 0x00005b16);

3011

alc5505_coef_set(codec, 0x61b0, 0x00005b16);

3012

alc5505_coef_set(codec, 0x61b4, 0x040a2b02);

3012

alc5505_coef_set(codec, 0x61b4, 0x040a2b02);

3013

alc5505_coef_set(codec, 0x6230, 0xf80d4011);

3013

alc5505_coef_set(codec, 0x6230, 0xf80d4011);

3014

alc5505_coef_set(codec, 0x6220, 0x2002010f);

3014

alc5505_coef_set(codec, 0x6220, 0x2002010f);

3015

alc5505_coef_set(codec, 0x880c, 0x00000004);

3015

alc5505_coef_set(codec, 0x880c, 0x00000004);

3016

}

3016

}

3017

3018

static void alc5505_dsp_init(struct hda_codec *codec)

3018

static void alc5505_dsp_init(struct hda_codec *codec)

3019

{

3019

{

3020

unsigned int val;

3020

unsigned int val;

3021

3022

alc5505_dsp_halt(codec);

3022

alc5505_dsp_halt(codec);

3023

alc5505_dsp_back_from_halt(codec);

3023

alc5505_dsp_back_from_halt(codec);

3024

alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */

3024

alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */

3025

alc5505_coef_set(codec, 0x61b0, 0x5b16);

3025

alc5505_coef_set(codec, 0x61b0, 0x5b16);

3026

alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */

3026

alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */

3027

alc5505_coef_set(codec, 0x61b4, 0x04132b02);

3027

alc5505_coef_set(codec, 0x61b4, 0x04132b02);

3028

alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/

3028

alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/

3029

alc5505_coef_set(codec, 0x61b8, 0x041f3302);

3029

alc5505_coef_set(codec, 0x61b8, 0x041f3302);

3030

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */

3030

snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */

3031

alc5505_coef_set(codec, 0x61b8, 0x041b3302);

3031

alc5505_coef_set(codec, 0x61b8, 0x041b3302);

3032

alc5505_coef_set(codec, 0x61b8, 0x04173302);

3032

alc5505_coef_set(codec, 0x61b8, 0x04173302);

3033

alc5505_coef_set(codec, 0x61b8, 0x04163302);

3033

alc5505_coef_set(codec, 0x61b8, 0x04163302);

3034

alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */

3034

alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */

3035

alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */

3035

alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */

3036

alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */

3036

alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */

3037

3038

val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */

3038

val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */

3039

if (val <= 3)

3039

if (val <= 3)

3040

alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */

3040

alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */

3041

else

3041

else

3042

alc5505_coef_set(codec, 0x6220, 0x6002018f);

3042

alc5505_coef_set(codec, 0x6220, 0x6002018f);

3043

3044

alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/

3044

alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/

3045

alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */

3045

alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */

3046

alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */

3046

alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */

3047

alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */

3047

alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */

3048

alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */

3048

alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */

3049

alc5505_coef_set(codec, 0x880c, 0x00000003);

3049

alc5505_coef_set(codec, 0x880c, 0x00000003);

3050

alc5505_coef_set(codec, 0x880c, 0x00000010);

3050

alc5505_coef_set(codec, 0x880c, 0x00000010);

3051

3052

#ifdef HALT_REALTEK_ALC5505

3052

#ifdef HALT_REALTEK_ALC5505

3053

alc5505_dsp_halt(codec);

3053

alc5505_dsp_halt(codec);

3054

#endif

3054

#endif

3055

}

3055

}

3056

3057

#ifdef HALT_REALTEK_ALC5505

3057

#ifdef HALT_REALTEK_ALC5505

3058

#define alc5505_dsp_suspend(codec) /* NOP */

3058

#define alc5505_dsp_suspend(codec) /* NOP */

3059

#define alc5505_dsp_resume(codec) /* NOP */

3059

#define alc5505_dsp_resume(codec) /* NOP */

3060

#else

3060

#else

3061

#define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)

3061

#define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)

3062

#define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)

3062

#define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)

3063

#endif

3063

#endif

3064

3065

#ifdef CONFIG_PM

3065

#ifdef CONFIG_PM

3066

static int alc269_suspend(struct hda_codec *codec)

3066

static int alc269_suspend(struct hda_codec *codec)

3067

{

3067

{

3068

struct alc_spec *spec = codec->spec;

3068

struct alc_spec *spec = codec->spec;

3069

3070

if (spec->has_alc5505_dsp)

3070

if (spec->has_alc5505_dsp)

3071

alc5505_dsp_suspend(codec);

3071

alc5505_dsp_suspend(codec);

3072

return alc_suspend(codec);

3072

return alc_suspend(codec);

3073

}

3073

}

3074

3075

static int alc269_resume(struct hda_codec *codec)

3075

static int alc269_resume(struct hda_codec *codec)

3076

{

3076

{

3077

struct alc_spec *spec = codec->spec;

3077

struct alc_spec *spec = codec->spec;

3078

3079

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3079

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3080

alc269vb_toggle_power_output(codec, 0);

3080

alc269vb_toggle_power_output(codec, 0);

3081

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3081

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3082

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

3082

(alc_get_coef0(codec) & 0x00ff) == 0x018) {

3083

msleep(150);

3083

msleep(150);

3084

}

3084

}

3085

3086

codec->patch_ops.init(codec);

3086

codec->patch_ops.init(codec);

3087

3088

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3088

if (spec->codec_variant == ALC269_TYPE_ALC269VB)

3089

alc269vb_toggle_power_output(codec, 1);

3089

alc269vb_toggle_power_output(codec, 1);

3090

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3090

if (spec->codec_variant == ALC269_TYPE_ALC269VB &&

3091

(alc_get_coef0(codec) & 0x00ff) == 0x017) {

3091

(alc_get_coef0(codec) & 0x00ff) == 0x017) {

3092

msleep(200);

3092

msleep(200);

3093

}

3093

}

3094

3095

regcache_sync(codec->core.regmap);

3095

regcache_sync(codec->core.regmap);

3096

hda_call_check_power_status(codec, 0x01);

3096

hda_call_check_power_status(codec, 0x01);

3097

3098

/* on some machine, the BIOS will clear the codec gpio data when enter

3098

/* on some machine, the BIOS will clear the codec gpio data when enter

3099

* suspend, and won't restore the data after resume, so we restore it

3099

* suspend, and won't restore the data after resume, so we restore it

3100

* in the driver.

3100

* in the driver.

3101

*/

3101

*/

3102

if (spec->gpio_led)

3102

if (spec->gpio_led)

3103

snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,

3103

snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,

3104

spec->gpio_led);

3104

spec->gpio_led);

3105

3106

if (spec->has_alc5505_dsp)

3106

if (spec->has_alc5505_dsp)

3107

alc5505_dsp_resume(codec);

3107

alc5505_dsp_resume(codec);

3108

3109

return 0;

3109

return 0;

3110

}

3110

}

3111

#endif /* CONFIG_PM */

3111

#endif /* CONFIG_PM */

3112

3113

static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,

3113

static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,

3114

const struct hda_fixup *fix, int action)

3114

const struct hda_fixup *fix, int action)

3115

{

3115

{

3116

struct alc_spec *spec = codec->spec;

3116

struct alc_spec *spec = codec->spec;

3117

3118

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3118

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3119

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

3119

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

3120

}

3120

}

3121

3122

static void alc269_fixup_hweq(struct hda_codec *codec,

3122

static void alc269_fixup_hweq(struct hda_codec *codec,

3123

const struct hda_fixup *fix, int action)

3123

const struct hda_fixup *fix, int action)

3124

{

3124

{

3125

if (action == HDA_FIXUP_ACT_INIT)

3125

if (action == HDA_FIXUP_ACT_INIT)

3126

alc_update_coef_idx(codec, 0x1e, 0, 0x80);

3126

alc_update_coef_idx(codec, 0x1e, 0, 0x80);

3127

}

3127

}

3128

3129

static void alc269_fixup_headset_mic(struct hda_codec *codec,

3129

static void alc269_fixup_headset_mic(struct hda_codec *codec,

3130

const struct hda_fixup *fix, int action)

3130

const struct hda_fixup *fix, int action)

3131

{

3131

{

3132

struct alc_spec *spec = codec->spec;

3132

struct alc_spec *spec = codec->spec;

3133

3134

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3134

if (action == HDA_FIXUP_ACT_PRE_PROBE)

3135

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3135

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3136

}

3136

}

3137

3138

static void alc271_fixup_dmic(struct hda_codec *codec,

3138

static void alc271_fixup_dmic(struct hda_codec *codec,

3139

const struct hda_fixup *fix, int action)

3139

const struct hda_fixup *fix, int action)

3140

{

3140

{

3141

static const struct hda_verb verbs[] = {

3141

static const struct hda_verb verbs[] = {

3142

{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},

3142

{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},

3143

{0x20, AC_VERB_SET_PROC_COEF, 0x4000},

3143

{0x20, AC_VERB_SET_PROC_COEF, 0x4000},

3144

{}

3144

{}

3145

};

3145

};

3146

unsigned int cfg;

3146

unsigned int cfg;

3147

3148

if (strcmp(codec->core.chip_name, "ALC271X") &&

3148

if (strcmp(codec->core.chip_name, "ALC271X") &&

3149

strcmp(codec->core.chip_name, "ALC269VB"))

3149

strcmp(codec->core.chip_name, "ALC269VB"))

3150

return;

3150

return;

3151

cfg = snd_hda_codec_get_pincfg(codec, 0x12);

3151

cfg = snd_hda_codec_get_pincfg(codec, 0x12);

3152

if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)

3152

if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)

3153

snd_hda_sequence_write(codec, verbs);

3153

snd_hda_sequence_write(codec, verbs);

3154

}

3154

}

3155

3156

static void alc269_fixup_pcm_44k(struct hda_codec *codec,

3156

static void alc269_fixup_pcm_44k(struct hda_codec *codec,

3157

const struct hda_fixup *fix, int action)

3157

const struct hda_fixup *fix, int action)

3158

{

3158

{

3159

struct alc_spec *spec = codec->spec;

3159

struct alc_spec *spec = codec->spec;

3160

3161

if (action != HDA_FIXUP_ACT_PROBE)

3161

if (action != HDA_FIXUP_ACT_PROBE)

3162

return;

3162

return;

3163

3164

/* Due to a hardware problem on Lenovo Ideadpad, we need to

3164

/* Due to a hardware problem on Lenovo Ideadpad, we need to

3165

* fix the sample rate of analog I/O to 44.1kHz

3165

* fix the sample rate of analog I/O to 44.1kHz

3166

*/

3166

*/

3167

spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;

3167

spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;

3168

spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;

3168

spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;

3169

}

3169

}

3170

3171

static void alc269_fixup_stereo_dmic(struct hda_codec *codec,

3171

static void alc269_fixup_stereo_dmic(struct hda_codec *codec,

3172

const struct hda_fixup *fix, int action)

3172

const struct hda_fixup *fix, int action)

3173

{

3173

{

3174

/* The digital-mic unit sends PDM (differential signal) instead of

3174

/* The digital-mic unit sends PDM (differential signal) instead of

3175

* the standard PCM, thus you can't record a valid mono stream as is.

3175

* the standard PCM, thus you can't record a valid mono stream as is.

3176

* Below is a workaround specific to ALC269 to control the dmic

3176

* Below is a workaround specific to ALC269 to control the dmic

3177

* signal source as mono.

3177

* signal source as mono.

3178

*/

3178

*/

3179

if (action == HDA_FIXUP_ACT_INIT)

3179

if (action == HDA_FIXUP_ACT_INIT)

3180

alc_update_coef_idx(codec, 0x07, 0, 0x80);

3180

alc_update_coef_idx(codec, 0x07, 0, 0x80);

3181

}

3181

}

3182

3183

static void alc269_quanta_automute(struct hda_codec *codec)

3183

static void alc269_quanta_automute(struct hda_codec *codec)

3184

{

3184

{

3185

snd_hda_gen_update_outputs(codec);

3185

snd_hda_gen_update_outputs(codec);

3186

3187

alc_write_coef_idx(codec, 0x0c, 0x680);

3187

alc_write_coef_idx(codec, 0x0c, 0x680);

3188

alc_write_coef_idx(codec, 0x0c, 0x480);

3188

alc_write_coef_idx(codec, 0x0c, 0x480);

3189

}

3189

}

3190

3191

static void alc269_fixup_quanta_mute(struct hda_codec *codec,

3191

static void alc269_fixup_quanta_mute(struct hda_codec *codec,

3192

const struct hda_fixup *fix, int action)

3192

const struct hda_fixup *fix, int action)

3193

{

3193

{

3194

struct alc_spec *spec = codec->spec;

3194

struct alc_spec *spec = codec->spec;

3195

if (action != HDA_FIXUP_ACT_PROBE)

3195

if (action != HDA_FIXUP_ACT_PROBE)

3196

return;

3196

return;

3197

spec->gen.automute_hook = alc269_quanta_automute;

3197

spec->gen.automute_hook = alc269_quanta_automute;

3198

}

3198

}

3199

3200

static void alc269_x101_hp_automute_hook(struct hda_codec *codec,

3200

static void alc269_x101_hp_automute_hook(struct hda_codec *codec,

3201

struct hda_jack_callback *jack)

3201

struct hda_jack_callback *jack)

3202

{

3202

{

3203

struct alc_spec *spec = codec->spec;

3203

struct alc_spec *spec = codec->spec;

3204

int vref;

3204

int vref;

3205

msleep(200);

3205

msleep(200);

3206

snd_hda_gen_hp_automute(codec, jack);

3206

snd_hda_gen_hp_automute(codec, jack);

3207

3208

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3208

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

3209

msleep(100);

3209

msleep(100);

3210

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3210

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3211

vref);

3211

vref);

3212

msleep(500);

3212

msleep(500);

3213

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3213

snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

3214

vref);

3214

vref);

3215

}

3215

}

3216

3217

static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,

3217

static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,

3218

const struct hda_fixup *fix, int action)

3218

const struct hda_fixup *fix, int action)

3219

{

3219

{

3220

struct alc_spec *spec = codec->spec;

3220

struct alc_spec *spec = codec->spec;

3221

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3221

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3222

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3222

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

3223

spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;

3223

spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;

3224

}

3224

}

3225

}

3225

}

3226

3227

3228

/* update mute-LED according to the speaker mute state via mic VREF pin */

3228

/* update mute-LED according to the speaker mute state via mic VREF pin */

3229

static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)

3229

static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)

3230

{

3230

{

3231

struct hda_codec *codec = private_data;

3231

struct hda_codec *codec = private_data;

3232

struct alc_spec *spec = codec->spec;

3232

struct alc_spec *spec = codec->spec;

3233

unsigned int pinval;

3233

unsigned int pinval;

3234

3235

if (spec->mute_led_polarity)

3235

if (spec->mute_led_polarity)

3236

enabled = !enabled;

3236

enabled = !enabled;

3237

pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);

3237

pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);

3238

pinval &= ~AC_PINCTL_VREFEN;

3238

pinval &= ~AC_PINCTL_VREFEN;

3239

pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;

3239

pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;

3240

if (spec->mute_led_nid)

3240

if (spec->mute_led_nid)

3241

snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);

3241

snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);

3242

}

3242

}

3243

3244

/* Make sure the led works even in runtime suspend */

3244

/* Make sure the led works even in runtime suspend */

3245

static unsigned int led_power_filter(struct hda_codec *codec,

3245

static unsigned int led_power_filter(struct hda_codec *codec,

3246

hda_nid_t nid,

3246

hda_nid_t nid,

3247

unsigned int power_state)

3247

unsigned int power_state)

3248

{

3248

{

3249

struct alc_spec *spec = codec->spec;

3249

struct alc_spec *spec = codec->spec;

3250

3251

if (power_state != AC_PWRST_D3 || nid == 0 ||

3251

if (power_state != AC_PWRST_D3 || nid == 0 ||

3252

(nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))

3252

(nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))

3253

return power_state;

3253

return power_state;

3254

3255

/* Set pin ctl again, it might have just been set to 0 */

3255

/* Set pin ctl again, it might have just been set to 0 */

3256

snd_hda_set_pin_ctl(codec, nid,

3256

snd_hda_set_pin_ctl(codec, nid,

3257

snd_hda_codec_get_pin_target(codec, nid));

3257

snd_hda_codec_get_pin_target(codec, nid));

3258

3259

return snd_hda_gen_path_power_filter(codec, nid, power_state);

3259

return snd_hda_gen_path_power_filter(codec, nid, power_state);

3260

}

3260

}

3261

3262

static void alc269_fixup_hp_mute_led(struct hda_codec *codec,

3262

static void alc269_fixup_hp_mute_led(struct hda_codec *codec,

3263

const struct hda_fixup *fix, int action)

3263

const struct hda_fixup *fix, int action)

3264

{

3264

{

3265

struct alc_spec *spec = codec->spec;

3265

struct alc_spec *spec = codec->spec;

3266

const struct dmi_device *dev = NULL;

3266

const struct dmi_device *dev = NULL;

3267

3268

if (action != HDA_FIXUP_ACT_PRE_PROBE)

3268

if (action != HDA_FIXUP_ACT_PRE_PROBE)

3269

return;

3269

return;

3270

3271

while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {

3271

while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {

3272

int pol, pin;

3272

int pol, pin;

3273

if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)

3273

if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)

3274

continue;

3274

continue;

3275

if (pin < 0x0a || pin >= 0x10)

3275

if (pin < 0x0a || pin >= 0x10)

3276

break;

3276

break;

3277

spec->mute_led_polarity = pol;

3277

spec->mute_led_polarity = pol;

3278

spec->mute_led_nid = pin - 0x0a + 0x18;

3278

spec->mute_led_nid = pin - 0x0a + 0x18;

3279

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3279

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3280

spec->gen.vmaster_mute_enum = 1;

3280

spec->gen.vmaster_mute_enum = 1;

3281

codec->power_filter = led_power_filter;

3281

codec->power_filter = led_power_filter;

3282

codec_dbg(codec,

3282

codec_dbg(codec,

3283

"Detected mute LED for %x:%d\n", spec->mute_led_nid,

3283

"Detected mute LED for %x:%d\n", spec->mute_led_nid,

3284

spec->mute_led_polarity);

3284

spec->mute_led_polarity);

3285

break;

3285

break;

3286

}

3286

}

3287

}

3287

}

3288

3289

static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,

3289

static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,

3290

const struct hda_fixup *fix, int action)

3290

const struct hda_fixup *fix, int action)

3291

{

3291

{

3292

struct alc_spec *spec = codec->spec;

3292

struct alc_spec *spec = codec->spec;

3293

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3293

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3294

spec->mute_led_polarity = 0;

3294

spec->mute_led_polarity = 0;

3295

spec->mute_led_nid = 0x18;

3295

spec->mute_led_nid = 0x18;

3296

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3296

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3297

spec->gen.vmaster_mute_enum = 1;

3297

spec->gen.vmaster_mute_enum = 1;

3298

codec->power_filter = led_power_filter;

3298

codec->power_filter = led_power_filter;

3299

}

3299

}

3300

}

3300

}

3301

3302

static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,

3302

static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,

3303

const struct hda_fixup *fix, int action)

3303

const struct hda_fixup *fix, int action)

3304

{

3304

{

3305

struct alc_spec *spec = codec->spec;

3305

struct alc_spec *spec = codec->spec;

3306

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3306

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3307

spec->mute_led_polarity = 0;

3307

spec->mute_led_polarity = 0;

3308

spec->mute_led_nid = 0x19;

3308

spec->mute_led_nid = 0x19;

3309

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3309

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3310

spec->gen.vmaster_mute_enum = 1;

3310

spec->gen.vmaster_mute_enum = 1;

3311

codec->power_filter = led_power_filter;

3311

codec->power_filter = led_power_filter;

3312

}

3312

}

3313

}

3313

}

3314

3315

/* update LED status via GPIO */

3315

/* update LED status via GPIO */

3316

static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,

3316

static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,

3317

bool enabled)

3317

bool enabled)

3318

{

3318

{

3319

struct alc_spec *spec = codec->spec;

3319

struct alc_spec *spec = codec->spec;

3320

unsigned int oldval = spec->gpio_led;

3320

unsigned int oldval = spec->gpio_led;

3321

3322

if (spec->mute_led_polarity)

3322

if (spec->mute_led_polarity)

3323

enabled = !enabled;

3323

enabled = !enabled;

3324

3325

if (enabled)

3325

if (enabled)

3326

spec->gpio_led &= ~mask;

3326

spec->gpio_led &= ~mask;

3327

else

3327

else

3328

spec->gpio_led |= mask;

3328

spec->gpio_led |= mask;

3329

if (spec->gpio_led != oldval)

3329

if (spec->gpio_led != oldval)

3330

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3330

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

3331

spec->gpio_led);

3331

spec->gpio_led);

3332

}

3332

}

3333

3334

/* turn on/off mute LED via GPIO per vmaster hook */

3334

/* turn on/off mute LED via GPIO per vmaster hook */

3335

static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)

3335

static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)

3336

{

3336

{

3337

struct hda_codec *codec = private_data;

3337

struct hda_codec *codec = private_data;

3338

struct alc_spec *spec = codec->spec;

3338

struct alc_spec *spec = codec->spec;

3339

3340

alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);

3340

alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);

3341

}

3341

}

3342

3343

/* turn on/off mic-mute LED via GPIO per capture hook */

3343

/* turn on/off mic-mute LED via GPIO per capture hook */

3344

static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,

3344

static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,

3345

struct snd_kcontrol *kcontrol,

3345

struct snd_kcontrol *kcontrol,

3346

struct snd_ctl_elem_value *ucontrol)

3346

struct snd_ctl_elem_value *ucontrol)

3347

{

3347

{

3348

struct alc_spec *spec = codec->spec;

3348

struct alc_spec *spec = codec->spec;

3349

3350

if (ucontrol)

3350

if (ucontrol)

3351

alc_update_gpio_led(codec, spec->gpio_mic_led_mask,

3351

alc_update_gpio_led(codec, spec->gpio_mic_led_mask,

3352

ucontrol->value.integer.value[0] ||

3352

ucontrol->value.integer.value[0] ||

3353

ucontrol->value.integer.value[1]);

3353

ucontrol->value.integer.value[1]);

3354

}

3354

}

3355

3356

static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,

3356

static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,

3357

const struct hda_fixup *fix, int action)

3357

const struct hda_fixup *fix, int action)

3358

{

3358

{

3359

struct alc_spec *spec = codec->spec;

3359

struct alc_spec *spec = codec->spec;

3360

static const struct hda_verb gpio_init[] = {

3360

static const struct hda_verb gpio_init[] = {

3361

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3361

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3362

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3362

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3363

{}

3363

{}

3364

};

3364

};

3365

3366

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3366

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3367

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3367

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3368

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3368

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3369

spec->gpio_led = 0;

3369

spec->gpio_led = 0;

3370

spec->mute_led_polarity = 0;

3370

spec->mute_led_polarity = 0;

3371

spec->gpio_mute_led_mask = 0x08;

3371

spec->gpio_mute_led_mask = 0x08;

3372

spec->gpio_mic_led_mask = 0x10;

3372

spec->gpio_mic_led_mask = 0x10;

3373

snd_hda_add_verbs(codec, gpio_init);

3373

snd_hda_add_verbs(codec, gpio_init);

3374

}

3374

}

3375

}

3375

}

3376

3377

static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,

3377

static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,

3378

const struct hda_fixup *fix, int action)

3378

const struct hda_fixup *fix, int action)

3379

{

3379

{

3380

struct alc_spec *spec = codec->spec;

3380

struct alc_spec *spec = codec->spec;

3381

static const struct hda_verb gpio_init[] = {

3381

static const struct hda_verb gpio_init[] = {

3382

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },

3382

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },

3383

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },

3383

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },

3384

{}

3384

{}

3385

};

3385

};

3386

3387

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3387

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3388

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3388

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3389

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3389

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3390

spec->gpio_led = 0;

3390

spec->gpio_led = 0;

3391

spec->mute_led_polarity = 0;

3391

spec->mute_led_polarity = 0;

3392

spec->gpio_mute_led_mask = 0x02;

3392

spec->gpio_mute_led_mask = 0x02;

3393

spec->gpio_mic_led_mask = 0x20;

3393

spec->gpio_mic_led_mask = 0x20;

3394

snd_hda_add_verbs(codec, gpio_init);

3394

snd_hda_add_verbs(codec, gpio_init);

3395

}

3395

}

3396

}

3396

}

3397

3398

/* turn on/off mic-mute LED per capture hook */

3398

/* turn on/off mic-mute LED per capture hook */

3399

static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,

3399

static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,

3400

struct snd_kcontrol *kcontrol,

3400

struct snd_kcontrol *kcontrol,

3401

struct snd_ctl_elem_value *ucontrol)

3401

struct snd_ctl_elem_value *ucontrol)

3402

{

3402

{

3403

struct alc_spec *spec = codec->spec;

3403

struct alc_spec *spec = codec->spec;

3404

unsigned int pinval, enable, disable;

3404

unsigned int pinval, enable, disable;

3405

3406

pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);

3406

pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);

3407

pinval &= ~AC_PINCTL_VREFEN;

3407

pinval &= ~AC_PINCTL_VREFEN;

3408

enable = pinval | AC_PINCTL_VREF_80;

3408

enable = pinval | AC_PINCTL_VREF_80;

3409

disable = pinval | AC_PINCTL_VREF_HIZ;

3409

disable = pinval | AC_PINCTL_VREF_HIZ;

3410

3411

if (!ucontrol)

3411

if (!ucontrol)

3412

return;

3412

return;

3413

3414

if (ucontrol->value.integer.value[0] ||

3414

if (ucontrol->value.integer.value[0] ||

3415

ucontrol->value.integer.value[1])

3415

ucontrol->value.integer.value[1])

3416

pinval = disable;

3416

pinval = disable;

3417

else

3417

else

3418

pinval = enable;

3418

pinval = enable;

3419

3420

if (spec->cap_mute_led_nid)

3420

if (spec->cap_mute_led_nid)

3421

snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);

3421

snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);

3422

}

3422

}

3423

3424

static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,

3424

static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,

3425

const struct hda_fixup *fix, int action)

3425

const struct hda_fixup *fix, int action)

3426

{

3426

{

3427

struct alc_spec *spec = codec->spec;

3427

struct alc_spec *spec = codec->spec;

3428

static const struct hda_verb gpio_init[] = {

3428

static const struct hda_verb gpio_init[] = {

3429

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },

3429

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },

3430

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },

3430

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },

3431

{}

3431

{}

3432

};

3432

};

3433

3434

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3434

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3435

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3435

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3436

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3436

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3437

spec->gpio_led = 0;

3437

spec->gpio_led = 0;

3438

spec->mute_led_polarity = 0;

3438

spec->mute_led_polarity = 0;

3439

spec->gpio_mute_led_mask = 0x08;

3439

spec->gpio_mute_led_mask = 0x08;

3440

spec->cap_mute_led_nid = 0x18;

3440

spec->cap_mute_led_nid = 0x18;

3441

snd_hda_add_verbs(codec, gpio_init);

3441

snd_hda_add_verbs(codec, gpio_init);

3442

codec->power_filter = led_power_filter;

3442

codec->power_filter = led_power_filter;

3443

}

3443

}

3444

}

3444

}

3445

3446

static void alc280_fixup_hp_gpio4(struct hda_codec *codec,

3446

static void alc280_fixup_hp_gpio4(struct hda_codec *codec,

3447

const struct hda_fixup *fix, int action)

3447

const struct hda_fixup *fix, int action)

3448

{

3448

{

3449

/* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */

3449

/* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */

3450

struct alc_spec *spec = codec->spec;

3450

struct alc_spec *spec = codec->spec;

3451

static const struct hda_verb gpio_init[] = {

3451

static const struct hda_verb gpio_init[] = {

3452

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3452

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

3453

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3453

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

3454

{}

3454

{}

3455

};

3455

};

3456

3457

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3457

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3458

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3458

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3459

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3459

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3460

spec->gpio_led = 0;

3460

spec->gpio_led = 0;

3461

spec->mute_led_polarity = 0;

3461

spec->mute_led_polarity = 0;

3462

spec->gpio_mute_led_mask = 0x08;

3462

spec->gpio_mute_led_mask = 0x08;

3463

spec->cap_mute_led_nid = 0x18;

3463

spec->cap_mute_led_nid = 0x18;

3464

snd_hda_add_verbs(codec, gpio_init);

3464

snd_hda_add_verbs(codec, gpio_init);

3465

codec->power_filter = led_power_filter;

3465

codec->power_filter = led_power_filter;

3466

}

3466

}

3467

}

3467

}

3468

3469

static void gpio2_mic_hotkey_event(struct hda_codec *codec,

3469

static void gpio2_mic_hotkey_event(struct hda_codec *codec,

3470

struct hda_jack_callback *event)

3470

struct hda_jack_callback *event)

3471

{

3471

{

3472

struct alc_spec *spec = codec->spec;

3472

struct alc_spec *spec = codec->spec;

3473

3474

/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore

3474

/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore

3475

send both key on and key off event for every interrupt. */

3475

send both key on and key off event for every interrupt. */

3476

input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);

3476

input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);

3477

input_sync(spec->kb_dev);

3477

input_sync(spec->kb_dev);

3478

input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);

3478

input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);

3479

input_sync(spec->kb_dev);

3479

input_sync(spec->kb_dev);

3480

}

3480

}

3481

3482

static int alc_register_micmute_input_device(struct hda_codec *codec)

3482

static int alc_register_micmute_input_device(struct hda_codec *codec)

3483

{

3483

{

3484

struct alc_spec *spec = codec->spec;

3484

struct alc_spec *spec = codec->spec;

3485

int i;

3485

int i;

3486

3487

spec->kb_dev = input_allocate_device();

3487

spec->kb_dev = input_allocate_device();

3488

if (!spec->kb_dev) {

3488

if (!spec->kb_dev) {

3489

codec_err(codec, "Out of memory (input_allocate_device)\n");

3489

codec_err(codec, "Out of memory (input_allocate_device)\n");

3490

return -ENOMEM;

3490

return -ENOMEM;

3491

}

3491

}

3492

3493

spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;

3493

spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;

3494

3495

spec->kb_dev->name = "Microphone Mute Button";

3495

spec->kb_dev->name = "Microphone Mute Button";

3496

spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);

3496

spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);

3497

spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);

3497

spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);

3498

spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);

3498

spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);

3499

spec->kb_dev->keycode = spec->alc_mute_keycode_map;

3499

spec->kb_dev->keycode = spec->alc_mute_keycode_map;

3500

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

3500

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

3501

set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);

3501

set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);

3502

3503

if (input_register_device(spec->kb_dev)) {

3503

if (input_register_device(spec->kb_dev)) {

3504

codec_err(codec, "input_register_device failed\n");

3504

codec_err(codec, "input_register_device failed\n");

3505

input_free_device(spec->kb_dev);

3505

input_free_device(spec->kb_dev);

3506

spec->kb_dev = NULL;

3506

spec->kb_dev = NULL;

3507

return -ENOMEM;

3507

return -ENOMEM;

3508

}

3508

}

3509

3510

return 0;

3510

return 0;

3511

}

3511

}

3512

3513

static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,

3513

static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,

3514

const struct hda_fixup *fix, int action)

3514

const struct hda_fixup *fix, int action)

3515

{

3515

{

3516

/* GPIO1 = set according to SKU external amp

3516

/* GPIO1 = set according to SKU external amp

3517

GPIO2 = mic mute hotkey

3517

GPIO2 = mic mute hotkey

3518

GPIO3 = mute LED

3518

GPIO3 = mute LED

3519

GPIO4 = mic mute LED */

3519

GPIO4 = mic mute LED */

3520

static const struct hda_verb gpio_init[] = {

3520

static const struct hda_verb gpio_init[] = {

3521

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },

3521

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },

3522

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },

3522

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },

3523

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },

3523

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },

3524

{}

3524

{}

3525

};

3525

};

3526

3527

struct alc_spec *spec = codec->spec;

3527

struct alc_spec *spec = codec->spec;

3528

3529

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3529

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3530

if (alc_register_micmute_input_device(codec) != 0)

3530

if (alc_register_micmute_input_device(codec) != 0)

3531

return;

3531

return;

3532

3533

snd_hda_add_verbs(codec, gpio_init);

3533

snd_hda_add_verbs(codec, gpio_init);

3534

snd_hda_codec_write_cache(codec, codec->core.afg, 0,

3534

snd_hda_codec_write_cache(codec, codec->core.afg, 0,

3535

AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);

3535

AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);

3536

snd_hda_jack_detect_enable_callback(codec, codec->core.afg,

3536

snd_hda_jack_detect_enable_callback(codec, codec->core.afg,

3537

gpio2_mic_hotkey_event);

3537

gpio2_mic_hotkey_event);

3538

3539

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3539

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

3540

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3540

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3541

spec->gpio_led = 0;

3541

spec->gpio_led = 0;

3542

spec->mute_led_polarity = 0;

3542

spec->mute_led_polarity = 0;

3543

spec->gpio_mute_led_mask = 0x08;

3543

spec->gpio_mute_led_mask = 0x08;

3544

spec->gpio_mic_led_mask = 0x10;

3544

spec->gpio_mic_led_mask = 0x10;

3545

return;

3545

return;

3546

}

3546

}

3547

3548

if (!spec->kb_dev)

3548

if (!spec->kb_dev)

3549

return;

3549

return;

3550

3551

switch (action) {

3551

switch (action) {

3552

case HDA_FIXUP_ACT_PROBE:

3552

case HDA_FIXUP_ACT_PROBE:

3553

spec->init_amp = ALC_INIT_DEFAULT;

3553

spec->init_amp = ALC_INIT_DEFAULT;

3554

break;

3554

break;

3555

case HDA_FIXUP_ACT_FREE:

3555

case HDA_FIXUP_ACT_FREE:

3556

input_unregister_device(spec->kb_dev);

3556

input_unregister_device(spec->kb_dev);

3557

spec->kb_dev = NULL;

3557

spec->kb_dev = NULL;

3558

}

3558

}

3559

}

3559

}

3560

3561

static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,

3561

static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,

3562

const struct hda_fixup *fix, int action)

3562

const struct hda_fixup *fix, int action)

3563

{

3563

{

3564

/* Line2 = mic mute hotkey

3564

/* Line2 = mic mute hotkey

3565

GPIO2 = mic mute LED */

3565

GPIO2 = mic mute LED */

3566

static const struct hda_verb gpio_init[] = {

3566

static const struct hda_verb gpio_init[] = {

3567

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

3567

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

3568

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

3568

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

3569

{}

3569

{}

3570

};

3570

};

3571

3572

struct alc_spec *spec = codec->spec;

3572

struct alc_spec *spec = codec->spec;

3573

3574

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3574

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3575

if (alc_register_micmute_input_device(codec) != 0)

3575

if (alc_register_micmute_input_device(codec) != 0)

3576

return;

3576

return;

3577

3578

snd_hda_add_verbs(codec, gpio_init);

3578

snd_hda_add_verbs(codec, gpio_init);

3579

snd_hda_jack_detect_enable_callback(codec, 0x1b,

3579

snd_hda_jack_detect_enable_callback(codec, 0x1b,

3580

gpio2_mic_hotkey_event);

3580

gpio2_mic_hotkey_event);

3581

3582

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3582

spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;

3583

spec->gpio_led = 0;

3583

spec->gpio_led = 0;

3584

spec->mute_led_polarity = 0;

3584

spec->mute_led_polarity = 0;

3585

spec->gpio_mic_led_mask = 0x04;

3585

spec->gpio_mic_led_mask = 0x04;

3586

return;

3586

return;

3587

}

3587

}

3588

3589

if (!spec->kb_dev)

3589

if (!spec->kb_dev)

3590

return;

3590

return;

3591

3592

switch (action) {

3592

switch (action) {

3593

case HDA_FIXUP_ACT_PROBE:

3593

case HDA_FIXUP_ACT_PROBE:

3594

spec->init_amp = ALC_INIT_DEFAULT;

3594

spec->init_amp = ALC_INIT_DEFAULT;

3595

break;

3595

break;

3596

case HDA_FIXUP_ACT_FREE:

3596

case HDA_FIXUP_ACT_FREE:

3597

input_unregister_device(spec->kb_dev);

3597

input_unregister_device(spec->kb_dev);

3598

spec->kb_dev = NULL;

3598

spec->kb_dev = NULL;

3599

}

3599

}

3600

}

3600

}

3601

3602

static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,

3602

static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,

3603

const struct hda_fixup *fix, int action)

3603

const struct hda_fixup *fix, int action)

3604

{

3604

{

3605

struct alc_spec *spec = codec->spec;

3605

struct alc_spec *spec = codec->spec;

3606

3607

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3607

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

3608

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3608

spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;

3609

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3609

spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;

3610

spec->mute_led_polarity = 0;

3610

spec->mute_led_polarity = 0;

3611

spec->mute_led_nid = 0x1a;

3611

spec->mute_led_nid = 0x1a;

3612

spec->cap_mute_led_nid = 0x18;

3612

spec->cap_mute_led_nid = 0x18;

3613

spec->gen.vmaster_mute_enum = 1;

3613

spec->gen.vmaster_mute_enum = 1;

3614

codec->power_filter = led_power_filter;

3614

codec->power_filter = led_power_filter;

3615

}

3615

}

3616

}

3616

}

3617

3618

static void alc_headset_mode_unplugged(struct hda_codec *codec)

3618

static void alc_headset_mode_unplugged(struct hda_codec *codec)

3619

{

3619

{

3620

static struct coef_fw coef0255[] = {

3620

static struct coef_fw coef0255[] = {

3621

WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */

3621

WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */

3622

WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */

3622

WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */

3623

UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/

3623

UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/

3624

WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */

3624

WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */

3625

WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */

3625

WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */

3626

{}

3626

{}

3627

};

3627

};

3628

static struct coef_fw coef0233[] = {

3628

static struct coef_fw coef0233[] = {

3629

WRITE_COEF(0x1b, 0x0c0b),

3629

WRITE_COEF(0x1b, 0x0c0b),

3630

WRITE_COEF(0x45, 0xc429),

3630

WRITE_COEF(0x45, 0xc429),

3631

UPDATE_COEF(0x35, 0x4000, 0),

3631

UPDATE_COEF(0x35, 0x4000, 0),

3632

WRITE_COEF(0x06, 0x2104),

3632

WRITE_COEF(0x06, 0x2104),

3633

WRITE_COEF(0x1a, 0x0001),

3633

WRITE_COEF(0x1a, 0x0001),

3634

WRITE_COEF(0x26, 0x0004),

3634

WRITE_COEF(0x26, 0x0004),

3635

WRITE_COEF(0x32, 0x42a3),

3635

WRITE_COEF(0x32, 0x42a3),

3636

{}

3636

{}

3637

};

3637

};

3638

static struct coef_fw coef0288[] = {

3638

static struct coef_fw coef0288[] = {

3639

UPDATE_COEF(0x4f, 0xfcc0, 0xc400),

3639

UPDATE_COEF(0x4f, 0xfcc0, 0xc400),

3640

UPDATE_COEF(0x50, 0x2000, 0x2000),

3640

UPDATE_COEF(0x50, 0x2000, 0x2000),

3641

UPDATE_COEF(0x56, 0x0006, 0x0006),

3641

UPDATE_COEF(0x56, 0x0006, 0x0006),

3642

UPDATE_COEF(0x66, 0x0008, 0),

3642

UPDATE_COEF(0x66, 0x0008, 0),

3643

UPDATE_COEF(0x67, 0x2000, 0),

3643

UPDATE_COEF(0x67, 0x2000, 0),

3644

{}

3644

{}

3645

};

3645

};

3646

static struct coef_fw coef0292[] = {

3646

static struct coef_fw coef0292[] = {

3647

WRITE_COEF(0x76, 0x000e),

3647

WRITE_COEF(0x76, 0x000e),

3648

WRITE_COEF(0x6c, 0x2400),

3648

WRITE_COEF(0x6c, 0x2400),

3649

WRITE_COEF(0x18, 0x7308),

3649

WRITE_COEF(0x18, 0x7308),

3650

WRITE_COEF(0x6b, 0xc429),

3650

WRITE_COEF(0x6b, 0xc429),

3651

{}

3651

{}

3652

};

3652

};

3653

static struct coef_fw coef0293[] = {

3653

static struct coef_fw coef0293[] = {

3654

UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */

3654

UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */

3655

UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */

3655

UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */

3656

UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */

3656

UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */

3657

UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */

3657

UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */

3658

WRITE_COEF(0x45, 0xc429), /* Set to TRS type */

3658

WRITE_COEF(0x45, 0xc429), /* Set to TRS type */

3659

UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */

3659

UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */

3660

{}

3660

{}

3661

};

3661

};

3662

static struct coef_fw coef0668[] = {

3662

static struct coef_fw coef0668[] = {

3663

WRITE_COEF(0x15, 0x0d40),

3663

WRITE_COEF(0x15, 0x0d40),

3664

WRITE_COEF(0xb7, 0x802b),

3664

WRITE_COEF(0xb7, 0x802b),

3665

{}

3665

{}

3666

};

3666

};

3667

static struct coef_fw coef0225[] = {

3667

static struct coef_fw coef0225[] = {

3668

UPDATE_COEF(0x4a, 1<<8, 0),

3668

UPDATE_COEF(0x4a, 1<<8, 0),

3669

UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),

3669

UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),

3670

UPDATE_COEF(0x63, 3<<14, 3<<14),

3670

UPDATE_COEF(0x63, 3<<14, 3<<14),

3671

UPDATE_COEF(0x4a, 3<<4, 2<<4),

3671

UPDATE_COEF(0x4a, 3<<4, 2<<4),

3672

UPDATE_COEF(0x4a, 3<<10, 3<<10),

3672

UPDATE_COEF(0x4a, 3<<10, 3<<10),

3673

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

3673

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

3674

UPDATE_COEF(0x4a, 3<<10, 0),

3674

UPDATE_COEF(0x4a, 3<<10, 0),

3675

{}

3675

{}

3676

};

3676

};

3677

3678

switch (codec->core.vendor_id) {

3678

switch (codec->core.vendor_id) {

3679

case 0x10ec0255:

3679

case 0x10ec0255:

3680

case 0x10ec0256:

3680

case 0x10ec0256:

3681

alc_process_coef_fw(codec, coef0255);

3681

alc_process_coef_fw(codec, coef0255);

3682

break;

3682

break;

3683

case 0x10ec0233:

3683

case 0x10ec0233:

3684

case 0x10ec0283:

3684

case 0x10ec0283:

3685

alc_process_coef_fw(codec, coef0233);

3685

alc_process_coef_fw(codec, coef0233);

3686

break;

3686

break;

3687

case 0x10ec0286:

3687

case 0x10ec0286:

3688

case 0x10ec0288:

3688

case 0x10ec0288:

3689

case 0x10ec0298:

3689

case 0x10ec0298:

3690

alc_process_coef_fw(codec, coef0288);

3690

alc_process_coef_fw(codec, coef0288);

3691

break;

3691

break;

3692

case 0x10ec0292:

3692

case 0x10ec0292:

3693

alc_process_coef_fw(codec, coef0292);

3693

alc_process_coef_fw(codec, coef0292);

3694

break;

3694

break;

3695

case 0x10ec0293:

3695

case 0x10ec0293:

3696

alc_process_coef_fw(codec, coef0293);

3696

alc_process_coef_fw(codec, coef0293);

3697

break;

3697

break;

3698

case 0x10ec0668:

3698

case 0x10ec0668:

3699

alc_process_coef_fw(codec, coef0668);

3699

alc_process_coef_fw(codec, coef0668);

3700

break;

3700

break;

3701

case 0x10ec0225:

3701

case 0x10ec0225:

3702

case 0x10ec0295:

3702

case 0x10ec0295:

3703

alc_process_coef_fw(codec, coef0225);

3703

alc_process_coef_fw(codec, coef0225);

3704

break;

3704

break;

3705

}

3705

}

3706

codec_dbg(codec, "Headset jack set to unplugged mode.\n");

3706

codec_dbg(codec, "Headset jack set to unplugged mode.\n");

3707

}

3707

}

3708

3709

3710

static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,

3710

static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,

3711

hda_nid_t mic_pin)

3711

hda_nid_t mic_pin)

3712

{

3712

{

3713

static struct coef_fw coef0255[] = {

3713

static struct coef_fw coef0255[] = {

3714

WRITE_COEFEX(0x57, 0x03, 0x8aa6),

3714

WRITE_COEFEX(0x57, 0x03, 0x8aa6),

3715

WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */

3715

WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */

3716

{}

3716

{}

3717

};

3717

};

3718

static struct coef_fw coef0233[] = {

3718

static struct coef_fw coef0233[] = {

3719

UPDATE_COEF(0x35, 0, 1<<14),

3719

UPDATE_COEF(0x35, 0, 1<<14),

3720

WRITE_COEF(0x06, 0x2100),

3720

WRITE_COEF(0x06, 0x2100),

3721

WRITE_COEF(0x1a, 0x0021),

3721

WRITE_COEF(0x1a, 0x0021),

3722

WRITE_COEF(0x26, 0x008c),

3722

WRITE_COEF(0x26, 0x008c),

3723

{}

3723

{}

3724

};

3724

};

3725

static struct coef_fw coef0288[] = {

3725

static struct coef_fw coef0288[] = {

3726

UPDATE_COEF(0x50, 0x2000, 0),

3726

UPDATE_COEF(0x50, 0x2000, 0),

3727

UPDATE_COEF(0x56, 0x0006, 0),

3727

UPDATE_COEF(0x56, 0x0006, 0),

3728

UPDATE_COEF(0x4f, 0xfcc0, 0xc400),

3728

UPDATE_COEF(0x4f, 0xfcc0, 0xc400),

3729

UPDATE_COEF(0x66, 0x0008, 0x0008),

3729

UPDATE_COEF(0x66, 0x0008, 0x0008),

3730

UPDATE_COEF(0x67, 0x2000, 0x2000),

3730

UPDATE_COEF(0x67, 0x2000, 0x2000),

3731

{}

3731

{}

3732

};

3732

};

3733

static struct coef_fw coef0292[] = {

3733

static struct coef_fw coef0292[] = {

3734

WRITE_COEF(0x19, 0xa208),

3734

WRITE_COEF(0x19, 0xa208),

3735

WRITE_COEF(0x2e, 0xacf0),

3735

WRITE_COEF(0x2e, 0xacf0),

3736

{}

3736

{}

3737

};

3737

};

3738

static struct coef_fw coef0293[] = {

3738

static struct coef_fw coef0293[] = {

3739

UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */

3739

UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */

3740

UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */

3740

UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */

3741

UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */

3741

UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */

3742

{}

3742

{}

3743

};

3743

};

3744

static struct coef_fw coef0688[] = {

3744

static struct coef_fw coef0688[] = {

3745

WRITE_COEF(0xb7, 0x802b),

3745

WRITE_COEF(0xb7, 0x802b),

3746

WRITE_COEF(0xb5, 0x1040),

3746

WRITE_COEF(0xb5, 0x1040),

3747

UPDATE_COEF(0xc3, 0, 1<<12),

3747

UPDATE_COEF(0xc3, 0, 1<<12),

3748

{}

3748

{}

3749

};

3749

};

3750

static struct coef_fw coef0225[] = {

3750

static struct coef_fw coef0225[] = {

3751

UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),

3751

UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),

3752

UPDATE_COEF(0x4a, 3<<4, 2<<4),

3752

UPDATE_COEF(0x4a, 3<<4, 2<<4),

3753

UPDATE_COEF(0x63, 3<<14, 0),

3753

UPDATE_COEF(0x63, 3<<14, 0),

3754

{}

3754

{}

3755

};

3755

};

3756

3757

3758

switch (codec->core.vendor_id) {

3758

switch (codec->core.vendor_id) {

3759

case 0x10ec0255:

3759

case 0x10ec0255:

3760

case 0x10ec0256:

3760

case 0x10ec0256:

3761

alc_write_coef_idx(codec, 0x45, 0xc489);

3761

alc_write_coef_idx(codec, 0x45, 0xc489);

3762

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3762

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3763

alc_process_coef_fw(codec, coef0255);

3763

alc_process_coef_fw(codec, coef0255);

3764

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3764

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3765

break;

3765

break;

3766

case 0x10ec0233:

3766

case 0x10ec0233:

3767

case 0x10ec0283:

3767

case 0x10ec0283:

3768

alc_write_coef_idx(codec, 0x45, 0xc429);

3768

alc_write_coef_idx(codec, 0x45, 0xc429);

3769

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3769

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3770

alc_process_coef_fw(codec, coef0233);

3770

alc_process_coef_fw(codec, coef0233);

3771

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3771

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3772

break;

3772

break;

3773

case 0x10ec0286:

3773

case 0x10ec0286:

3774

case 0x10ec0288:

3774

case 0x10ec0288:

3775

case 0x10ec0298:

3775

case 0x10ec0298:

3776

alc_update_coef_idx(codec, 0x4f, 0x000c, 0);

3776

alc_update_coef_idx(codec, 0x4f, 0x000c, 0);

3777

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3777

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3778

alc_process_coef_fw(codec, coef0288);

3778

alc_process_coef_fw(codec, coef0288);

3779

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3779

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3780

break;

3780

break;

3781

case 0x10ec0292:

3781

case 0x10ec0292:

3782

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3782

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3783

alc_process_coef_fw(codec, coef0292);

3783

alc_process_coef_fw(codec, coef0292);

3784

break;

3784

break;

3785

case 0x10ec0293:

3785

case 0x10ec0293:

3786

/* Set to TRS mode */

3786

/* Set to TRS mode */

3787

alc_write_coef_idx(codec, 0x45, 0xc429);

3787

alc_write_coef_idx(codec, 0x45, 0xc429);

3788

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3788

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3789

alc_process_coef_fw(codec, coef0293);

3789

alc_process_coef_fw(codec, coef0293);

3790

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3790

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3791

break;

3791

break;

3792

case 0x10ec0662:

3792

case 0x10ec0662:

3793

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3793

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3794

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3794

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3795

break;

3795

break;

3796

case 0x10ec0668:

3796

case 0x10ec0668:

3797

alc_write_coef_idx(codec, 0x11, 0x0001);

3797

alc_write_coef_idx(codec, 0x11, 0x0001);

3798

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3798

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3799

alc_process_coef_fw(codec, coef0688);

3799

alc_process_coef_fw(codec, coef0688);

3800

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3800

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3801

break;

3801

break;

3802

case 0x10ec0225:

3802

case 0x10ec0225:

3803

case 0x10ec0295:

3803

case 0x10ec0295:

3804

alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);

3804

alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);

3805

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3805

snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);

3806

alc_process_coef_fw(codec, coef0225);

3806

alc_process_coef_fw(codec, coef0225);

3807

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3807

snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);

3808

break;

3808

break;

3809

}

3809

}

3810

codec_dbg(codec, "Headset jack set to mic-in mode.\n");

3810

codec_dbg(codec, "Headset jack set to mic-in mode.\n");

3811

}

3811

}

3812

3813

static void alc_headset_mode_default(struct hda_codec *codec)

3813

static void alc_headset_mode_default(struct hda_codec *codec)

3814

{

3814

{

3815

static struct coef_fw coef0225[] = {

3815

static struct coef_fw coef0225[] = {

3816

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

3816

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

3817

{}

3817

{}

3818

};

3818

};

3819

static struct coef_fw coef0255[] = {

3819

static struct coef_fw coef0255[] = {

3820

WRITE_COEF(0x45, 0xc089),

3820

WRITE_COEF(0x45, 0xc089),

3821

WRITE_COEF(0x45, 0xc489),

3821

WRITE_COEF(0x45, 0xc489),

3822

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3822

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3823

WRITE_COEF(0x49, 0x0049),

3823

WRITE_COEF(0x49, 0x0049),

3824

{}

3824

{}

3825

};

3825

};

3826

static struct coef_fw coef0233[] = {

3826

static struct coef_fw coef0233[] = {

3827

WRITE_COEF(0x06, 0x2100),

3827

WRITE_COEF(0x06, 0x2100),

3828

WRITE_COEF(0x32, 0x4ea3),

3828

WRITE_COEF(0x32, 0x4ea3),

3829

{}

3829

{}

3830

};

3830

};

3831

static struct coef_fw coef0288[] = {

3831

static struct coef_fw coef0288[] = {

3832

UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */

3832

UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */

3833

UPDATE_COEF(0x50, 0x2000, 0x2000),

3833

UPDATE_COEF(0x50, 0x2000, 0x2000),

3834

UPDATE_COEF(0x56, 0x0006, 0x0006),

3834

UPDATE_COEF(0x56, 0x0006, 0x0006),

3835

UPDATE_COEF(0x66, 0x0008, 0),

3835

UPDATE_COEF(0x66, 0x0008, 0),

3836

UPDATE_COEF(0x67, 0x2000, 0),

3836

UPDATE_COEF(0x67, 0x2000, 0),

3837

{}

3837

{}

3838

};

3838

};

3839

static struct coef_fw coef0292[] = {

3839

static struct coef_fw coef0292[] = {

3840

WRITE_COEF(0x76, 0x000e),

3840

WRITE_COEF(0x76, 0x000e),

3841

WRITE_COEF(0x6c, 0x2400),

3841

WRITE_COEF(0x6c, 0x2400),

3842

WRITE_COEF(0x6b, 0xc429),

3842

WRITE_COEF(0x6b, 0xc429),

3843

WRITE_COEF(0x18, 0x7308),

3843

WRITE_COEF(0x18, 0x7308),

3844

{}

3844

{}

3845

};

3845

};

3846

static struct coef_fw coef0293[] = {

3846

static struct coef_fw coef0293[] = {

3847

UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */

3847

UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */

3848

WRITE_COEF(0x45, 0xC429), /* Set to TRS type */

3848

WRITE_COEF(0x45, 0xC429), /* Set to TRS type */

3849

UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */

3849

UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */

3850

{}

3850

{}

3851

};

3851

};

3852

static struct coef_fw coef0688[] = {

3852

static struct coef_fw coef0688[] = {

3853

WRITE_COEF(0x11, 0x0041),

3853

WRITE_COEF(0x11, 0x0041),

3854

WRITE_COEF(0x15, 0x0d40),

3854

WRITE_COEF(0x15, 0x0d40),

3855

WRITE_COEF(0xb7, 0x802b),

3855

WRITE_COEF(0xb7, 0x802b),

3856

{}

3856

{}

3857

};

3857

};

3858

3859

switch (codec->core.vendor_id) {

3859

switch (codec->core.vendor_id) {

3860

case 0x10ec0225:

3860

case 0x10ec0225:

3861

case 0x10ec0295:

3861

case 0x10ec0295:

3862

alc_process_coef_fw(codec, coef0225);

3862

alc_process_coef_fw(codec, coef0225);

3863

break;

3863

break;

3864

case 0x10ec0255:

3864

case 0x10ec0255:

3865

case 0x10ec0256:

3865

case 0x10ec0256:

3866

alc_process_coef_fw(codec, coef0255);

3866

alc_process_coef_fw(codec, coef0255);

3867

break;

3867

break;

3868

case 0x10ec0233:

3868

case 0x10ec0233:

3869

case 0x10ec0283:

3869

case 0x10ec0283:

3870

alc_process_coef_fw(codec, coef0233);

3870

alc_process_coef_fw(codec, coef0233);

3871

break;

3871

break;

3872

case 0x10ec0286:

3872

case 0x10ec0286:

3873

case 0x10ec0288:

3873

case 0x10ec0288:

3874

case 0x10ec0298:

3874

case 0x10ec0298:

3875

alc_process_coef_fw(codec, coef0288);

3875

alc_process_coef_fw(codec, coef0288);

3876

break;

3876

break;

3877

case 0x10ec0292:

3877

case 0x10ec0292:

3878

alc_process_coef_fw(codec, coef0292);

3878

alc_process_coef_fw(codec, coef0292);

3879

break;

3879

break;

3880

case 0x10ec0293:

3880

case 0x10ec0293:

3881

alc_process_coef_fw(codec, coef0293);

3881

alc_process_coef_fw(codec, coef0293);

3882

break;

3882

break;

3883

case 0x10ec0668:

3883

case 0x10ec0668:

3884

alc_process_coef_fw(codec, coef0688);

3884

alc_process_coef_fw(codec, coef0688);

3885

break;

3885

break;

3886

}

3886

}

3887

codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");

3887

codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");

3888

}

3888

}

3889

3890

/* Iphone type */

3890

/* Iphone type */

3891

static void alc_headset_mode_ctia(struct hda_codec *codec)

3891

static void alc_headset_mode_ctia(struct hda_codec *codec)

3892

{

3892

{

3893

static struct coef_fw coef0255[] = {

3893

static struct coef_fw coef0255[] = {

3894

WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */

3894

WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */

3895

WRITE_COEF(0x1b, 0x0c2b),

3895

WRITE_COEF(0x1b, 0x0c2b),

3896

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3896

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3897

{}

3897

{}

3898

};

3898

};

3899

static struct coef_fw coef0233[] = {

3899

static struct coef_fw coef0233[] = {

3900

WRITE_COEF(0x45, 0xd429),

3900

WRITE_COEF(0x45, 0xd429),

3901

WRITE_COEF(0x1b, 0x0c2b),

3901

WRITE_COEF(0x1b, 0x0c2b),

3902

WRITE_COEF(0x32, 0x4ea3),

3902

WRITE_COEF(0x32, 0x4ea3),

3903

{}

3903

{}

3904

};

3904

};

3905

static struct coef_fw coef0288[] = {

3905

static struct coef_fw coef0288[] = {

3906

UPDATE_COEF(0x50, 0x2000, 0x2000),

3906

UPDATE_COEF(0x50, 0x2000, 0x2000),

3907

UPDATE_COEF(0x56, 0x0006, 0x0006),

3907

UPDATE_COEF(0x56, 0x0006, 0x0006),

3908

UPDATE_COEF(0x66, 0x0008, 0),

3908

UPDATE_COEF(0x66, 0x0008, 0),

3909

UPDATE_COEF(0x67, 0x2000, 0),

3909

UPDATE_COEF(0x67, 0x2000, 0),

3910

{}

3910

{}

3911

};

3911

};

3912

static struct coef_fw coef0292[] = {

3912

static struct coef_fw coef0292[] = {

3913

WRITE_COEF(0x6b, 0xd429),

3913

WRITE_COEF(0x6b, 0xd429),

3914

WRITE_COEF(0x76, 0x0008),

3914

WRITE_COEF(0x76, 0x0008),

3915

WRITE_COEF(0x18, 0x7388),

3915

WRITE_COEF(0x18, 0x7388),

3916

{}

3916

{}

3917

};

3917

};

3918

static struct coef_fw coef0293[] = {

3918

static struct coef_fw coef0293[] = {

3919

WRITE_COEF(0x45, 0xd429), /* Set to ctia type */

3919

WRITE_COEF(0x45, 0xd429), /* Set to ctia type */

3920

UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */

3920

UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */

3921

{}

3921

{}

3922

};

3922

};

3923

static struct coef_fw coef0688[] = {

3923

static struct coef_fw coef0688[] = {

3924

WRITE_COEF(0x11, 0x0001),

3924

WRITE_COEF(0x11, 0x0001),

3925

WRITE_COEF(0x15, 0x0d60),

3925

WRITE_COEF(0x15, 0x0d60),

3926

WRITE_COEF(0xc3, 0x0000),

3926

WRITE_COEF(0xc3, 0x0000),

3927

{}

3927

{}

3928

};

3928

};

3929

static struct coef_fw coef0225[] = {

3929

static struct coef_fw coef0225[] = {

3930

UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),

3930

UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),

3931

UPDATE_COEF(0x49, 1<<8, 1<<8),

3931

UPDATE_COEF(0x49, 1<<8, 1<<8),

3932

UPDATE_COEF(0x4a, 7<<6, 7<<6),

3932

UPDATE_COEF(0x4a, 7<<6, 7<<6),

3933

UPDATE_COEF(0x4a, 3<<4, 3<<4),

3933

UPDATE_COEF(0x4a, 3<<4, 3<<4),

3934

{}

3934

{}

3935

};

3935

};

3936

3937

switch (codec->core.vendor_id) {

3937

switch (codec->core.vendor_id) {

3938

case 0x10ec0255:

3938

case 0x10ec0255:

3939

case 0x10ec0256:

3939

case 0x10ec0256:

3940

alc_process_coef_fw(codec, coef0255);

3940

alc_process_coef_fw(codec, coef0255);

3941

break;

3941

break;

3942

case 0x10ec0233:

3942

case 0x10ec0233:

3943

case 0x10ec0283:

3943

case 0x10ec0283:

3944

alc_process_coef_fw(codec, coef0233);

3944

alc_process_coef_fw(codec, coef0233);

3945

break;

3945

break;

3946

case 0x10ec0298:

3946

case 0x10ec0298:

3947

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */

3947

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */

3948

/* ALC298 jack type setting is the same with ALC286/ALC288 */

3948

/* ALC298 jack type setting is the same with ALC286/ALC288 */

3949

case 0x10ec0286:

3949

case 0x10ec0286:

3950

case 0x10ec0288:

3950

case 0x10ec0288:

3951

alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);

3951

alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);

3952

msleep(300);

3952

msleep(300);

3953

alc_process_coef_fw(codec, coef0288);

3953

alc_process_coef_fw(codec, coef0288);

3954

break;

3954

break;

3955

case 0x10ec0292:

3955

case 0x10ec0292:

3956

alc_process_coef_fw(codec, coef0292);

3956

alc_process_coef_fw(codec, coef0292);

3957

break;

3957

break;

3958

case 0x10ec0293:

3958

case 0x10ec0293:

3959

alc_process_coef_fw(codec, coef0293);

3959

alc_process_coef_fw(codec, coef0293);

3960

break;

3960

break;

3961

case 0x10ec0668:

3961

case 0x10ec0668:

3962

alc_process_coef_fw(codec, coef0688);

3962

alc_process_coef_fw(codec, coef0688);

3963

break;

3963

break;

3964

case 0x10ec0225:

3964

case 0x10ec0225:

3965

case 0x10ec0295:

3965

case 0x10ec0295:

3966

alc_process_coef_fw(codec, coef0225);

3966

alc_process_coef_fw(codec, coef0225);

3967

break;

3967

break;

3968

}

3968

}

3969

codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");

3969

codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");

3970

}

3970

}

3971

3972

/* Nokia type */

3972

/* Nokia type */

3973

static void alc_headset_mode_omtp(struct hda_codec *codec)

3973

static void alc_headset_mode_omtp(struct hda_codec *codec)

3974

{

3974

{

3975

static struct coef_fw coef0255[] = {

3975

static struct coef_fw coef0255[] = {

3976

WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */

3976

WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */

3977

WRITE_COEF(0x1b, 0x0c2b),

3977

WRITE_COEF(0x1b, 0x0c2b),

3978

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3978

WRITE_COEFEX(0x57, 0x03, 0x8ea6),

3979

{}

3979

{}

3980

};

3980

};

3981

static struct coef_fw coef0233[] = {

3981

static struct coef_fw coef0233[] = {

3982

WRITE_COEF(0x45, 0xe429),

3982

WRITE_COEF(0x45, 0xe429),

3983

WRITE_COEF(0x1b, 0x0c2b),

3983

WRITE_COEF(0x1b, 0x0c2b),

3984

WRITE_COEF(0x32, 0x4ea3),

3984

WRITE_COEF(0x32, 0x4ea3),

3985

{}

3985

{}

3986

};

3986

};

3987

static struct coef_fw coef0288[] = {

3987

static struct coef_fw coef0288[] = {

3988

UPDATE_COEF(0x50, 0x2000, 0x2000),

3988

UPDATE_COEF(0x50, 0x2000, 0x2000),

3989

UPDATE_COEF(0x56, 0x0006, 0x0006),

3989

UPDATE_COEF(0x56, 0x0006, 0x0006),

3990

UPDATE_COEF(0x66, 0x0008, 0),

3990

UPDATE_COEF(0x66, 0x0008, 0),

3991

UPDATE_COEF(0x67, 0x2000, 0),

3991

UPDATE_COEF(0x67, 0x2000, 0),

3992

{}

3992

{}

3993

};

3993

};

3994

static struct coef_fw coef0292[] = {

3994

static struct coef_fw coef0292[] = {

3995

WRITE_COEF(0x6b, 0xe429),

3995

WRITE_COEF(0x6b, 0xe429),

3996

WRITE_COEF(0x76, 0x0008),

3996

WRITE_COEF(0x76, 0x0008),

3997

WRITE_COEF(0x18, 0x7388),

3997

WRITE_COEF(0x18, 0x7388),

3998

{}

3998

{}

3999

};

3999

};

4000

static struct coef_fw coef0293[] = {

4000

static struct coef_fw coef0293[] = {

4001

WRITE_COEF(0x45, 0xe429), /* Set to omtp type */

4001

WRITE_COEF(0x45, 0xe429), /* Set to omtp type */

4002

UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */

4002

UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */

4003

{}

4003

{}

4004

};

4004

};

4005

static struct coef_fw coef0688[] = {

4005

static struct coef_fw coef0688[] = {

4006

WRITE_COEF(0x11, 0x0001),

4006

WRITE_COEF(0x11, 0x0001),

4007

WRITE_COEF(0x15, 0x0d50),

4007

WRITE_COEF(0x15, 0x0d50),

4008

WRITE_COEF(0xc3, 0x0000),

4008

WRITE_COEF(0xc3, 0x0000),

4009

{}

4009

{}

4010

};

4010

};

4011

static struct coef_fw coef0225[] = {

4011

static struct coef_fw coef0225[] = {

4012

UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),

4012

UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),

4013

UPDATE_COEF(0x49, 1<<8, 1<<8),

4013

UPDATE_COEF(0x49, 1<<8, 1<<8),

4014

UPDATE_COEF(0x4a, 7<<6, 7<<6),

4014

UPDATE_COEF(0x4a, 7<<6, 7<<6),

4015

UPDATE_COEF(0x4a, 3<<4, 3<<4),

4015

UPDATE_COEF(0x4a, 3<<4, 3<<4),

4016

{}

4016

{}

4017

};

4017

};

4018

4019

switch (codec->core.vendor_id) {

4019

switch (codec->core.vendor_id) {

4020

case 0x10ec0255:

4020

case 0x10ec0255:

4021

case 0x10ec0256:

4021

case 0x10ec0256:

4022

alc_process_coef_fw(codec, coef0255);

4022

alc_process_coef_fw(codec, coef0255);

4023

break;

4023

break;

4024

case 0x10ec0233:

4024

case 0x10ec0233:

4025

case 0x10ec0283:

4025

case 0x10ec0283:

4026

alc_process_coef_fw(codec, coef0233);

4026

alc_process_coef_fw(codec, coef0233);

4027

break;

4027

break;

4028

case 0x10ec0298:

4028

case 0x10ec0298:

4029

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */

4029

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */

4030

/* ALC298 jack type setting is the same with ALC286/ALC288 */

4030

/* ALC298 jack type setting is the same with ALC286/ALC288 */

4031

case 0x10ec0286:

4031

case 0x10ec0286:

4032

case 0x10ec0288:

4032

case 0x10ec0288:

4033

alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);

4033

alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);

4034

msleep(300);

4034

msleep(300);

4035

alc_process_coef_fw(codec, coef0288);

4035

alc_process_coef_fw(codec, coef0288);

4036

break;

4036

break;

4037

case 0x10ec0292:

4037

case 0x10ec0292:

4038

alc_process_coef_fw(codec, coef0292);

4038

alc_process_coef_fw(codec, coef0292);

4039

break;

4039

break;

4040

case 0x10ec0293:

4040

case 0x10ec0293:

4041

alc_process_coef_fw(codec, coef0293);

4041

alc_process_coef_fw(codec, coef0293);

4042

break;

4042

break;

4043

case 0x10ec0668:

4043

case 0x10ec0668:

4044

alc_process_coef_fw(codec, coef0688);

4044

alc_process_coef_fw(codec, coef0688);

4045

break;

4045

break;

4046

case 0x10ec0225:

4046

case 0x10ec0225:

4047

case 0x10ec0295:

4047

case 0x10ec0295:

4048

alc_process_coef_fw(codec, coef0225);

4048

alc_process_coef_fw(codec, coef0225);

4049

break;

4049

break;

4050

}

4050

}

4051

codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");

4051

codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");

4052

}

4052

}

4053

4054

static void alc_determine_headset_type(struct hda_codec *codec)

4054

static void alc_determine_headset_type(struct hda_codec *codec)

4055

{

4055

{

4056

int val;

4056

int val;

4057

bool is_ctia = false;

4057

bool is_ctia = false;

4058

struct alc_spec *spec = codec->spec;

4058

struct alc_spec *spec = codec->spec;

4059

static struct coef_fw coef0255[] = {

4059

static struct coef_fw coef0255[] = {

4060

WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/

4060

WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/

4061

WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref

4061

WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref

4062

conteol) */

4062

conteol) */

4063

{}

4063

{}

4064

};

4064

};

4065

static struct coef_fw coef0288[] = {

4065

static struct coef_fw coef0288[] = {

4066

UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */

4066

UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */

4067

{}

4067

{}

4068

};

4068

};

4069

static struct coef_fw coef0293[] = {

4069

static struct coef_fw coef0293[] = {

4070

UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */

4070

UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */

4071

WRITE_COEF(0x45, 0xD429), /* Set to ctia type */

4071

WRITE_COEF(0x45, 0xD429), /* Set to ctia type */

4072

{}

4072

{}

4073

};

4073

};

4074

static struct coef_fw coef0688[] = {

4074

static struct coef_fw coef0688[] = {

4075

WRITE_COEF(0x11, 0x0001),

4075

WRITE_COEF(0x11, 0x0001),

4076

WRITE_COEF(0xb7, 0x802b),

4076

WRITE_COEF(0xb7, 0x802b),

4077

WRITE_COEF(0x15, 0x0d60),

4077

WRITE_COEF(0x15, 0x0d60),

4078

WRITE_COEF(0xc3, 0x0c00),

4078

WRITE_COEF(0xc3, 0x0c00),

4079

{}

4079

{}

4080

};

4080

};

4081

static struct coef_fw coef0225[] = {

4081

static struct coef_fw coef0225[] = {

4082

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

4082

UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),

4083

UPDATE_COEF(0x49, 1<<8, 1<<8),

4083

UPDATE_COEF(0x49, 1<<8, 1<<8),

4084

{}

4084

{}

4085

};

4085

};

4086

4087

switch (codec->core.vendor_id) {

4087

switch (codec->core.vendor_id) {

4088

case 0x10ec0255:

4088

case 0x10ec0255:

4089

case 0x10ec0256:

4089

case 0x10ec0256:

4090

alc_process_coef_fw(codec, coef0255);

4090

alc_process_coef_fw(codec, coef0255);

4091

msleep(300);

4091

msleep(300);

4092

val = alc_read_coef_idx(codec, 0x46);

4092

val = alc_read_coef_idx(codec, 0x46);

4093

is_ctia = (val & 0x0070) == 0x0070;

4093

is_ctia = (val & 0x0070) == 0x0070;

4094

break;

4094

break;

4095

case 0x10ec0233:

4095

case 0x10ec0233:

4096

case 0x10ec0283:

4096

case 0x10ec0283:

4097

alc_write_coef_idx(codec, 0x45, 0xd029);

4097

alc_write_coef_idx(codec, 0x45, 0xd029);

4098

msleep(300);

4098

msleep(300);

4099

val = alc_read_coef_idx(codec, 0x46);

4099

val = alc_read_coef_idx(codec, 0x46);

4100

is_ctia = (val & 0x0070) == 0x0070;

4100

is_ctia = (val & 0x0070) == 0x0070;

4101

break;

4101

break;

4102

case 0x10ec0298:

4102

case 0x10ec0298:

4103

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */

4103

alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */

4104

/* ALC298 check jack type is the same with ALC286/ALC288 */

4104

/* ALC298 check jack type is the same with ALC286/ALC288 */

4105

case 0x10ec0286:

4105

case 0x10ec0286:

4106

case 0x10ec0288:

4106

case 0x10ec0288:

4107

alc_process_coef_fw(codec, coef0288);

4107

alc_process_coef_fw(codec, coef0288);

4108

msleep(350);

4108

msleep(350);

4109

val = alc_read_coef_idx(codec, 0x50);

4109

val = alc_read_coef_idx(codec, 0x50);

4110

is_ctia = (val & 0x0070) == 0x0070;

4110

is_ctia = (val & 0x0070) == 0x0070;

4111

break;

4111

break;

4112

case 0x10ec0292:

4112

case 0x10ec0292:

4113

alc_write_coef_idx(codec, 0x6b, 0xd429);

4113

alc_write_coef_idx(codec, 0x6b, 0xd429);

4114

msleep(300);

4114

msleep(300);

4115

val = alc_read_coef_idx(codec, 0x6c);

4115

val = alc_read_coef_idx(codec, 0x6c);

4116

is_ctia = (val & 0x001c) == 0x001c;

4116

is_ctia = (val & 0x001c) == 0x001c;

4117

break;

4117

break;

4118

case 0x10ec0293:

4118

case 0x10ec0293:

4119

alc_process_coef_fw(codec, coef0293);

4119

alc_process_coef_fw(codec, coef0293);

4120

msleep(300);

4120

msleep(300);

4121

val = alc_read_coef_idx(codec, 0x46);

4121

val = alc_read_coef_idx(codec, 0x46);

4122

is_ctia = (val & 0x0070) == 0x0070;

4122

is_ctia = (val & 0x0070) == 0x0070;

4123

break;

4123

break;

4124

case 0x10ec0668:

4124

case 0x10ec0668:

4125

alc_process_coef_fw(codec, coef0688);

4125

alc_process_coef_fw(codec, coef0688);

4126

msleep(300);

4126

msleep(300);

4127

val = alc_read_coef_idx(codec, 0xbe);

4127

val = alc_read_coef_idx(codec, 0xbe);

4128

is_ctia = (val & 0x1c02) == 0x1c02;

4128

is_ctia = (val & 0x1c02) == 0x1c02;

4129

break;

4129

break;

4130

case 0x10ec0225:

4130

case 0x10ec0225:

4131

case 0x10ec0295:

4131

case 0x10ec0295:

4132

alc_process_coef_fw(codec, coef0225);

4132

alc_process_coef_fw(codec, coef0225);

4133

msleep(800);

4133

msleep(800);

4134

val = alc_read_coef_idx(codec, 0x46);

4134

val = alc_read_coef_idx(codec, 0x46);

4135

is_ctia = (val & 0x00f0) == 0x00f0;

4135

is_ctia = (val & 0x00f0) == 0x00f0;

4136

break;

4136

break;

4137

}

4137

}

4138

4139

codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",

4139

codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",

4140

is_ctia ? "yes" : "no");

4140

is_ctia ? "yes" : "no");

4141

spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;

4141

spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;

4142

}

4142

}

4143

4144

static void alc_update_headset_mode(struct hda_codec *codec)

4144

static void alc_update_headset_mode(struct hda_codec *codec)

4145

{

4145

{

4146

struct alc_spec *spec = codec->spec;

4146

struct alc_spec *spec = codec->spec;

4147

4148

hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];

4148

hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];

4149

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

4149

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

4150

4151

int new_headset_mode;

4151

int new_headset_mode;

4152

4153

if (!snd_hda_jack_detect(codec, hp_pin))

4153

if (!snd_hda_jack_detect(codec, hp_pin))

4154

new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;

4154

new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;

4155

else if (mux_pin == spec->headset_mic_pin)

4155

else if (mux_pin == spec->headset_mic_pin)

4156

new_headset_mode = ALC_HEADSET_MODE_HEADSET;

4156

new_headset_mode = ALC_HEADSET_MODE_HEADSET;

4157

else if (mux_pin == spec->headphone_mic_pin)

4157

else if (mux_pin == spec->headphone_mic_pin)

4158

new_headset_mode = ALC_HEADSET_MODE_MIC;

4158

new_headset_mode = ALC_HEADSET_MODE_MIC;

4159

else

4159

else

4160

new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;

4160

new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;

4161

4162

if (new_headset_mode == spec->current_headset_mode) {

4162

if (new_headset_mode == spec->current_headset_mode) {

4163

snd_hda_gen_update_outputs(codec);

4163

snd_hda_gen_update_outputs(codec);

4164

return;

4164

return;

4165

}

4165

}

4166

4167

switch (new_headset_mode) {

4167

switch (new_headset_mode) {

4168

case ALC_HEADSET_MODE_UNPLUGGED:

4168

case ALC_HEADSET_MODE_UNPLUGGED:

4169

alc_headset_mode_unplugged(codec);

4169

alc_headset_mode_unplugged(codec);

4170

spec->gen.hp_jack_present = false;

4170

spec->gen.hp_jack_present = false;

4171

break;

4171

break;

4172

case ALC_HEADSET_MODE_HEADSET:

4172

case ALC_HEADSET_MODE_HEADSET:

4173

if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)

4173

if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)

4174

alc_determine_headset_type(codec);

4174

alc_determine_headset_type(codec);

4175

if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)

4175

if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)

4176

alc_headset_mode_ctia(codec);

4176

alc_headset_mode_ctia(codec);

4177

else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)

4177

else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)

4178

alc_headset_mode_omtp(codec);

4178

alc_headset_mode_omtp(codec);

4179

spec->gen.hp_jack_present = true;

4179

spec->gen.hp_jack_present = true;

4180

break;

4180

break;

4181

case ALC_HEADSET_MODE_MIC:

4181

case ALC_HEADSET_MODE_MIC:

4182

alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);

4182

alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);

4183

spec->gen.hp_jack_present = false;

4183

spec->gen.hp_jack_present = false;

4184

break;

4184

break;

4185

case ALC_HEADSET_MODE_HEADPHONE:

4185

case ALC_HEADSET_MODE_HEADPHONE:

4186

alc_headset_mode_default(codec);

4186

alc_headset_mode_default(codec);

4187

spec->gen.hp_jack_present = true;

4187

spec->gen.hp_jack_present = true;

4188

break;

4188

break;

4189

}

4189

}

4190

if (new_headset_mode != ALC_HEADSET_MODE_MIC) {

4190

if (new_headset_mode != ALC_HEADSET_MODE_MIC) {

4191

snd_hda_set_pin_ctl_cache(codec, hp_pin,

4191

snd_hda_set_pin_ctl_cache(codec, hp_pin,

4192

AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);

4192

AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);

4193

if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)

4193

if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)

4194

snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,

4194

snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,

4195

PIN_VREFHIZ);

4195

PIN_VREFHIZ);

4196

}

4196

}

4197

spec->current_headset_mode = new_headset_mode;

4197

spec->current_headset_mode = new_headset_mode;

4198

4199

snd_hda_gen_update_outputs(codec);

4199

snd_hda_gen_update_outputs(codec);

4200

}

4200

}

4201

4202

static void alc_update_headset_mode_hook(struct hda_codec *codec,

4202

static void alc_update_headset_mode_hook(struct hda_codec *codec,

4203

struct snd_kcontrol *kcontrol,

4203

struct snd_kcontrol *kcontrol,

4204

struct snd_ctl_elem_value *ucontrol)

4204

struct snd_ctl_elem_value *ucontrol)

4205

{

4205

{

4206

alc_update_headset_mode(codec);

4206

alc_update_headset_mode(codec);

4207

}

4207

}

4208

4209

static void alc_update_headset_jack_cb(struct hda_codec *codec,

4209

static void alc_update_headset_jack_cb(struct hda_codec *codec,

4210

struct hda_jack_callback *jack)

4210

struct hda_jack_callback *jack)

4211

{

4211

{

4212

struct alc_spec *spec = codec->spec;

4212

struct alc_spec *spec = codec->spec;

4213

spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;

4213

spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;

4214

snd_hda_gen_hp_automute(codec, jack);

4214

snd_hda_gen_hp_automute(codec, jack);

4215

}

4215

}

4216

4217

static void alc_probe_headset_mode(struct hda_codec *codec)

4217

static void alc_probe_headset_mode(struct hda_codec *codec)

4218

{

4218

{

4219

int i;

4219

int i;

4220

struct alc_spec *spec = codec->spec;

4220

struct alc_spec *spec = codec->spec;

4221

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

4221

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

4222

4223

/* Find mic pins */

4223

/* Find mic pins */

4224

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

4224

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

4225

if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)

4225

if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)

4226

spec->headset_mic_pin = cfg->inputs[i].pin;

4226

spec->headset_mic_pin = cfg->inputs[i].pin;

4227

if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)

4227

if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)

4228

spec->headphone_mic_pin = cfg->inputs[i].pin;

4228

spec->headphone_mic_pin = cfg->inputs[i].pin;

4229

}

4229

}

4230

4231

spec->gen.cap_sync_hook = alc_update_headset_mode_hook;

4231

spec->gen.cap_sync_hook = alc_update_headset_mode_hook;

4232

spec->gen.automute_hook = alc_update_headset_mode;

4232

spec->gen.automute_hook = alc_update_headset_mode;

4233

spec->gen.hp_automute_hook = alc_update_headset_jack_cb;

4233

spec->gen.hp_automute_hook = alc_update_headset_jack_cb;

4234

}

4234

}

4235

4236

static void alc_fixup_headset_mode(struct hda_codec *codec,

4236

static void alc_fixup_headset_mode(struct hda_codec *codec,

4237

const struct hda_fixup *fix, int action)

4237

const struct hda_fixup *fix, int action)

4238

{

4238

{

4239

struct alc_spec *spec = codec->spec;

4239

struct alc_spec *spec = codec->spec;

4240

4241

switch (action) {

4241

switch (action) {

4242

case HDA_FIXUP_ACT_PRE_PROBE:

4242

case HDA_FIXUP_ACT_PRE_PROBE:

4243

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;

4243

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;

4244

break;

4244

break;

4245

case HDA_FIXUP_ACT_PROBE:

4245

case HDA_FIXUP_ACT_PROBE:

4246

alc_probe_headset_mode(codec);

4246

alc_probe_headset_mode(codec);

4247

break;

4247

break;

4248

case HDA_FIXUP_ACT_INIT:

4248

case HDA_FIXUP_ACT_INIT:

4249

spec->current_headset_mode = 0;

4249

spec->current_headset_mode = 0;

4250

alc_update_headset_mode(codec);

4250

alc_update_headset_mode(codec);

4251

break;

4251

break;

4252

}

4252

}

4253

}

4253

}

4254

4255

static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,

4255

static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,

4256

const struct hda_fixup *fix, int action)

4256

const struct hda_fixup *fix, int action)

4257

{

4257

{

4258

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4258

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4259

struct alc_spec *spec = codec->spec;

4259

struct alc_spec *spec = codec->spec;

4260

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4260

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4261

}

4261

}

4262

else

4262

else

4263

alc_fixup_headset_mode(codec, fix, action);

4263

alc_fixup_headset_mode(codec, fix, action);

4264

}

4264

}

4265

4266

static void alc255_set_default_jack_type(struct hda_codec *codec)

4266

static void alc255_set_default_jack_type(struct hda_codec *codec)

4267

{

4267

{

4268

/* Set to iphone type */

4268

/* Set to iphone type */

4269

static struct coef_fw fw[] = {

4269

static struct coef_fw fw[] = {

4270

WRITE_COEF(0x1b, 0x880b),

4270

WRITE_COEF(0x1b, 0x880b),

4271

WRITE_COEF(0x45, 0xd089),

4271

WRITE_COEF(0x45, 0xd089),

4272

WRITE_COEF(0x1b, 0x080b),

4272

WRITE_COEF(0x1b, 0x080b),

4273

WRITE_COEF(0x46, 0x0004),

4273

WRITE_COEF(0x46, 0x0004),

4274

WRITE_COEF(0x1b, 0x0c0b),

4274

WRITE_COEF(0x1b, 0x0c0b),

4275

{}

4275

{}

4276

};

4276

};

4277

alc_process_coef_fw(codec, fw);

4277

alc_process_coef_fw(codec, fw);

4278

msleep(30);

4278

msleep(30);

4279

}

4279

}

4280

4281

static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,

4281

static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,

4282

const struct hda_fixup *fix, int action)

4282

const struct hda_fixup *fix, int action)

4283

{

4283

{

4284

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4284

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4285

alc255_set_default_jack_type(codec);

4285

alc255_set_default_jack_type(codec);

4286

}

4286

}

4287

alc_fixup_headset_mode(codec, fix, action);

4287

alc_fixup_headset_mode(codec, fix, action);

4288

}

4288

}

4289

4290

static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,

4290

static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,

4291

const struct hda_fixup *fix, int action)

4291

const struct hda_fixup *fix, int action)

4292

{

4292

{

4293

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4293

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4294

struct alc_spec *spec = codec->spec;

4294

struct alc_spec *spec = codec->spec;

4295

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4295

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4296

alc255_set_default_jack_type(codec);

4296

alc255_set_default_jack_type(codec);

4297

}

4297

}

4298

else

4298

else

4299

alc_fixup_headset_mode(codec, fix, action);

4299

alc_fixup_headset_mode(codec, fix, action);

4300

}

4300

}

4301

4302

static void alc288_update_headset_jack_cb(struct hda_codec *codec,

4302

static void alc288_update_headset_jack_cb(struct hda_codec *codec,

4303

struct hda_jack_callback *jack)

4303

struct hda_jack_callback *jack)

4304

{

4304

{

4305

struct alc_spec *spec = codec->spec;

4305

struct alc_spec *spec = codec->spec;

4306

int present;

4306

int present;

4307

4308

alc_update_headset_jack_cb(codec, jack);

4308

alc_update_headset_jack_cb(codec, jack);

4309

/* Headset Mic enable or disable, only for Dell Dino */

4309

/* Headset Mic enable or disable, only for Dell Dino */

4310

present = spec->gen.hp_jack_present ? 0x40 : 0;

4310

present = spec->gen.hp_jack_present ? 0x40 : 0;

4311

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

4311

snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,

4312

present);

4312

present);

4313

}

4313

}

4314

4315

static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,

4315

static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,

4316

const struct hda_fixup *fix, int action)

4316

const struct hda_fixup *fix, int action)

4317

{

4317

{

4318

alc_fixup_headset_mode(codec, fix, action);

4318

alc_fixup_headset_mode(codec, fix, action);

4319

if (action == HDA_FIXUP_ACT_PROBE) {

4319

if (action == HDA_FIXUP_ACT_PROBE) {

4320

struct alc_spec *spec = codec->spec;

4320

struct alc_spec *spec = codec->spec;

4321

spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;

4321

spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;

4322

}

4322

}

4323

}

4323

}

4324

4325

static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,

4325

static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,

4326

const struct hda_fixup *fix, int action)

4326

const struct hda_fixup *fix, int action)

4327

{

4327

{

4328

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4328

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4329

struct alc_spec *spec = codec->spec;

4329

struct alc_spec *spec = codec->spec;

4330

spec->gen.auto_mute_via_amp = 1;

4330

spec->gen.auto_mute_via_amp = 1;

4331

}

4331

}

4332

}

4332

}

4333

4334

static void alc_no_shutup(struct hda_codec *codec)

4334

static void alc_no_shutup(struct hda_codec *codec)

4335

{

4335

{

4336

}

4336

}

4337

4338

static void alc_fixup_no_shutup(struct hda_codec *codec,

4338

static void alc_fixup_no_shutup(struct hda_codec *codec,

4339

const struct hda_fixup *fix, int action)

4339

const struct hda_fixup *fix, int action)

4340

{

4340

{

4341

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4341

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4342

struct alc_spec *spec = codec->spec;

4342

struct alc_spec *spec = codec->spec;

4343

spec->shutup = alc_no_shutup;

4343

spec->shutup = alc_no_shutup;

4344

}

4344

}

4345

}

4345

}

4346

4347

static void alc_fixup_disable_aamix(struct hda_codec *codec,

4347

static void alc_fixup_disable_aamix(struct hda_codec *codec,

4348

const struct hda_fixup *fix, int action)

4348

const struct hda_fixup *fix, int action)

4349

{

4349

{

4350

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4350

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4351

struct alc_spec *spec = codec->spec;

4351

struct alc_spec *spec = codec->spec;

4352

/* Disable AA-loopback as it causes white noise */

4352

/* Disable AA-loopback as it causes white noise */

4353

spec->gen.mixer_nid = 0;

4353

spec->gen.mixer_nid = 0;

4354

}

4354

}

4355

}

4355

}

4356

4357

/* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */

4357

/* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */

4358

static void alc_fixup_tpt440_dock(struct hda_codec *codec,

4358

static void alc_fixup_tpt440_dock(struct hda_codec *codec,

4359

const struct hda_fixup *fix, int action)

4359

const struct hda_fixup *fix, int action)

4360

{

4360

{

4361

static const struct hda_pintbl pincfgs[] = {

4361

static const struct hda_pintbl pincfgs[] = {

4362

{ 0x16, 0x21211010 }, /* dock headphone */

4362

{ 0x16, 0x21211010 }, /* dock headphone */

4363

{ 0x19, 0x21a11010 }, /* dock mic */

4363

{ 0x19, 0x21a11010 }, /* dock mic */

4364

{ }

4364

{ }

4365

};

4365

};

4366

struct alc_spec *spec = codec->spec;

4366

struct alc_spec *spec = codec->spec;

4367

4368

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4368

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4369

spec->shutup = alc_no_shutup; /* reduce click noise */

4369

spec->shutup = alc_no_shutup; /* reduce click noise */

4370

spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */

4370

spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */

4371

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

4371

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

4372

codec->power_save_node = 0; /* avoid click noises */

4372

codec->power_save_node = 0; /* avoid click noises */

4373

snd_hda_apply_pincfgs(codec, pincfgs);

4373

snd_hda_apply_pincfgs(codec, pincfgs);

4374

}

4374

}

4375

}

4375

}

4376

4377

static void alc_shutup_dell_xps13(struct hda_codec *codec)

4377

static void alc_shutup_dell_xps13(struct hda_codec *codec)

4378

{

4378

{

4379

struct alc_spec *spec = codec->spec;

4379

struct alc_spec *spec = codec->spec;

4380

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

4380

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

4381

4382

/* Prevent pop noises when headphones are plugged in */

4382

/* Prevent pop noises when headphones are plugged in */

4383

snd_hda_codec_write(codec, hp_pin, 0,

4383

snd_hda_codec_write(codec, hp_pin, 0,

4384

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

4384

AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

4385

msleep(20);

4385

msleep(20);

4386

}

4386

}

4387

4388

static void alc_fixup_dell_xps13(struct hda_codec *codec,

4388

static void alc_fixup_dell_xps13(struct hda_codec *codec,

4389

const struct hda_fixup *fix, int action)

4389

const struct hda_fixup *fix, int action)

4390

{

4390

{

4391

struct alc_spec *spec = codec->spec;

4391

struct alc_spec *spec = codec->spec;

4392

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

4392

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

4393

int i;

4393

int i;

4394

4395

switch (action) {

4395

switch (action) {

4396

case HDA_FIXUP_ACT_PRE_PROBE:

4396

case HDA_FIXUP_ACT_PRE_PROBE:

4397

/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise

4397

/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise

4398

* it causes a click noise at start up

4398

* it causes a click noise at start up

4399

*/

4399

*/

4400

snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);

4400

snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);

4401

break;

4401

break;

4402

case HDA_FIXUP_ACT_PROBE:

4402

case HDA_FIXUP_ACT_PROBE:

4403

spec->shutup = alc_shutup_dell_xps13;

4403

spec->shutup = alc_shutup_dell_xps13;

4404

4405

/* Make the internal mic the default input source. */

4405

/* Make the internal mic the default input source. */

4406

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

4406

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

4407

if (spec->gen.imux_pins[i] == 0x12) {

4407

if (spec->gen.imux_pins[i] == 0x12) {

4408

spec->gen.cur_mux[0] = i;

4408

spec->gen.cur_mux[0] = i;

4409

break;

4409

break;

4410

}

4410

}

4411

}

4411

}

4412

break;

4412

break;

4413

}

4413

}

4414

}

4414

}

4415

4416

static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,

4416

static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,

4417

const struct hda_fixup *fix, int action)

4417

const struct hda_fixup *fix, int action)

4418

{

4418

{

4419

struct alc_spec *spec = codec->spec;

4419

struct alc_spec *spec = codec->spec;

4420

4421

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4421

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4422

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4422

spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;

4423

spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */

4423

spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */

4424

4425

/* Disable boost for mic-in permanently. (This code is only called

4425

/* Disable boost for mic-in permanently. (This code is only called

4426

from quirks that guarantee that the headphone is at NID 0x1b.) */

4426

from quirks that guarantee that the headphone is at NID 0x1b.) */

4427

snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);

4427

snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);

4428

snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);

4428

snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);

4429

} else

4429

} else

4430

alc_fixup_headset_mode(codec, fix, action);

4430

alc_fixup_headset_mode(codec, fix, action);

4431

}

4431

}

4432

4433

static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,

4433

static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,

4434

const struct hda_fixup *fix, int action)

4434

const struct hda_fixup *fix, int action)

4435

{

4435

{

4436

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4436

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4437

alc_write_coef_idx(codec, 0xc4, 0x8000);

4437

alc_write_coef_idx(codec, 0xc4, 0x8000);

4438

alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);

4438

alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);

4439

snd_hda_set_pin_ctl_cache(codec, 0x18, 0);

4439

snd_hda_set_pin_ctl_cache(codec, 0x18, 0);

4440

}

4440

}

4441

alc_fixup_headset_mode(codec, fix, action);

4441

alc_fixup_headset_mode(codec, fix, action);

4442

}

4442

}

4443

4444

/* Returns the nid of the external mic input pin, or 0 if it cannot be found. */

4444

/* Returns the nid of the external mic input pin, or 0 if it cannot be found. */

4445

static int find_ext_mic_pin(struct hda_codec *codec)

4445

static int find_ext_mic_pin(struct hda_codec *codec)

4446

{

4446

{

4447

struct alc_spec *spec = codec->spec;

4447

struct alc_spec *spec = codec->spec;

4448

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

4448

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

4449

hda_nid_t nid;

4449

hda_nid_t nid;

4450

unsigned int defcfg;

4450

unsigned int defcfg;

4451

int i;

4451

int i;

4452

4453

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

4453

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

4454

if (cfg->inputs[i].type != AUTO_PIN_MIC)

4454

if (cfg->inputs[i].type != AUTO_PIN_MIC)

4455

continue;

4455

continue;

4456

nid = cfg->inputs[i].pin;

4456

nid = cfg->inputs[i].pin;

4457

defcfg = snd_hda_codec_get_pincfg(codec, nid);

4457

defcfg = snd_hda_codec_get_pincfg(codec, nid);

4458

if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)

4458

if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)

4459

continue;

4459

continue;

4460

return nid;

4460

return nid;

4461

}

4461

}

4462

4463

return 0;

4463

return 0;

4464

}

4464

}

4465

4466

static void alc271_hp_gate_mic_jack(struct hda_codec *codec,

4466

static void alc271_hp_gate_mic_jack(struct hda_codec *codec,

4467

const struct hda_fixup *fix,

4467

const struct hda_fixup *fix,

4468

int action)

4468

int action)

4469

{

4469

{

4470

struct alc_spec *spec = codec->spec;

4470

struct alc_spec *spec = codec->spec;

4471

4472

if (action == HDA_FIXUP_ACT_PROBE) {

4472

if (action == HDA_FIXUP_ACT_PROBE) {

4473

int mic_pin = find_ext_mic_pin(codec);

4473

int mic_pin = find_ext_mic_pin(codec);

4474

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

4474

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

4475

4476

if (snd_BUG_ON(!mic_pin || !hp_pin))

4476

if (snd_BUG_ON(!mic_pin || !hp_pin))

4477

return;

4477

return;

4478

snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);

4478

snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);

4479

}

4479

}

4480

}

4480

}

4481

4482

static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,

4482

static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,

4483

const struct hda_fixup *fix,

4483

const struct hda_fixup *fix,

4484

int action)

4484

int action)

4485

{

4485

{

4486

struct alc_spec *spec = codec->spec;

4486

struct alc_spec *spec = codec->spec;

4487

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

4487

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

4488

int i;

4488

int i;

4489

4490

/* The mic boosts on level 2 and 3 are too noisy

4490

/* The mic boosts on level 2 and 3 are too noisy

4491

on the internal mic input.

4491

on the internal mic input.

4492

Therefore limit the boost to 0 or 1. */

4492

Therefore limit the boost to 0 or 1. */

4493

4494

if (action != HDA_FIXUP_ACT_PROBE)

4494

if (action != HDA_FIXUP_ACT_PROBE)

4495

return;

4495

return;

4496

4497

for (i = 0; i < cfg->num_inputs; i++) {

4497

for (i = 0; i < cfg->num_inputs; i++) {

4498

hda_nid_t nid = cfg->inputs[i].pin;

4498

hda_nid_t nid = cfg->inputs[i].pin;

4499

unsigned int defcfg;

4499

unsigned int defcfg;

4500

if (cfg->inputs[i].type != AUTO_PIN_MIC)

4500

if (cfg->inputs[i].type != AUTO_PIN_MIC)

4501

continue;

4501

continue;

4502

defcfg = snd_hda_codec_get_pincfg(codec, nid);

4502

defcfg = snd_hda_codec_get_pincfg(codec, nid);

4503

if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)

4503

if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)

4504

continue;

4504

continue;

4505

4506

snd_hda_override_amp_caps(codec, nid, HDA_INPUT,

4506

snd_hda_override_amp_caps(codec, nid, HDA_INPUT,

4507

(0x00 << AC_AMPCAP_OFFSET_SHIFT) |

4507

(0x00 << AC_AMPCAP_OFFSET_SHIFT) |

4508

(0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |

4508

(0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |

4509

(0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |

4509

(0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |

4510

(0 << AC_AMPCAP_MUTE_SHIFT));

4510

(0 << AC_AMPCAP_MUTE_SHIFT));

4511

}

4511

}

4512

}

4512

}

4513

4514

static void alc283_hp_automute_hook(struct hda_codec *codec,

4514

static void alc283_hp_automute_hook(struct hda_codec *codec,

4515

struct hda_jack_callback *jack)

4515

struct hda_jack_callback *jack)

4516

{

4516

{

4517

struct alc_spec *spec = codec->spec;

4517

struct alc_spec *spec = codec->spec;

4518

int vref;

4518

int vref;

4519

4520

msleep(200);

4520

msleep(200);

4521

snd_hda_gen_hp_automute(codec, jack);

4521

snd_hda_gen_hp_automute(codec, jack);

4522

4523

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

4523

vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;

4524

4525

msleep(600);

4525

msleep(600);

4526

snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

4526

snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,

4527

vref);

4527

vref);

4528

}

4528

}

4529

4530

static void alc283_fixup_chromebook(struct hda_codec *codec,

4530

static void alc283_fixup_chromebook(struct hda_codec *codec,

4531

const struct hda_fixup *fix, int action)

4531

const struct hda_fixup *fix, int action)

4532

{

4532

{

4533

struct alc_spec *spec = codec->spec;

4533

struct alc_spec *spec = codec->spec;

4534

4535

switch (action) {

4535

switch (action) {

4536

case HDA_FIXUP_ACT_PRE_PROBE:

4536

case HDA_FIXUP_ACT_PRE_PROBE:

4537

snd_hda_override_wcaps(codec, 0x03, 0);

4537

snd_hda_override_wcaps(codec, 0x03, 0);

4538

/* Disable AA-loopback as it causes white noise */

4538

/* Disable AA-loopback as it causes white noise */

4539

spec->gen.mixer_nid = 0;

4539

spec->gen.mixer_nid = 0;

4540

break;

4540

break;

4541

case HDA_FIXUP_ACT_INIT:

4541

case HDA_FIXUP_ACT_INIT:

4542

/* MIC2-VREF control */

4542

/* MIC2-VREF control */

4543

/* Set to manual mode */

4543

/* Set to manual mode */

4544

alc_update_coef_idx(codec, 0x06, 0x000c, 0);

4544

alc_update_coef_idx(codec, 0x06, 0x000c, 0);

4545

/* Enable Line1 input control by verb */

4545

/* Enable Line1 input control by verb */

4546

alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);

4546

alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);

4547

break;

4547

break;

4548

}

4548

}

4549

}

4549

}

4550

4551

static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,

4551

static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,

4552

const struct hda_fixup *fix, int action)

4552

const struct hda_fixup *fix, int action)

4553

{

4553

{

4554

struct alc_spec *spec = codec->spec;

4554

struct alc_spec *spec = codec->spec;

4555

4556

switch (action) {

4556

switch (action) {

4557

case HDA_FIXUP_ACT_PRE_PROBE:

4557

case HDA_FIXUP_ACT_PRE_PROBE:

4558

spec->gen.hp_automute_hook = alc283_hp_automute_hook;

4558

spec->gen.hp_automute_hook = alc283_hp_automute_hook;

4559

break;

4559

break;

4560

case HDA_FIXUP_ACT_INIT:

4560

case HDA_FIXUP_ACT_INIT:

4561

/* MIC2-VREF control */

4561

/* MIC2-VREF control */

4562

/* Set to manual mode */

4562

/* Set to manual mode */

4563

alc_update_coef_idx(codec, 0x06, 0x000c, 0);

4563

alc_update_coef_idx(codec, 0x06, 0x000c, 0);

4564

break;

4564

break;

4565

}

4565

}

4566

}

4566

}

4567

4568

/* mute tablet speaker pin (0x14) via dock plugging in addition */

4568

/* mute tablet speaker pin (0x14) via dock plugging in addition */

4569

static void asus_tx300_automute(struct hda_codec *codec)

4569

static void asus_tx300_automute(struct hda_codec *codec)

4570

{

4570

{

4571

struct alc_spec *spec = codec->spec;

4571

struct alc_spec *spec = codec->spec;

4572

snd_hda_gen_update_outputs(codec);

4572

snd_hda_gen_update_outputs(codec);

4573

if (snd_hda_jack_detect(codec, 0x1b))

4573

if (snd_hda_jack_detect(codec, 0x1b))

4574

spec->gen.mute_bits |= (1ULL << 0x14);

4574

spec->gen.mute_bits |= (1ULL << 0x14);

4575

}

4575

}

4576

4577

static void alc282_fixup_asus_tx300(struct hda_codec *codec,

4577

static void alc282_fixup_asus_tx300(struct hda_codec *codec,

4578

const struct hda_fixup *fix, int action)

4578

const struct hda_fixup *fix, int action)

4579

{

4579

{

4580

struct alc_spec *spec = codec->spec;

4580

struct alc_spec *spec = codec->spec;

4581

/* TX300 needs to set up GPIO2 for the speaker amp */

4581

/* TX300 needs to set up GPIO2 for the speaker amp */

4582

static const struct hda_verb gpio2_verbs[] = {

4582

static const struct hda_verb gpio2_verbs[] = {

4583

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

4583

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },

4584

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

4584

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },

4585

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },

4585

{ 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },

4586

{}

4586

{}

4587

};

4587

};

4588

static const struct hda_pintbl dock_pins[] = {

4588

static const struct hda_pintbl dock_pins[] = {

4589

{ 0x1b, 0x21114000 }, /* dock speaker pin */

4589

{ 0x1b, 0x21114000 }, /* dock speaker pin */

4590

{}

4590

{}

4591

};

4591

};

4592

struct snd_kcontrol *kctl;

4592

struct snd_kcontrol *kctl;

4593

4594

switch (action) {

4594

switch (action) {

4595

case HDA_FIXUP_ACT_PRE_PROBE:

4595

case HDA_FIXUP_ACT_PRE_PROBE:

4596

snd_hda_add_verbs(codec, gpio2_verbs);

4596

snd_hda_add_verbs(codec, gpio2_verbs);

4597

snd_hda_apply_pincfgs(codec, dock_pins);

4597

snd_hda_apply_pincfgs(codec, dock_pins);

4598

spec->gen.auto_mute_via_amp = 1;

4598

spec->gen.auto_mute_via_amp = 1;

4599

spec->gen.automute_hook = asus_tx300_automute;

4599

spec->gen.automute_hook = asus_tx300_automute;

4600

snd_hda_jack_detect_enable_callback(codec, 0x1b,

4600

snd_hda_jack_detect_enable_callback(codec, 0x1b,

4601

snd_hda_gen_hp_automute);

4601

snd_hda_gen_hp_automute);

4602

break;

4602

break;

4603

case HDA_FIXUP_ACT_BUILD:

4603

case HDA_FIXUP_ACT_BUILD:

4604

/* this is a bit tricky; give more sane names for the main

4604

/* this is a bit tricky; give more sane names for the main

4605

* (tablet) speaker and the dock speaker, respectively

4605

* (tablet) speaker and the dock speaker, respectively

4606

*/

4606

*/

4607

kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");

4607

kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");

4608

if (kctl)

4608

if (kctl)

4609

strcpy(kctl->id.name, "Dock Speaker Playback Switch");

4609

strcpy(kctl->id.name, "Dock Speaker Playback Switch");

4610

kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");

4610

kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");

4611

if (kctl)

4611

if (kctl)

4612

strcpy(kctl->id.name, "Speaker Playback Switch");

4612

strcpy(kctl->id.name, "Speaker Playback Switch");

4613

break;

4613

break;

4614

}

4614

}

4615

}

4615

}

4616

4617

static void alc290_fixup_mono_speakers(struct hda_codec *codec,

4617

static void alc290_fixup_mono_speakers(struct hda_codec *codec,

4618

const struct hda_fixup *fix, int action)

4618

const struct hda_fixup *fix, int action)

4619

{

4619

{

4620

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4620

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4621

/* DAC node 0x03 is giving mono output. We therefore want to

4621

/* DAC node 0x03 is giving mono output. We therefore want to

4622

make sure 0x14 (front speaker) and 0x15 (headphones) use the

4622

make sure 0x14 (front speaker) and 0x15 (headphones) use the

4623

stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */

4623

stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */

4624

hda_nid_t conn1[2] = { 0x0c };

4624

hda_nid_t conn1[2] = { 0x0c };

4625

snd_hda_override_conn_list(codec, 0x14, 1, conn1);

4625

snd_hda_override_conn_list(codec, 0x14, 1, conn1);

4626

snd_hda_override_conn_list(codec, 0x15, 1, conn1);

4626

snd_hda_override_conn_list(codec, 0x15, 1, conn1);

4627

}

4627

}

4628

}

4628

}

4629

4630

/* Hook to update amp GPIO4 for automute */

4630

/* Hook to update amp GPIO4 for automute */

4631

static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,

4631

static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,

4632

struct hda_jack_callback *jack)

4632

struct hda_jack_callback *jack)

4633

{

4633

{

4634

struct alc_spec *spec = codec->spec;

4634

struct alc_spec *spec = codec->spec;

4635

4636

snd_hda_gen_hp_automute(codec, jack);

4636

snd_hda_gen_hp_automute(codec, jack);

4637

/* mute_led_polarity is set to 0, so we pass inverted value here */

4637

/* mute_led_polarity is set to 0, so we pass inverted value here */

4638

alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);

4638

alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);

4639

}

4639

}

4640

4641

/* Manage GPIOs for HP EliteBook Folio 9480m.

4641

/* Manage GPIOs for HP EliteBook Folio 9480m.

4642

*

4642

*

4643

* GPIO4 is the headphone amplifier power control

4643

* GPIO4 is the headphone amplifier power control

4644

* GPIO3 is the audio output mute indicator LED

4644

* GPIO3 is the audio output mute indicator LED

4645

*/

4645

*/

4646

4647

static void alc280_fixup_hp_9480m(struct hda_codec *codec,

4647

static void alc280_fixup_hp_9480m(struct hda_codec *codec,

4648

const struct hda_fixup *fix,

4648

const struct hda_fixup *fix,

4649

int action)

4649

int action)

4650

{

4650

{

4651

struct alc_spec *spec = codec->spec;

4651

struct alc_spec *spec = codec->spec;

4652

static const struct hda_verb gpio_init[] = {

4652

static const struct hda_verb gpio_init[] = {

4653

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

4653

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },

4654

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

4654

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },

4655

{}

4655

{}

4656

};

4656

};

4657

4658

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4658

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

4659

/* Set the hooks to turn the headphone amp on/off

4659

/* Set the hooks to turn the headphone amp on/off

4660

* as needed

4660

* as needed

4661

*/

4661

*/

4662

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

4662

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

4663

spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;

4663

spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;

4664

4665

/* The GPIOs are currently off */

4665

/* The GPIOs are currently off */

4666

spec->gpio_led = 0;

4666

spec->gpio_led = 0;

4667

4668

/* GPIO3 is connected to the output mute LED,

4668

/* GPIO3 is connected to the output mute LED,

4669

* high is on, low is off

4669

* high is on, low is off

4670

*/

4670

*/

4671

spec->mute_led_polarity = 0;

4671

spec->mute_led_polarity = 0;

4672

spec->gpio_mute_led_mask = 0x08;

4672

spec->gpio_mute_led_mask = 0x08;

4673

4674

/* Initialize GPIO configuration */

4674

/* Initialize GPIO configuration */

4675

snd_hda_add_verbs(codec, gpio_init);

4675

snd_hda_add_verbs(codec, gpio_init);

4676

}

4676

}

4677

}

4677

}

4678

4679

/* for hda_fixup_thinkpad_acpi() */

4679

/* for hda_fixup_thinkpad_acpi() */

4680

#include "thinkpad_helper.c"

4680

#include "thinkpad_helper.c"

4681

4682

/* for dell wmi mic mute led */

4682

/* for dell wmi mic mute led */

4683

#include "dell_wmi_helper.c"

4683

#include "dell_wmi_helper.c"

4684

4685

enum {

4685

enum {

4686

ALC269_FIXUP_SONY_VAIO,

4686

ALC269_FIXUP_SONY_VAIO,

4687

ALC275_FIXUP_SONY_VAIO_GPIO2,

4687

ALC275_FIXUP_SONY_VAIO_GPIO2,

4688

ALC269_FIXUP_DELL_M101Z,

4688

ALC269_FIXUP_DELL_M101Z,

4689

ALC269_FIXUP_SKU_IGNORE,

4689

ALC269_FIXUP_SKU_IGNORE,

4690

ALC269_FIXUP_ASUS_G73JW,

4690

ALC269_FIXUP_ASUS_G73JW,

4691

ALC269_FIXUP_LENOVO_EAPD,

4691

ALC269_FIXUP_LENOVO_EAPD,

4692

ALC275_FIXUP_SONY_HWEQ,

4692

ALC275_FIXUP_SONY_HWEQ,

4693

ALC275_FIXUP_SONY_DISABLE_AAMIX,

4693

ALC275_FIXUP_SONY_DISABLE_AAMIX,

4694

ALC271_FIXUP_DMIC,

4694

ALC271_FIXUP_DMIC,

4695

ALC269_FIXUP_PCM_44K,

4695

ALC269_FIXUP_PCM_44K,

4696

ALC269_FIXUP_STEREO_DMIC,

4696

ALC269_FIXUP_STEREO_DMIC,

4697

ALC269_FIXUP_HEADSET_MIC,

4697

ALC269_FIXUP_HEADSET_MIC,

4698

ALC269_FIXUP_QUANTA_MUTE,

4698

ALC269_FIXUP_QUANTA_MUTE,

4699

ALC269_FIXUP_LIFEBOOK,

4699

ALC269_FIXUP_LIFEBOOK,

4700

ALC269_FIXUP_LIFEBOOK_EXTMIC,

4700

ALC269_FIXUP_LIFEBOOK_EXTMIC,

4701

ALC269_FIXUP_LIFEBOOK_HP_PIN,

4701

ALC269_FIXUP_LIFEBOOK_HP_PIN,

4702

ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,

4702

ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,

4703

ALC269_FIXUP_AMIC,

4703

ALC269_FIXUP_AMIC,

4704

ALC269_FIXUP_DMIC,

4704

ALC269_FIXUP_DMIC,

4705

ALC269VB_FIXUP_AMIC,

4705

ALC269VB_FIXUP_AMIC,

4706

ALC269VB_FIXUP_DMIC,

4706

ALC269VB_FIXUP_DMIC,

4707

ALC269_FIXUP_HP_MUTE_LED,

4707

ALC269_FIXUP_HP_MUTE_LED,

4708

ALC269_FIXUP_HP_MUTE_LED_MIC1,

4708

ALC269_FIXUP_HP_MUTE_LED_MIC1,

4709

ALC269_FIXUP_HP_MUTE_LED_MIC2,

4709

ALC269_FIXUP_HP_MUTE_LED_MIC2,

4710

ALC269_FIXUP_HP_GPIO_LED,

4710

ALC269_FIXUP_HP_GPIO_LED,

4711

ALC269_FIXUP_HP_GPIO_MIC1_LED,

4711

ALC269_FIXUP_HP_GPIO_MIC1_LED,

4712

ALC269_FIXUP_HP_LINE1_MIC1_LED,

4712

ALC269_FIXUP_HP_LINE1_MIC1_LED,

4713

ALC269_FIXUP_INV_DMIC,

4713

ALC269_FIXUP_INV_DMIC,

4714

ALC269_FIXUP_LENOVO_DOCK,

4714

ALC269_FIXUP_LENOVO_DOCK,

4715

ALC269_FIXUP_NO_SHUTUP,

4715

ALC269_FIXUP_NO_SHUTUP,

4716

ALC286_FIXUP_SONY_MIC_NO_PRESENCE,

4716

ALC286_FIXUP_SONY_MIC_NO_PRESENCE,

4717

ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,

4717

ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,

4718

ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

4718

ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

4719

ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

4719

ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

4720

ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4720

ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

4721

ALC269_FIXUP_HEADSET_MODE,

4721

ALC269_FIXUP_HEADSET_MODE,

4722

ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,

4722

ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,

4723

ALC269_FIXUP_ASPIRE_HEADSET_MIC,

4723

ALC269_FIXUP_ASPIRE_HEADSET_MIC,

4724

ALC269_FIXUP_ASUS_X101_FUNC,

4724

ALC269_FIXUP_ASUS_X101_FUNC,

4725

ALC269_FIXUP_ASUS_X101_VERB,

4725

ALC269_FIXUP_ASUS_X101_VERB,

4726

ALC269_FIXUP_ASUS_X101,

4726

ALC269_FIXUP_ASUS_X101,

4727

ALC271_FIXUP_AMIC_MIC2,

4727

ALC271_FIXUP_AMIC_MIC2,

4728

ALC271_FIXUP_HP_GATE_MIC_JACK,

4728

ALC271_FIXUP_HP_GATE_MIC_JACK,

4729

ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,

4729

ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,

4730

ALC269_FIXUP_ACER_AC700,

4730

ALC269_FIXUP_ACER_AC700,

4731

ALC269_FIXUP_LIMIT_INT_MIC_BOOST,

4731

ALC269_FIXUP_LIMIT_INT_MIC_BOOST,

4732

ALC269VB_FIXUP_ASUS_ZENBOOK,

4732

ALC269VB_FIXUP_ASUS_ZENBOOK,

4733

ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,

4733

ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,

4734

ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,

4734

ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,

4735

ALC269VB_FIXUP_ORDISSIMO_EVE2,

4735

ALC269VB_FIXUP_ORDISSIMO_EVE2,

4736

ALC283_FIXUP_CHROME_BOOK,

4736

ALC283_FIXUP_CHROME_BOOK,

4737

ALC283_FIXUP_SENSE_COMBO_JACK,

4737

ALC283_FIXUP_SENSE_COMBO_JACK,

4738

ALC282_FIXUP_ASUS_TX300,

4738

ALC282_FIXUP_ASUS_TX300,

4739

ALC283_FIXUP_INT_MIC,

4739

ALC283_FIXUP_INT_MIC,

4740

ALC290_FIXUP_MONO_SPEAKERS,

4740

ALC290_FIXUP_MONO_SPEAKERS,

4741

ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4741

ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

4742

ALC290_FIXUP_SUBWOOFER,

4742

ALC290_FIXUP_SUBWOOFER,

4743

ALC290_FIXUP_SUBWOOFER_HSJACK,

4743

ALC290_FIXUP_SUBWOOFER_HSJACK,

4744

ALC269_FIXUP_THINKPAD_ACPI,

4744

ALC269_FIXUP_THINKPAD_ACPI,

4745

ALC269_FIXUP_DMIC_THINKPAD_ACPI,

4745

ALC269_FIXUP_DMIC_THINKPAD_ACPI,

4746

ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

4746

ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

4747

ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

4747

ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

4748

ALC255_FIXUP_HEADSET_MODE,

4748

ALC255_FIXUP_HEADSET_MODE,

4749

ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,

4749

ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,

4750

ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

4750

ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

4751

ALC292_FIXUP_TPT440_DOCK,

4751

ALC292_FIXUP_TPT440_DOCK,

4752

ALC292_FIXUP_TPT440,

4752

ALC292_FIXUP_TPT440,

4753

ALC283_FIXUP_BXBT2807_MIC,

4753

ALC283_FIXUP_BXBT2807_MIC,

4754

ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,

4754

ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,

4755

ALC282_FIXUP_ASPIRE_V5_PINS,

4755

ALC282_FIXUP_ASPIRE_V5_PINS,

4756

ALC280_FIXUP_HP_GPIO4,

4756

ALC280_FIXUP_HP_GPIO4,

4757

ALC286_FIXUP_HP_GPIO_LED,

4757

ALC286_FIXUP_HP_GPIO_LED,

4758

ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,

4758

ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,

4759

ALC280_FIXUP_HP_DOCK_PINS,

4759

ALC280_FIXUP_HP_DOCK_PINS,

4760

ALC280_FIXUP_HP_9480M,

4760

ALC280_FIXUP_HP_9480M,

4761

ALC288_FIXUP_DELL_HEADSET_MODE,

4761

ALC288_FIXUP_DELL_HEADSET_MODE,

4762

ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,

4762

ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,

4763

ALC288_FIXUP_DELL_XPS_13_GPIO6,

4763

ALC288_FIXUP_DELL_XPS_13_GPIO6,

4764

ALC288_FIXUP_DELL_XPS_13,

4764

ALC288_FIXUP_DELL_XPS_13,

4765

ALC288_FIXUP_DISABLE_AAMIX,

4765

ALC288_FIXUP_DISABLE_AAMIX,

4766

ALC292_FIXUP_DELL_E7X,

4766

ALC292_FIXUP_DELL_E7X,

4767

ALC292_FIXUP_DISABLE_AAMIX,

4767

ALC292_FIXUP_DISABLE_AAMIX,

4768

ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,

4768

ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,

4769

ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

4769

ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

4770

ALC275_FIXUP_DELL_XPS,

4770

ALC275_FIXUP_DELL_XPS,

4771

ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,

4771

ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,

4772

ALC293_FIXUP_LENOVO_SPK_NOISE,

4772

ALC293_FIXUP_LENOVO_SPK_NOISE,

4773

ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,

4773

ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,

4774

ALC255_FIXUP_DELL_SPK_NOISE,

4774

ALC255_FIXUP_DELL_SPK_NOISE,

4775

ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

4775

ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

4776

ALC280_FIXUP_HP_HEADSET_MIC,

4776

ALC280_FIXUP_HP_HEADSET_MIC,

4777

ALC221_FIXUP_HP_FRONT_MIC,

4777

ALC221_FIXUP_HP_FRONT_MIC,

4778

ALC292_FIXUP_TPT460,

4778

ALC292_FIXUP_TPT460,

4779

};

4779

};

4780

4781

static const struct hda_fixup alc269_fixups[] = {

4781

static const struct hda_fixup alc269_fixups[] = {

4782

[ALC269_FIXUP_SONY_VAIO] = {

4782

[ALC269_FIXUP_SONY_VAIO] = {

4783

.type = HDA_FIXUP_PINCTLS,

4783

.type = HDA_FIXUP_PINCTLS,

4784

.v.pins = (const struct hda_pintbl[]) {

4784

.v.pins = (const struct hda_pintbl[]) {

4785

{0x19, PIN_VREFGRD},

4785

{0x19, PIN_VREFGRD},

4786

{}

4786

{}

4787

}

4787

}

4788

},

4788

},

4789

[ALC275_FIXUP_SONY_VAIO_GPIO2] = {

4789

[ALC275_FIXUP_SONY_VAIO_GPIO2] = {

4790

.type = HDA_FIXUP_VERBS,

4790

.type = HDA_FIXUP_VERBS,

4791

.v.verbs = (const struct hda_verb[]) {

4791

.v.verbs = (const struct hda_verb[]) {

4792

{0x01, AC_VERB_SET_GPIO_MASK, 0x04},

4792

{0x01, AC_VERB_SET_GPIO_MASK, 0x04},

4793

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},

4793

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},

4794

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

4794

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

4795

{ }

4795

{ }

4796

},

4796

},

4797

.chained = true,

4797

.chained = true,

4798

.chain_id = ALC269_FIXUP_SONY_VAIO

4798

.chain_id = ALC269_FIXUP_SONY_VAIO

4799

},

4799

},

4800

[ALC269_FIXUP_DELL_M101Z] = {

4800

[ALC269_FIXUP_DELL_M101Z] = {

4801

.type = HDA_FIXUP_VERBS,

4801

.type = HDA_FIXUP_VERBS,

4802

.v.verbs = (const struct hda_verb[]) {

4802

.v.verbs = (const struct hda_verb[]) {

4803

/* Enables internal speaker */

4803

/* Enables internal speaker */

4804

{0x20, AC_VERB_SET_COEF_INDEX, 13},

4804

{0x20, AC_VERB_SET_COEF_INDEX, 13},

4805

{0x20, AC_VERB_SET_PROC_COEF, 0x4040},

4805

{0x20, AC_VERB_SET_PROC_COEF, 0x4040},

4806

{}

4806

{}

4807

}

4807

}

4808

},

4808

},

4809

[ALC269_FIXUP_SKU_IGNORE] = {

4809

[ALC269_FIXUP_SKU_IGNORE] = {

4810

.type = HDA_FIXUP_FUNC,

4810

.type = HDA_FIXUP_FUNC,

4811

.v.func = alc_fixup_sku_ignore,

4811

.v.func = alc_fixup_sku_ignore,

4812

},

4812

},

4813

[ALC269_FIXUP_ASUS_G73JW] = {

4813

[ALC269_FIXUP_ASUS_G73JW] = {

4814

.type = HDA_FIXUP_PINS,

4814

.type = HDA_FIXUP_PINS,

4815

.v.pins = (const struct hda_pintbl[]) {

4815

.v.pins = (const struct hda_pintbl[]) {

4816

{ 0x17, 0x99130111 }, /* subwoofer */

4816

{ 0x17, 0x99130111 }, /* subwoofer */

4817

{ }

4817

{ }

4818

}

4818

}

4819

},

4819

},

4820

[ALC269_FIXUP_LENOVO_EAPD] = {

4820

[ALC269_FIXUP_LENOVO_EAPD] = {

4821

.type = HDA_FIXUP_VERBS,

4821

.type = HDA_FIXUP_VERBS,

4822

.v.verbs = (const struct hda_verb[]) {

4822

.v.verbs = (const struct hda_verb[]) {

4823

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

4823

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

4824

{}

4824

{}

4825

}

4825

}

4826

},

4826

},

4827

[ALC275_FIXUP_SONY_HWEQ] = {

4827

[ALC275_FIXUP_SONY_HWEQ] = {

4828

.type = HDA_FIXUP_FUNC,

4828

.type = HDA_FIXUP_FUNC,

4829

.v.func = alc269_fixup_hweq,

4829

.v.func = alc269_fixup_hweq,

4830

.chained = true,

4830

.chained = true,

4831

.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2

4831

.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2

4832

},

4832

},

4833

[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {

4833

[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {

4834

.type = HDA_FIXUP_FUNC,

4834

.type = HDA_FIXUP_FUNC,

4835

.v.func = alc_fixup_disable_aamix,

4835

.v.func = alc_fixup_disable_aamix,

4836

.chained = true,

4836

.chained = true,

4837

.chain_id = ALC269_FIXUP_SONY_VAIO

4837

.chain_id = ALC269_FIXUP_SONY_VAIO

4838

},

4838

},

4839

[ALC271_FIXUP_DMIC] = {

4839

[ALC271_FIXUP_DMIC] = {

4840

.type = HDA_FIXUP_FUNC,

4840

.type = HDA_FIXUP_FUNC,

4841

.v.func = alc271_fixup_dmic,

4841

.v.func = alc271_fixup_dmic,

4842

},

4842

},

4843

[ALC269_FIXUP_PCM_44K] = {

4843

[ALC269_FIXUP_PCM_44K] = {

4844

.type = HDA_FIXUP_FUNC,

4844

.type = HDA_FIXUP_FUNC,

4845

.v.func = alc269_fixup_pcm_44k,

4845

.v.func = alc269_fixup_pcm_44k,

4846

.chained = true,

4846

.chained = true,

4847

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4847

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4848

},

4848

},

4849

[ALC269_FIXUP_STEREO_DMIC] = {

4849

[ALC269_FIXUP_STEREO_DMIC] = {

4850

.type = HDA_FIXUP_FUNC,

4850

.type = HDA_FIXUP_FUNC,

4851

.v.func = alc269_fixup_stereo_dmic,

4851

.v.func = alc269_fixup_stereo_dmic,

4852

},

4852

},

4853

[ALC269_FIXUP_HEADSET_MIC] = {

4853

[ALC269_FIXUP_HEADSET_MIC] = {

4854

.type = HDA_FIXUP_FUNC,

4854

.type = HDA_FIXUP_FUNC,

4855

.v.func = alc269_fixup_headset_mic,

4855

.v.func = alc269_fixup_headset_mic,

4856

},

4856

},

4857

[ALC269_FIXUP_QUANTA_MUTE] = {

4857

[ALC269_FIXUP_QUANTA_MUTE] = {

4858

.type = HDA_FIXUP_FUNC,

4858

.type = HDA_FIXUP_FUNC,

4859

.v.func = alc269_fixup_quanta_mute,

4859

.v.func = alc269_fixup_quanta_mute,

4860

},

4860

},

4861

[ALC269_FIXUP_LIFEBOOK] = {

4861

[ALC269_FIXUP_LIFEBOOK] = {

4862

.type = HDA_FIXUP_PINS,

4862

.type = HDA_FIXUP_PINS,

4863

.v.pins = (const struct hda_pintbl[]) {

4863

.v.pins = (const struct hda_pintbl[]) {

4864

{ 0x1a, 0x2101103f }, /* dock line-out */

4864

{ 0x1a, 0x2101103f }, /* dock line-out */

4865

{ 0x1b, 0x23a11040 }, /* dock mic-in */

4865

{ 0x1b, 0x23a11040 }, /* dock mic-in */

4866

{ }

4866

{ }

4867

},

4867

},

4868

.chained = true,

4868

.chained = true,

4869

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4869

.chain_id = ALC269_FIXUP_QUANTA_MUTE

4870

},

4870

},

4871

[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {

4871

[ALC269_FIXUP_LIFEBOOK_EXTMIC] = {

4872

.type = HDA_FIXUP_PINS,

4872

.type = HDA_FIXUP_PINS,

4873

.v.pins = (const struct hda_pintbl[]) {

4873

.v.pins = (const struct hda_pintbl[]) {

4874

{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */

4874

{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */

4875

{ }

4875

{ }

4876

},

4876

},

4877

},

4877

},

4878

[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {

4878

[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {

4879

.type = HDA_FIXUP_PINS,

4879

.type = HDA_FIXUP_PINS,

4880

.v.pins = (const struct hda_pintbl[]) {

4880

.v.pins = (const struct hda_pintbl[]) {

4881

{ 0x21, 0x0221102f }, /* HP out */

4881

{ 0x21, 0x0221102f }, /* HP out */

4882

{ }

4882

{ }

4883

},

4883

},

4884

},

4884

},

4885

[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {

4885

[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {

4886

.type = HDA_FIXUP_FUNC,

4886

.type = HDA_FIXUP_FUNC,

4887

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4887

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4888

},

4888

},

4889

[ALC269_FIXUP_AMIC] = {

4889

[ALC269_FIXUP_AMIC] = {

4890

.type = HDA_FIXUP_PINS,

4890

.type = HDA_FIXUP_PINS,

4891

.v.pins = (const struct hda_pintbl[]) {

4891

.v.pins = (const struct hda_pintbl[]) {

4892

{ 0x14, 0x99130110 }, /* speaker */

4892

{ 0x14, 0x99130110 }, /* speaker */

4893

{ 0x15, 0x0121401f }, /* HP out */

4893

{ 0x15, 0x0121401f }, /* HP out */

4894

{ 0x18, 0x01a19c20 }, /* mic */

4894

{ 0x18, 0x01a19c20 }, /* mic */

4895

{ 0x19, 0x99a3092f }, /* int-mic */

4895

{ 0x19, 0x99a3092f }, /* int-mic */

4896

{ }

4896

{ }

4897

},

4897

},

4898

},

4898

},

4899

[ALC269_FIXUP_DMIC] = {

4899

[ALC269_FIXUP_DMIC] = {

4900

.type = HDA_FIXUP_PINS,

4900

.type = HDA_FIXUP_PINS,

4901

.v.pins = (const struct hda_pintbl[]) {

4901

.v.pins = (const struct hda_pintbl[]) {

4902

{ 0x12, 0x99a3092f }, /* int-mic */

4902

{ 0x12, 0x99a3092f }, /* int-mic */

4903

{ 0x14, 0x99130110 }, /* speaker */

4903

{ 0x14, 0x99130110 }, /* speaker */

4904

{ 0x15, 0x0121401f }, /* HP out */

4904

{ 0x15, 0x0121401f }, /* HP out */

4905

{ 0x18, 0x01a19c20 }, /* mic */

4905

{ 0x18, 0x01a19c20 }, /* mic */

4906

{ }

4906

{ }

4907

},

4907

},

4908

},

4908

},

4909

[ALC269VB_FIXUP_AMIC] = {

4909

[ALC269VB_FIXUP_AMIC] = {

4910

.type = HDA_FIXUP_PINS,

4910

.type = HDA_FIXUP_PINS,

4911

.v.pins = (const struct hda_pintbl[]) {

4911

.v.pins = (const struct hda_pintbl[]) {

4912

{ 0x14, 0x99130110 }, /* speaker */

4912

{ 0x14, 0x99130110 }, /* speaker */

4913

{ 0x18, 0x01a19c20 }, /* mic */

4913

{ 0x18, 0x01a19c20 }, /* mic */

4914

{ 0x19, 0x99a3092f }, /* int-mic */

4914

{ 0x19, 0x99a3092f }, /* int-mic */

4915

{ 0x21, 0x0121401f }, /* HP out */

4915

{ 0x21, 0x0121401f }, /* HP out */

4916

{ }

4916

{ }

4917

},

4917

},

4918

},

4918

},

4919

[ALC269VB_FIXUP_DMIC] = {

4919

[ALC269VB_FIXUP_DMIC] = {

4920

.type = HDA_FIXUP_PINS,

4920

.type = HDA_FIXUP_PINS,

4921

.v.pins = (const struct hda_pintbl[]) {

4921

.v.pins = (const struct hda_pintbl[]) {

4922

{ 0x12, 0x99a3092f }, /* int-mic */

4922

{ 0x12, 0x99a3092f }, /* int-mic */

4923

{ 0x14, 0x99130110 }, /* speaker */

4923

{ 0x14, 0x99130110 }, /* speaker */

4924

{ 0x18, 0x01a19c20 }, /* mic */

4924

{ 0x18, 0x01a19c20 }, /* mic */

4925

{ 0x21, 0x0121401f }, /* HP out */

4925

{ 0x21, 0x0121401f }, /* HP out */

4926

{ }

4926

{ }

4927

},

4927

},

4928

},

4928

},

4929

[ALC269_FIXUP_HP_MUTE_LED] = {

4929

[ALC269_FIXUP_HP_MUTE_LED] = {

4930

.type = HDA_FIXUP_FUNC,

4930

.type = HDA_FIXUP_FUNC,

4931

.v.func = alc269_fixup_hp_mute_led,

4931

.v.func = alc269_fixup_hp_mute_led,

4932

},

4932

},

4933

[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {

4933

[ALC269_FIXUP_HP_MUTE_LED_MIC1] = {

4934

.type = HDA_FIXUP_FUNC,

4934

.type = HDA_FIXUP_FUNC,

4935

.v.func = alc269_fixup_hp_mute_led_mic1,

4935

.v.func = alc269_fixup_hp_mute_led_mic1,

4936

},

4936

},

4937

[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {

4937

[ALC269_FIXUP_HP_MUTE_LED_MIC2] = {

4938

.type = HDA_FIXUP_FUNC,

4938

.type = HDA_FIXUP_FUNC,

4939

.v.func = alc269_fixup_hp_mute_led_mic2,

4939

.v.func = alc269_fixup_hp_mute_led_mic2,

4940

},

4940

},

4941

[ALC269_FIXUP_HP_GPIO_LED] = {

4941

[ALC269_FIXUP_HP_GPIO_LED] = {

4942

.type = HDA_FIXUP_FUNC,

4942

.type = HDA_FIXUP_FUNC,

4943

.v.func = alc269_fixup_hp_gpio_led,

4943

.v.func = alc269_fixup_hp_gpio_led,

4944

},

4944

},

4945

[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {

4945

[ALC269_FIXUP_HP_GPIO_MIC1_LED] = {

4946

.type = HDA_FIXUP_FUNC,

4946

.type = HDA_FIXUP_FUNC,

4947

.v.func = alc269_fixup_hp_gpio_mic1_led,

4947

.v.func = alc269_fixup_hp_gpio_mic1_led,

4948

},

4948

},

4949

[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {

4949

[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {

4950

.type = HDA_FIXUP_FUNC,

4950

.type = HDA_FIXUP_FUNC,

4951

.v.func = alc269_fixup_hp_line1_mic1_led,

4951

.v.func = alc269_fixup_hp_line1_mic1_led,

4952

},

4952

},

4953

[ALC269_FIXUP_INV_DMIC] = {

4953

[ALC269_FIXUP_INV_DMIC] = {

4954

.type = HDA_FIXUP_FUNC,

4954

.type = HDA_FIXUP_FUNC,

4955

.v.func = alc_fixup_inv_dmic,

4955

.v.func = alc_fixup_inv_dmic,

4956

},

4956

},

4957

[ALC269_FIXUP_NO_SHUTUP] = {

4957

[ALC269_FIXUP_NO_SHUTUP] = {

4958

.type = HDA_FIXUP_FUNC,

4958

.type = HDA_FIXUP_FUNC,

4959

.v.func = alc_fixup_no_shutup,

4959

.v.func = alc_fixup_no_shutup,

4960

},

4960

},

4961

[ALC269_FIXUP_LENOVO_DOCK] = {

4961

[ALC269_FIXUP_LENOVO_DOCK] = {

4962

.type = HDA_FIXUP_PINS,

4962

.type = HDA_FIXUP_PINS,

4963

.v.pins = (const struct hda_pintbl[]) {

4963

.v.pins = (const struct hda_pintbl[]) {

4964

{ 0x19, 0x23a11040 }, /* dock mic */

4964

{ 0x19, 0x23a11040 }, /* dock mic */

4965

{ 0x1b, 0x2121103f }, /* dock headphone */

4965

{ 0x1b, 0x2121103f }, /* dock headphone */

4966

{ }

4966

{ }

4967

},

4967

},

4968

.chained = true,

4968

.chained = true,

4969

.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT

4969

.chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT

4970

},

4970

},

4971

[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {

4971

[ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {

4972

.type = HDA_FIXUP_FUNC,

4972

.type = HDA_FIXUP_FUNC,

4973

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4973

.v.func = alc269_fixup_pincfg_no_hp_to_lineout,

4974

.chained = true,

4974

.chained = true,

4975

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4975

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

4976

},

4976

},

4977

[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4977

[ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {

4978

.type = HDA_FIXUP_PINS,

4978

.type = HDA_FIXUP_PINS,

4979

.v.pins = (const struct hda_pintbl[]) {

4979

.v.pins = (const struct hda_pintbl[]) {

4980

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4980

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4981

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4981

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

4982

{ }

4982

{ }

4983

},

4983

},

4984

.chained = true,

4984

.chained = true,

4985

.chain_id = ALC269_FIXUP_HEADSET_MODE

4985

.chain_id = ALC269_FIXUP_HEADSET_MODE

4986

},

4986

},

4987

[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4987

[ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {

4988

.type = HDA_FIXUP_PINS,

4988

.type = HDA_FIXUP_PINS,

4989

.v.pins = (const struct hda_pintbl[]) {

4989

.v.pins = (const struct hda_pintbl[]) {

4990

{ 0x16, 0x21014020 }, /* dock line out */

4990

{ 0x16, 0x21014020 }, /* dock line out */

4991

{ 0x19, 0x21a19030 }, /* dock mic */

4991

{ 0x19, 0x21a19030 }, /* dock mic */

4992

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4992

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

4993

{ }

4993

{ }

4994

},

4994

},

4995

.chained = true,

4995

.chained = true,

4996

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4996

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

4997

},

4997

},

4998

[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {

4998

[ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {

4999

.type = HDA_FIXUP_PINS,

4999

.type = HDA_FIXUP_PINS,

5000

.v.pins = (const struct hda_pintbl[]) {

5000

.v.pins = (const struct hda_pintbl[]) {

5001

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5001

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5002

{ }

5002

{ }

5003

},

5003

},

5004

.chained = true,

5004

.chained = true,

5005

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

5005

.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC

5006

},

5006

},

5007

[ALC269_FIXUP_HEADSET_MODE] = {

5007

[ALC269_FIXUP_HEADSET_MODE] = {

5008

.type = HDA_FIXUP_FUNC,

5008

.type = HDA_FIXUP_FUNC,

5009

.v.func = alc_fixup_headset_mode,

5009

.v.func = alc_fixup_headset_mode,

5010

.chained = true,

5010

.chained = true,

5011

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5011

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5012

},

5012

},

5013

[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

5013

[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

5014

.type = HDA_FIXUP_FUNC,

5014

.type = HDA_FIXUP_FUNC,

5015

.v.func = alc_fixup_headset_mode_no_hp_mic,

5015

.v.func = alc_fixup_headset_mode_no_hp_mic,

5016

},

5016

},

5017

[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {

5017

[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {

5018

.type = HDA_FIXUP_PINS,

5018

.type = HDA_FIXUP_PINS,

5019

.v.pins = (const struct hda_pintbl[]) {

5019

.v.pins = (const struct hda_pintbl[]) {

5020

{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */

5020

{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */

5021

{ }

5021

{ }

5022

},

5022

},

5023

.chained = true,

5023

.chained = true,

5024

.chain_id = ALC269_FIXUP_HEADSET_MODE,

5024

.chain_id = ALC269_FIXUP_HEADSET_MODE,

5025

},

5025

},

5026

[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {

5026

[ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {

5027

.type = HDA_FIXUP_PINS,

5027

.type = HDA_FIXUP_PINS,

5028

.v.pins = (const struct hda_pintbl[]) {

5028

.v.pins = (const struct hda_pintbl[]) {

5029

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5029

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5030

{ }

5030

{ }

5031

},

5031

},

5032

.chained = true,

5032

.chained = true,

5033

.chain_id = ALC269_FIXUP_HEADSET_MIC

5033

.chain_id = ALC269_FIXUP_HEADSET_MIC

5034

},

5034

},

5035

[ALC269_FIXUP_ASUS_X101_FUNC] = {

5035

[ALC269_FIXUP_ASUS_X101_FUNC] = {

5036

.type = HDA_FIXUP_FUNC,

5036

.type = HDA_FIXUP_FUNC,

5037

.v.func = alc269_fixup_x101_headset_mic,

5037

.v.func = alc269_fixup_x101_headset_mic,

5038

},

5038

},

5039

[ALC269_FIXUP_ASUS_X101_VERB] = {

5039

[ALC269_FIXUP_ASUS_X101_VERB] = {

5040

.type = HDA_FIXUP_VERBS,

5040

.type = HDA_FIXUP_VERBS,

5041

.v.verbs = (const struct hda_verb[]) {

5041

.v.verbs = (const struct hda_verb[]) {

5042

{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},

5042

{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},

5043

{0x20, AC_VERB_SET_COEF_INDEX, 0x08},

5043

{0x20, AC_VERB_SET_COEF_INDEX, 0x08},

5044

{0x20, AC_VERB_SET_PROC_COEF, 0x0310},

5044

{0x20, AC_VERB_SET_PROC_COEF, 0x0310},

5045

{ }

5045

{ }

5046

},

5046

},

5047

.chained = true,

5047

.chained = true,

5048

.chain_id = ALC269_FIXUP_ASUS_X101_FUNC

5048

.chain_id = ALC269_FIXUP_ASUS_X101_FUNC

5049

},

5049

},

5050

[ALC269_FIXUP_ASUS_X101] = {

5050

[ALC269_FIXUP_ASUS_X101] = {

5051

.type = HDA_FIXUP_PINS,

5051

.type = HDA_FIXUP_PINS,

5052

.v.pins = (const struct hda_pintbl[]) {

5052

.v.pins = (const struct hda_pintbl[]) {

5053

{ 0x18, 0x04a1182c }, /* Headset mic */

5053

{ 0x18, 0x04a1182c }, /* Headset mic */

5054

{ }

5054

{ }

5055

},

5055

},

5056

.chained = true,

5056

.chained = true,

5057

.chain_id = ALC269_FIXUP_ASUS_X101_VERB

5057

.chain_id = ALC269_FIXUP_ASUS_X101_VERB

5058

},

5058

},

5059

[ALC271_FIXUP_AMIC_MIC2] = {

5059

[ALC271_FIXUP_AMIC_MIC2] = {

5060

.type = HDA_FIXUP_PINS,

5060

.type = HDA_FIXUP_PINS,

5061

.v.pins = (const struct hda_pintbl[]) {

5061

.v.pins = (const struct hda_pintbl[]) {

5062

{ 0x14, 0x99130110 }, /* speaker */

5062

{ 0x14, 0x99130110 }, /* speaker */

5063

{ 0x19, 0x01a19c20 }, /* mic */

5063

{ 0x19, 0x01a19c20 }, /* mic */

5064

{ 0x1b, 0x99a7012f }, /* int-mic */

5064

{ 0x1b, 0x99a7012f }, /* int-mic */

5065

{ 0x21, 0x0121401f }, /* HP out */

5065

{ 0x21, 0x0121401f }, /* HP out */

5066

{ }

5066

{ }

5067

},

5067

},

5068

},

5068

},

5069

[ALC271_FIXUP_HP_GATE_MIC_JACK] = {

5069

[ALC271_FIXUP_HP_GATE_MIC_JACK] = {

5070

.type = HDA_FIXUP_FUNC,

5070

.type = HDA_FIXUP_FUNC,

5071

.v.func = alc271_hp_gate_mic_jack,

5071

.v.func = alc271_hp_gate_mic_jack,

5072

.chained = true,

5072

.chained = true,

5073

.chain_id = ALC271_FIXUP_AMIC_MIC2,

5073

.chain_id = ALC271_FIXUP_AMIC_MIC2,

5074

},

5074

},

5075

[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {

5075

[ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {

5076

.type = HDA_FIXUP_FUNC,

5076

.type = HDA_FIXUP_FUNC,

5077

.v.func = alc269_fixup_limit_int_mic_boost,

5077

.v.func = alc269_fixup_limit_int_mic_boost,

5078

.chained = true,

5078

.chained = true,

5079

.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,

5079

.chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,

5080

},

5080

},

5081

[ALC269_FIXUP_ACER_AC700] = {

5081

[ALC269_FIXUP_ACER_AC700] = {

5082

.type = HDA_FIXUP_PINS,

5082

.type = HDA_FIXUP_PINS,

5083

.v.pins = (const struct hda_pintbl[]) {

5083

.v.pins = (const struct hda_pintbl[]) {

5084

{ 0x12, 0x99a3092f }, /* int-mic */

5084

{ 0x12, 0x99a3092f }, /* int-mic */

5085

{ 0x14, 0x99130110 }, /* speaker */

5085

{ 0x14, 0x99130110 }, /* speaker */

5086

{ 0x18, 0x03a11c20 }, /* mic */

5086

{ 0x18, 0x03a11c20 }, /* mic */

5087

{ 0x1e, 0x0346101e }, /* SPDIF1 */

5087

{ 0x1e, 0x0346101e }, /* SPDIF1 */

5088

{ 0x21, 0x0321101f }, /* HP out */

5088

{ 0x21, 0x0321101f }, /* HP out */

5089

{ }

5089

{ }

5090

},

5090

},

5091

.chained = true,

5091

.chained = true,

5092

.chain_id = ALC271_FIXUP_DMIC,

5092

.chain_id = ALC271_FIXUP_DMIC,

5093

},

5093

},

5094

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {

5094

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {

5095

.type = HDA_FIXUP_FUNC,

5095

.type = HDA_FIXUP_FUNC,

5096

.v.func = alc269_fixup_limit_int_mic_boost,

5096

.v.func = alc269_fixup_limit_int_mic_boost,

5097

.chained = true,

5097

.chained = true,

5098

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

5098

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

5099

},

5099

},

5100

[ALC269VB_FIXUP_ASUS_ZENBOOK] = {

5100

[ALC269VB_FIXUP_ASUS_ZENBOOK] = {

5101

.type = HDA_FIXUP_FUNC,

5101

.type = HDA_FIXUP_FUNC,

5102

.v.func = alc269_fixup_limit_int_mic_boost,

5102

.v.func = alc269_fixup_limit_int_mic_boost,

5103

.chained = true,

5103

.chained = true,

5104

.chain_id = ALC269VB_FIXUP_DMIC,

5104

.chain_id = ALC269VB_FIXUP_DMIC,

5105

},

5105

},

5106

[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {

5106

[ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {

5107

.type = HDA_FIXUP_VERBS,

5107

.type = HDA_FIXUP_VERBS,

5108

.v.verbs = (const struct hda_verb[]) {

5108

.v.verbs = (const struct hda_verb[]) {

5109

/* class-D output amp +5dB */

5109

/* class-D output amp +5dB */

5110

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },

5110

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },

5111

{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },

5111

{ 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },

5112

{}

5112

{}

5113

},

5113

},

5114

.chained = true,

5114

.chained = true,

5115

.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,

5115

.chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,

5116

},

5116

},

5117

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {

5117

[ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {

5118

.type = HDA_FIXUP_FUNC,

5118

.type = HDA_FIXUP_FUNC,

5119

.v.func = alc269_fixup_limit_int_mic_boost,

5119

.v.func = alc269_fixup_limit_int_mic_boost,

5120

.chained = true,

5120

.chained = true,

5121

.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,

5121

.chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,

5122

},

5122

},

5123

[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {

5123

[ALC269VB_FIXUP_ORDISSIMO_EVE2] = {

5124

.type = HDA_FIXUP_PINS,

5124

.type = HDA_FIXUP_PINS,

5125

.v.pins = (const struct hda_pintbl[]) {

5125

.v.pins = (const struct hda_pintbl[]) {

5126

{ 0x12, 0x99a3092f }, /* int-mic */

5126

{ 0x12, 0x99a3092f }, /* int-mic */

5127

{ 0x18, 0x03a11d20 }, /* mic */

5127

{ 0x18, 0x03a11d20 }, /* mic */

5128

{ 0x19, 0x411111f0 }, /* Unused bogus pin */

5128

{ 0x19, 0x411111f0 }, /* Unused bogus pin */

5129

{ }

5129

{ }

5130

},

5130

},

5131

},

5131

},

5132

[ALC283_FIXUP_CHROME_BOOK] = {

5132

[ALC283_FIXUP_CHROME_BOOK] = {

5133

.type = HDA_FIXUP_FUNC,

5133

.type = HDA_FIXUP_FUNC,

5134

.v.func = alc283_fixup_chromebook,

5134

.v.func = alc283_fixup_chromebook,

5135

},

5135

},

5136

[ALC283_FIXUP_SENSE_COMBO_JACK] = {

5136

[ALC283_FIXUP_SENSE_COMBO_JACK] = {

5137

.type = HDA_FIXUP_FUNC,

5137

.type = HDA_FIXUP_FUNC,

5138

.v.func = alc283_fixup_sense_combo_jack,

5138

.v.func = alc283_fixup_sense_combo_jack,

5139

.chained = true,

5139

.chained = true,

5140

.chain_id = ALC283_FIXUP_CHROME_BOOK,

5140

.chain_id = ALC283_FIXUP_CHROME_BOOK,

5141

},

5141

},

5142

[ALC282_FIXUP_ASUS_TX300] = {

5142

[ALC282_FIXUP_ASUS_TX300] = {

5143

.type = HDA_FIXUP_FUNC,

5143

.type = HDA_FIXUP_FUNC,

5144

.v.func = alc282_fixup_asus_tx300,

5144

.v.func = alc282_fixup_asus_tx300,

5145

},

5145

},

5146

[ALC283_FIXUP_INT_MIC] = {

5146

[ALC283_FIXUP_INT_MIC] = {

5147

.type = HDA_FIXUP_VERBS,

5147

.type = HDA_FIXUP_VERBS,

5148

.v.verbs = (const struct hda_verb[]) {

5148

.v.verbs = (const struct hda_verb[]) {

5149

{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},

5149

{0x20, AC_VERB_SET_COEF_INDEX, 0x1a},

5150

{0x20, AC_VERB_SET_PROC_COEF, 0x0011},

5150

{0x20, AC_VERB_SET_PROC_COEF, 0x0011},

5151

{ }

5151

{ }

5152

},

5152

},

5153

.chained = true,

5153

.chained = true,

5154

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

5154

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

5155

},

5155

},

5156

[ALC290_FIXUP_SUBWOOFER_HSJACK] = {

5156

[ALC290_FIXUP_SUBWOOFER_HSJACK] = {

5157

.type = HDA_FIXUP_PINS,

5157

.type = HDA_FIXUP_PINS,

5158

.v.pins = (const struct hda_pintbl[]) {

5158

.v.pins = (const struct hda_pintbl[]) {

5159

{ 0x17, 0x90170112 }, /* subwoofer */

5159

{ 0x17, 0x90170112 }, /* subwoofer */

5160

{ }

5160

{ }

5161

},

5161

},

5162

.chained = true,

5162

.chained = true,

5163

.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

5163

.chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,

5164

},

5164

},

5165

[ALC290_FIXUP_SUBWOOFER] = {

5165

[ALC290_FIXUP_SUBWOOFER] = {

5166

.type = HDA_FIXUP_PINS,

5166

.type = HDA_FIXUP_PINS,

5167

.v.pins = (const struct hda_pintbl[]) {

5167

.v.pins = (const struct hda_pintbl[]) {

5168

{ 0x17, 0x90170112 }, /* subwoofer */

5168

{ 0x17, 0x90170112 }, /* subwoofer */

5169

{ }

5169

{ }

5170

},

5170

},

5171

.chained = true,

5171

.chained = true,

5172

.chain_id = ALC290_FIXUP_MONO_SPEAKERS,

5172

.chain_id = ALC290_FIXUP_MONO_SPEAKERS,

5173

},

5173

},

5174

[ALC290_FIXUP_MONO_SPEAKERS] = {

5174

[ALC290_FIXUP_MONO_SPEAKERS] = {

5175

.type = HDA_FIXUP_FUNC,

5175

.type = HDA_FIXUP_FUNC,

5176

.v.func = alc290_fixup_mono_speakers,

5176

.v.func = alc290_fixup_mono_speakers,

5177

},

5177

},

5178

[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {

5178

[ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {

5179

.type = HDA_FIXUP_FUNC,

5179

.type = HDA_FIXUP_FUNC,

5180

.v.func = alc290_fixup_mono_speakers,

5180

.v.func = alc290_fixup_mono_speakers,

5181

.chained = true,

5181

.chained = true,

5182

.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

5182

.chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

5183

},

5183

},

5184

[ALC269_FIXUP_THINKPAD_ACPI] = {

5184

[ALC269_FIXUP_THINKPAD_ACPI] = {

5185

.type = HDA_FIXUP_FUNC,

5185

.type = HDA_FIXUP_FUNC,

5186

.v.func = hda_fixup_thinkpad_acpi,

5186

.v.func = hda_fixup_thinkpad_acpi,

5187

},

5187

},

5188

[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {

5188

[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {

5189

.type = HDA_FIXUP_FUNC,

5189

.type = HDA_FIXUP_FUNC,

5190

.v.func = alc_fixup_inv_dmic,

5190

.v.func = alc_fixup_inv_dmic,

5191

.chained = true,

5191

.chained = true,

5192

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

5192

.chain_id = ALC269_FIXUP_THINKPAD_ACPI,

5193

},

5193

},

5194

[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5194

[ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5195

.type = HDA_FIXUP_PINS,

5195

.type = HDA_FIXUP_PINS,

5196

.v.pins = (const struct hda_pintbl[]) {

5196

.v.pins = (const struct hda_pintbl[]) {

5197

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5197

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5198

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5198

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5199

{ }

5199

{ }

5200

},

5200

},

5201

.chained = true,

5201

.chained = true,

5202

.chain_id = ALC255_FIXUP_HEADSET_MODE

5202

.chain_id = ALC255_FIXUP_HEADSET_MODE

5203

},

5203

},

5204

[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {

5204

[ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {

5205

.type = HDA_FIXUP_PINS,

5205

.type = HDA_FIXUP_PINS,

5206

.v.pins = (const struct hda_pintbl[]) {

5206

.v.pins = (const struct hda_pintbl[]) {

5207

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5207

{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5208

{ }

5208

{ }

5209

},

5209

},

5210

.chained = true,

5210

.chained = true,

5211

.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC

5211

.chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC

5212

},

5212

},

5213

[ALC255_FIXUP_HEADSET_MODE] = {

5213

[ALC255_FIXUP_HEADSET_MODE] = {

5214

.type = HDA_FIXUP_FUNC,

5214

.type = HDA_FIXUP_FUNC,

5215

.v.func = alc_fixup_headset_mode_alc255,

5215

.v.func = alc_fixup_headset_mode_alc255,

5216

.chained = true,

5216

.chained = true,

5217

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5217

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5218

},

5218

},

5219

[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

5219

[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {

5220

.type = HDA_FIXUP_FUNC,

5220

.type = HDA_FIXUP_FUNC,

5221

.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,

5221

.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,

5222

},

5222

},

5223

[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5223

[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5224

.type = HDA_FIXUP_PINS,

5224

.type = HDA_FIXUP_PINS,

5225

.v.pins = (const struct hda_pintbl[]) {

5225

.v.pins = (const struct hda_pintbl[]) {

5226

{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5226

{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5227

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5227

{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5228

{ }

5228

{ }

5229

},

5229

},

5230

.chained = true,

5230

.chained = true,

5231

.chain_id = ALC269_FIXUP_HEADSET_MODE

5231

.chain_id = ALC269_FIXUP_HEADSET_MODE

5232

},

5232

},

5233

[ALC292_FIXUP_TPT440_DOCK] = {

5233

[ALC292_FIXUP_TPT440_DOCK] = {

5234

.type = HDA_FIXUP_FUNC,

5234

.type = HDA_FIXUP_FUNC,

5235

.v.func = alc_fixup_tpt440_dock,

5235

.v.func = alc_fixup_tpt440_dock,

5236

.chained = true,

5236

.chained = true,

5237

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

5237

.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST

5238

},

5238

},

5239

[ALC292_FIXUP_TPT440] = {

5239

[ALC292_FIXUP_TPT440] = {

5240

.type = HDA_FIXUP_FUNC,

5240

.type = HDA_FIXUP_FUNC,

5241

.v.func = alc_fixup_disable_aamix,

5241

.v.func = alc_fixup_disable_aamix,

5242

.chained = true,

5242

.chained = true,

5243

.chain_id = ALC292_FIXUP_TPT440_DOCK,

5243

.chain_id = ALC292_FIXUP_TPT440_DOCK,

5244

},

5244

},

5245

[ALC283_FIXUP_BXBT2807_MIC] = {

5245

[ALC283_FIXUP_BXBT2807_MIC] = {

5246

.type = HDA_FIXUP_PINS,

5246

.type = HDA_FIXUP_PINS,

5247

.v.pins = (const struct hda_pintbl[]) {

5247

.v.pins = (const struct hda_pintbl[]) {

5248

{ 0x19, 0x04a110f0 },

5248

{ 0x19, 0x04a110f0 },

5249

{ },

5249

{ },

5250

},

5250

},

5251

},

5251

},

5252

[ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {

5252

[ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {

5253

.type = HDA_FIXUP_FUNC,

5253

.type = HDA_FIXUP_FUNC,

5254

.v.func = alc_fixup_dell_wmi,

5254

.v.func = alc_fixup_dell_wmi,

5255

},

5255

},

5256

[ALC282_FIXUP_ASPIRE_V5_PINS] = {

5256

[ALC282_FIXUP_ASPIRE_V5_PINS] = {

5257

.type = HDA_FIXUP_PINS,

5257

.type = HDA_FIXUP_PINS,

5258

.v.pins = (const struct hda_pintbl[]) {

5258

.v.pins = (const struct hda_pintbl[]) {

5259

{ 0x12, 0x90a60130 },

5259

{ 0x12, 0x90a60130 },

5260

{ 0x14, 0x90170110 },

5260

{ 0x14, 0x90170110 },

5261

{ 0x17, 0x40000008 },

5261

{ 0x17, 0x40000008 },

5262

{ 0x18, 0x411111f0 },

5262

{ 0x18, 0x411111f0 },

5263

{ 0x19, 0x01a1913c },

5263

{ 0x19, 0x01a1913c },

5264

{ 0x1a, 0x411111f0 },

5264

{ 0x1a, 0x411111f0 },

5265

{ 0x1b, 0x411111f0 },

5265

{ 0x1b, 0x411111f0 },

5266

{ 0x1d, 0x40f89b2d },

5266

{ 0x1d, 0x40f89b2d },

5267

{ 0x1e, 0x411111f0 },

5267

{ 0x1e, 0x411111f0 },

5268

{ 0x21, 0x0321101f },

5268

{ 0x21, 0x0321101f },

5269

{ },

5269

{ },

5270

},

5270

},

5271

},

5271

},

5272

[ALC280_FIXUP_HP_GPIO4] = {

5272

[ALC280_FIXUP_HP_GPIO4] = {

5273

.type = HDA_FIXUP_FUNC,

5273

.type = HDA_FIXUP_FUNC,

5274

.v.func = alc280_fixup_hp_gpio4,

5274

.v.func = alc280_fixup_hp_gpio4,

5275

},

5275

},

5276

[ALC286_FIXUP_HP_GPIO_LED] = {

5276

[ALC286_FIXUP_HP_GPIO_LED] = {

5277

.type = HDA_FIXUP_FUNC,

5277

.type = HDA_FIXUP_FUNC,

5278

.v.func = alc286_fixup_hp_gpio_led,

5278

.v.func = alc286_fixup_hp_gpio_led,

5279

},

5279

},

5280

[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {

5280

[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {

5281

.type = HDA_FIXUP_FUNC,

5281

.type = HDA_FIXUP_FUNC,

5282

.v.func = alc280_fixup_hp_gpio2_mic_hotkey,

5282

.v.func = alc280_fixup_hp_gpio2_mic_hotkey,

5283

},

5283

},

5284

[ALC280_FIXUP_HP_DOCK_PINS] = {

5284

[ALC280_FIXUP_HP_DOCK_PINS] = {

5285

.type = HDA_FIXUP_PINS,

5285

.type = HDA_FIXUP_PINS,

5286

.v.pins = (const struct hda_pintbl[]) {

5286

.v.pins = (const struct hda_pintbl[]) {

5287

{ 0x1b, 0x21011020 }, /* line-out */

5287

{ 0x1b, 0x21011020 }, /* line-out */

5288

{ 0x1a, 0x01a1903c }, /* headset mic */

5288

{ 0x1a, 0x01a1903c }, /* headset mic */

5289

{ 0x18, 0x2181103f }, /* line-in */

5289

{ 0x18, 0x2181103f }, /* line-in */

5290

{ },

5290

{ },

5291

},

5291

},

5292

.chained = true,

5292

.chained = true,

5293

.chain_id = ALC280_FIXUP_HP_GPIO4

5293

.chain_id = ALC280_FIXUP_HP_GPIO4

5294

},

5294

},

5295

[ALC280_FIXUP_HP_9480M] = {

5295

[ALC280_FIXUP_HP_9480M] = {

5296

.type = HDA_FIXUP_FUNC,

5296

.type = HDA_FIXUP_FUNC,

5297

.v.func = alc280_fixup_hp_9480m,

5297

.v.func = alc280_fixup_hp_9480m,

5298

},

5298

},

5299

[ALC288_FIXUP_DELL_HEADSET_MODE] = {

5299

[ALC288_FIXUP_DELL_HEADSET_MODE] = {

5300

.type = HDA_FIXUP_FUNC,

5300

.type = HDA_FIXUP_FUNC,

5301

.v.func = alc_fixup_headset_mode_dell_alc288,

5301

.v.func = alc_fixup_headset_mode_dell_alc288,

5302

.chained = true,

5302

.chained = true,

5303

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5303

.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED

5304

},

5304

},

5305

[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5305

[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5306

.type = HDA_FIXUP_PINS,

5306

.type = HDA_FIXUP_PINS,

5307

.v.pins = (const struct hda_pintbl[]) {

5307

.v.pins = (const struct hda_pintbl[]) {

5308

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5308

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5309

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5309

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5310

{ }

5310

{ }

5311

},

5311

},

5312

.chained = true,

5312

.chained = true,

5313

.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE

5313

.chain_id = ALC288_FIXUP_DELL_HEADSET_MODE

5314

},

5314

},

5315

[ALC288_FIXUP_DELL_XPS_13_GPIO6] = {

5315

[ALC288_FIXUP_DELL_XPS_13_GPIO6] = {

5316

.type = HDA_FIXUP_VERBS,

5316

.type = HDA_FIXUP_VERBS,

5317

.v.verbs = (const struct hda_verb[]) {

5317

.v.verbs = (const struct hda_verb[]) {

5318

{0x01, AC_VERB_SET_GPIO_MASK, 0x40},

5318

{0x01, AC_VERB_SET_GPIO_MASK, 0x40},

5319

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},

5319

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},

5320

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

5320

{0x01, AC_VERB_SET_GPIO_DATA, 0x00},

5321

{ }

5321

{ }

5322

},

5322

},

5323

.chained = true,

5323

.chained = true,

5324

.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE

5324

.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE

5325

},

5325

},

5326

[ALC288_FIXUP_DISABLE_AAMIX] = {

5326

[ALC288_FIXUP_DISABLE_AAMIX] = {

5327

.type = HDA_FIXUP_FUNC,

5327

.type = HDA_FIXUP_FUNC,

5328

.v.func = alc_fixup_disable_aamix,

5328

.v.func = alc_fixup_disable_aamix,

5329

.chained = true,

5329

.chained = true,

5330

.chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6

5330

.chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6

5331

},

5331

},

5332

[ALC288_FIXUP_DELL_XPS_13] = {

5332

[ALC288_FIXUP_DELL_XPS_13] = {

5333

.type = HDA_FIXUP_FUNC,

5333

.type = HDA_FIXUP_FUNC,

5334

.v.func = alc_fixup_dell_xps13,

5334

.v.func = alc_fixup_dell_xps13,

5335

.chained = true,

5335

.chained = true,

5336

.chain_id = ALC288_FIXUP_DISABLE_AAMIX

5336

.chain_id = ALC288_FIXUP_DISABLE_AAMIX

5337

},

5337

},

5338

[ALC292_FIXUP_DISABLE_AAMIX] = {

5338

[ALC292_FIXUP_DISABLE_AAMIX] = {

5339

.type = HDA_FIXUP_FUNC,

5339

.type = HDA_FIXUP_FUNC,

5340

.v.func = alc_fixup_disable_aamix,

5340

.v.func = alc_fixup_disable_aamix,

5341

.chained = true,

5341

.chained = true,

5342

.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE

5342

.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE

5343

},

5343

},

5344

[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {

5344

[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {

5345

.type = HDA_FIXUP_FUNC,

5345

.type = HDA_FIXUP_FUNC,

5346

.v.func = alc_fixup_disable_aamix,

5346

.v.func = alc_fixup_disable_aamix,

5347

.chained = true,

5347

.chained = true,

5348

.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE

5348

.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE

5349

},

5349

},

5350

[ALC292_FIXUP_DELL_E7X] = {

5350

[ALC292_FIXUP_DELL_E7X] = {

5351

.type = HDA_FIXUP_FUNC,

5351

.type = HDA_FIXUP_FUNC,

5352

.v.func = alc_fixup_dell_xps13,

5352

.v.func = alc_fixup_dell_xps13,

5353

.chained = true,

5353

.chained = true,

5354

.chain_id = ALC292_FIXUP_DISABLE_AAMIX

5354

.chain_id = ALC292_FIXUP_DISABLE_AAMIX

5355

},

5355

},

5356

[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5356

[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5357

.type = HDA_FIXUP_PINS,

5357

.type = HDA_FIXUP_PINS,

5358

.v.pins = (const struct hda_pintbl[]) {

5358

.v.pins = (const struct hda_pintbl[]) {

5359

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5359

{ 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */

5360

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5360

{ 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */

5361

{ }

5361

{ }

5362

},

5362

},

5363

.chained = true,

5363

.chained = true,

5364

.chain_id = ALC269_FIXUP_HEADSET_MODE

5364

.chain_id = ALC269_FIXUP_HEADSET_MODE

5365

},

5365

},

5366

[ALC275_FIXUP_DELL_XPS] = {

5366

[ALC275_FIXUP_DELL_XPS] = {

5367

.type = HDA_FIXUP_VERBS,

5367

.type = HDA_FIXUP_VERBS,

5368

.v.verbs = (const struct hda_verb[]) {

5368

.v.verbs = (const struct hda_verb[]) {

5369

/* Enables internal speaker */

5369

/* Enables internal speaker */

5370

{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},

5370

{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},

5371

{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},

5371

{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},

5372

{0x20, AC_VERB_SET_COEF_INDEX, 0x30},

5372

{0x20, AC_VERB_SET_COEF_INDEX, 0x30},

5373

{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},

5373

{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},

5374

{}

5374

{}

5375

}

5375

}

5376

},

5376

},

5377

[ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {

5377

[ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {

5378

.type = HDA_FIXUP_VERBS,

5378

.type = HDA_FIXUP_VERBS,

5379

.v.verbs = (const struct hda_verb[]) {

5379

.v.verbs = (const struct hda_verb[]) {

5380

/* Disable pass-through path for FRONT 14h */

5380

/* Disable pass-through path for FRONT 14h */

5381

{0x20, AC_VERB_SET_COEF_INDEX, 0x36},

5381

{0x20, AC_VERB_SET_COEF_INDEX, 0x36},

5382

{0x20, AC_VERB_SET_PROC_COEF, 0x1737},

5382

{0x20, AC_VERB_SET_PROC_COEF, 0x1737},

5383

{}

5383

{}

5384

},

5384

},

5385

.chained = true,

5385

.chained = true,

5386

.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE

5386

.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE

5387

},

5387

},

5388

[ALC293_FIXUP_LENOVO_SPK_NOISE] = {

5388

[ALC293_FIXUP_LENOVO_SPK_NOISE] = {

5389

.type = HDA_FIXUP_FUNC,

5389

.type = HDA_FIXUP_FUNC,

5390

.v.func = alc_fixup_disable_aamix,

5390

.v.func = alc_fixup_disable_aamix,

5391

.chained = true,

5391

.chained = true,

5392

.chain_id = ALC269_FIXUP_THINKPAD_ACPI

5392

.chain_id = ALC269_FIXUP_THINKPAD_ACPI

5393

},

5393

},

5394

[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {

5394

[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {

5395

.type = HDA_FIXUP_FUNC,

5395

.type = HDA_FIXUP_FUNC,

5396

.v.func = alc233_fixup_lenovo_line2_mic_hotkey,

5396

.v.func = alc233_fixup_lenovo_line2_mic_hotkey,

5397

},

5397

},

5398

[ALC255_FIXUP_DELL_SPK_NOISE] = {

5398

[ALC255_FIXUP_DELL_SPK_NOISE] = {

5399

.type = HDA_FIXUP_FUNC,

5399

.type = HDA_FIXUP_FUNC,

5400

.v.func = alc_fixup_disable_aamix,

5400

.v.func = alc_fixup_disable_aamix,

5401

.chained = true,

5401

.chained = true,

5402

.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE

5402

.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE

5403

},

5403

},

5404

[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5404

[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {

5405

.type = HDA_FIXUP_VERBS,

5405

.type = HDA_FIXUP_VERBS,

5406

.v.verbs = (const struct hda_verb[]) {

5406

.v.verbs = (const struct hda_verb[]) {

5407

/* Disable pass-through path for FRONT 14h */

5407

/* Disable pass-through path for FRONT 14h */

5408

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },

5408

{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },

5409

{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },

5409

{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },

5410

{}

5410

{}

5411

},

5411

},

5412

.chained = true,

5412

.chained = true,

5413

.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE

5413

.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE

5414

},

5414

},

5415

[ALC280_FIXUP_HP_HEADSET_MIC] = {

5415

[ALC280_FIXUP_HP_HEADSET_MIC] = {

5416

.type = HDA_FIXUP_FUNC,

5416

.type = HDA_FIXUP_FUNC,

5417

.v.func = alc_fixup_disable_aamix,

5417

.v.func = alc_fixup_disable_aamix,

5418

.chained = true,

5418

.chained = true,

5419

.chain_id = ALC269_FIXUP_HEADSET_MIC,

5419

.chain_id = ALC269_FIXUP_HEADSET_MIC,

5420

},

5420

},

5421

[ALC221_FIXUP_HP_FRONT_MIC] = {

5421

[ALC221_FIXUP_HP_FRONT_MIC] = {

5422

.type = HDA_FIXUP_PINS,

5422

.type = HDA_FIXUP_PINS,

5423

.v.pins = (const struct hda_pintbl[]) {

5423

.v.pins = (const struct hda_pintbl[]) {

5424

{ 0x19, 0x02a19020 }, /* Front Mic */

5424

{ 0x19, 0x02a19020 }, /* Front Mic */

5425

{ }

5425

{ }

5426

},

5426

},

5427

},

5427

},

5428

[ALC292_FIXUP_TPT460] = {

5428

[ALC292_FIXUP_TPT460] = {

5429

.type = HDA_FIXUP_FUNC,

5429

.type = HDA_FIXUP_FUNC,

5430

.v.func = alc_fixup_tpt440_dock,

5430

.v.func = alc_fixup_tpt440_dock,

5431

.chained = true,

5431

.chained = true,

5432

.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,

5432

.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,

5433

},

5433

},

5434

};

5434

};

5435

5436

static const struct snd_pci_quirk alc269_fixup_tbl[] = {

5436

static const struct snd_pci_quirk alc269_fixup_tbl[] = {

5437

SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),

5437

SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),

5438

SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),

5438

SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),

5439

SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),

5439

SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),

5440

SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),

5440

SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),

5441

SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),

5441

SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),

5442

SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),

5442

SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),

5443

SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),

5443

SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),

5444

SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),

5444

SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),

5445

SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

5445

SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

5446

SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

5446

SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),

5447

SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),

5447

SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),

5448

SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),

5448

SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),

5449

SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),

5449

SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),

5450

SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),

5450

SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),

5451

SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),

5451

SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),

5452

SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),

5452

SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),

5453

SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),

5453

SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),

5454

SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),

5454

SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),

5455

SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),

5455

SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),

5456

SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5456

SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5457

SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5457

SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5458

SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5458

SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),

5459

SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

5459

SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

5460

SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

5460

SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),

5461

SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),

5461

SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),

5462

SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),

5462

SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),

5463

SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),

5463

SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),

5464

SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5464

SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5465

SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5465

SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5466

SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),

5466

SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),

5467

SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

5467

SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

5468

SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),

5468

SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),

5469

SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

5469

SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),

5470

SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5470

SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5471

SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5471

SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5472

SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5472

SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5473

SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5473

SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5474

SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5474

SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5475

SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5475

SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5476

SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5476

SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),

5477

SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),

5477

SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),

5478

SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),

5478

SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),

5479

SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),

5479

SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),

5480

SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5480

SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5481

SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5481

SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),

5482

SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),

5482

SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),

5483

SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),

5483

SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),

5484

SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),

5484

SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),

5485

SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),

5485

SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),

5486

/* ALC282 */

5486

/* ALC282 */

5487

SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5487

SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5488

SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5488

SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5489

SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5489

SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5490

SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5490

SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5491

SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5491

SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5492

SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5492

SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5493

SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5493

SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5494

SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5494

SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),

5495

SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5495

SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5496

SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5496

SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5497

SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5497

SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5498

SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5498

SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5499

SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),

5499

SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),

5500

SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),

5500

SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),

5501

SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),

5501

SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),

5502

SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5502

SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5503

SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5503

SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5504

SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5504

SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5505

SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5505

SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5506

SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5506

SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5507

SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),

5507

SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),

5508

SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5508

SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5509

SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5509

SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5510

/* ALC290 */

5510

/* ALC290 */

5511

SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5511

SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5512

SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5512

SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5513

SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5513

SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5514

SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5514

SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5515

SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5515

SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5516

SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5516

SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5517

SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5517

SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5518

SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5518

SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5519

SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5519

SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5520

SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5520

SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5521

SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5521

SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5522

SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5522

SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5523

SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5523

SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5524

SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5524

SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5525

SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5525

SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5526

SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5526

SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5527

SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5527

SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),

5528

SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5528

SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5529

SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5529

SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5530

SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5530

SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5531

SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5531

SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5532

SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5532

SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5533

SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5533

SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5534

SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5534

SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5535

SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5535

SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5536

SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5536

SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5537

SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5537

SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5538

SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5538

SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5539

SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5539

SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),

5540

SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),

5540

SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),

5541

SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),

5541

SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),

5542

SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),

5542

SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),

5543

SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5543

SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5544

SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5544

SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5545

SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),

5545

SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),

5546

SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),

5546

SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),

5547

SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),

5547

SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),

5548

SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),

5548

SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),

5549

SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),

5549

SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),

5550

SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5550

SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5551

SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),

5551

SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),

5552

SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),

5552

SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),

5553

SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

5553

SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

5554

SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

5554

SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),

5555

SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),

5555

SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),

5556

SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

5556

SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

5557

SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

5557

SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),

5558

SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),

5558

SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),

5559

SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

5559

SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

5560

SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

5560

SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),

5561

SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),

5561

SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),

5562

SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),

5562

SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),

5563

SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),

5563

SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),

5564

SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),

5564

SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),

5565

SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),

5565

SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),

5566

SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),

5566

SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),

5567

SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),

5567

SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),

5568

SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),

5568

SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),

5569

SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),

5569

SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),

5570

SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),

5570

SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),

5571

SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

5571

SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

5572

SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),

5572

SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),

5573

SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),

5573

SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),

5574

SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),

5574

SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),

5575

SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),

5575

SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),

5576

SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),

5576

SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),

5577

SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),

5577

SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),

5578

SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),

5578

SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),

5579

SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),

5579

SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),

5580

SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),

5580

SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),

5581

SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),

5581

SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),

5582

SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),

5582

SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),

5583

SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),

5583

SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),

5584

SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),

5584

SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),

5585

SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),

5585

SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),

5586

SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5586

SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5587

SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),

5587

SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),

5588

SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),

5588

SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),

5589

SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),

5589

SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),

5590

SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),

5590

SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),

5591

SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),

5591

SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),

5592

SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),

5592

SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),

5593

SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),

5593

SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),

5594

SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),

5594

SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),

5595

SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),

5595

SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),

5596

SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5596

SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5597

SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),

5597

SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),

5598

SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),

5598

SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),

5599

SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5599

SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5600

SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),

5600

SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),

5601

SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),

5601

SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),

5602

SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),

5602

SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),

5603

SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),

5603

SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),

5604

SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),

5604

SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),

5605

SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5605

SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

5606

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),

5606

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),

5607

SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),

5607

SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),

5608

SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */

5608

SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */

5609

5610

#if 0

5610

#if 0

5611

/* Below is a quirk table taken from the old code.

5611

/* Below is a quirk table taken from the old code.

5612

* Basically the device should work as is without the fixup table.

5612

* Basically the device should work as is without the fixup table.

5613

* If BIOS doesn't give a proper info, enable the corresponding

5613

* If BIOS doesn't give a proper info, enable the corresponding

5614

* fixup entry.

5614

* fixup entry.

5615

*/

5615

*/

5616

SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",

5616

SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",

5617

ALC269_FIXUP_AMIC),

5617

ALC269_FIXUP_AMIC),

5618

SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),

5618

SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),

5619

SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),

5619

SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),

5620

SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),

5620

SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),

5621

SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),

5621

SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),

5622

SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),

5622

SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),

5623

SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),

5623

SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),

5624

SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),

5624

SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),

5625

SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),

5625

SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),

5626

SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),

5626

SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),

5627

SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),

5627

SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),

5628

SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),

5628

SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),

5629

SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),

5629

SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),

5630

SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),

5630

SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),

5631

SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),

5631

SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),

5632

SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),

5632

SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),

5633

SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),

5633

SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),

5634

SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),

5634

SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),

5635

SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),

5635

SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),

5636

SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),

5636

SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),

5637

SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),

5637

SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),

5638

SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),

5638

SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),

5639

SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),

5639

SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),

5640

SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),

5640

SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),

5641

SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),

5641

SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),

5642

SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),

5642

SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),

5643

SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),

5643

SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),

5644

SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),

5644

SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),

5645

SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),

5645

SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),

5646

SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),

5646

SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),

5647

SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),

5647

SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),

5648

SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),

5648

SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),

5649

SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),

5649

SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),

5650

SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),

5650

SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),

5651

SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),

5651

SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),

5652

SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),

5652

SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),

5653

SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),

5653

SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),

5654

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),

5654

SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),

5655

SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),

5655

SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),

5656

SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),

5656

SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),

5657

#endif

5657

#endif

5658

{}

5658

{}

5659

};

5659

};

5660

5661

static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {

5661

static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {

5662

SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),

5662

SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),

5663

SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),

5663

SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),

5664

SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),

5664

SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),

5665

SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),

5665

SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),

5666

{}

5666

{}

5667

};

5667

};

5668

5669

static const struct hda_model_fixup alc269_fixup_models[] = {

5669

static const struct hda_model_fixup alc269_fixup_models[] = {

5670

{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},

5670

{.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},

5671

{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},

5671

{.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},

5672

{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},

5672

{.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},

5673

{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},

5673

{.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},

5674

{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},

5674

{.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},

5675

{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},

5675

{.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},

5676

{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},

5676

{.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},

5677

{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},

5677

{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},

5678

{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},

5678

{.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},

5679

{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},

5679

{.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},

5680

{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

5680

{.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

5681

{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},

5681

{.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},

5682

{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},

5682

{.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},

5683

{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},

5683

{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},

5684

{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},

5684

{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},

5685

{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},

5685

{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},

5686

{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},

5686

{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},

5687

{}

5687

{}

5688

};

5688

};

5689

#define ALC225_STANDARD_PINS \

5689

#define ALC225_STANDARD_PINS \

5690

{0x12, 0xb7a60130}, \

5690

{0x12, 0xb7a60130}, \

5691

{0x21, 0x04211020}

5691

{0x21, 0x04211020}

5692

5693

#define ALC256_STANDARD_PINS \

5693

#define ALC256_STANDARD_PINS \

5694

{0x12, 0x90a60140}, \

5694

{0x12, 0x90a60140}, \

5695

{0x14, 0x90170110}, \

5695

{0x14, 0x90170110}, \

5696

{0x21, 0x02211020}

5696

{0x21, 0x02211020}

5697

5698

#define ALC282_STANDARD_PINS \

5698

#define ALC282_STANDARD_PINS \

5699

{0x14, 0x90170110}

5699

{0x14, 0x90170110}

5700

5701

#define ALC290_STANDARD_PINS \

5701

#define ALC290_STANDARD_PINS \

5702

{0x12, 0x99a30130}

5702

{0x12, 0x99a30130}

5703

5704

#define ALC292_STANDARD_PINS \

5704

#define ALC292_STANDARD_PINS \

5705

{0x14, 0x90170110}, \

5705

{0x14, 0x90170110}, \

5706

{0x15, 0x0221401f}

5706

{0x15, 0x0221401f}

5707

5708

#define ALC298_STANDARD_PINS \

5708

#define ALC298_STANDARD_PINS \

5709

{0x12, 0x90a60130}, \

5709

{0x12, 0x90a60130}, \

5710

{0x21, 0x03211020}

5710

{0x21, 0x03211020}

5711

5712

static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {

5712

static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {

5713

SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

5713

SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

5714

ALC225_STANDARD_PINS,

5714

ALC225_STANDARD_PINS,

5715

{0x14, 0x901701a0}),

5715

{0x14, 0x901701a0}),

5716

SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

5716

SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,

5717

ALC225_STANDARD_PINS,

5717

ALC225_STANDARD_PINS,

5718

{0x14, 0x901701b0}),

5718

{0x14, 0x901701b0}),

5719

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

5719

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,

5720

{0x14, 0x90170110},

5720

{0x14, 0x90170110},

5721

{0x21, 0x02211020}),

5721

{0x21, 0x02211020}),

5722

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5722

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5723

{0x14, 0x90170130},

5724

{0x21, 0x02211040}),

5725

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5723

{0x12, 0x90a60140},

5726

{0x12, 0x90a60140},

5724

{0x14, 0x90170110},

5727

{0x14, 0x90170110},

5725

{0x21, 0x02211020}),

5728

{0x21, 0x02211020}),

5726

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5729

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5727

{0x12, 0x90a60160},

5730

{0x12, 0x90a60160},

5728

{0x14, 0x90170120},

5731

{0x14, 0x90170120},

5729

{0x21, 0x02211030}),

5732

{0x21, 0x02211030}),

5730

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5733

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5731

{0x14, 0x90170130},

5734

{0x14, 0x90170130},

5732

{0x1b, 0x01014020},

5735

{0x1b, 0x01014020},

5733

{0x21, 0x0221103f}),

5736

{0x21, 0x0221103f}),

5734

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5737

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5735

{0x14, 0x90170150},

5738

{0x14, 0x90170150},

5736

{0x1b, 0x02011020},

5739

{0x1b, 0x02011020},

5737

{0x21, 0x0221105f}),

5740

{0x21, 0x0221105f}),

5738

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5741

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5739

{0x14, 0x90170110},

5742

{0x14, 0x90170110},

5740

{0x1b, 0x01014020},

5743

{0x1b, 0x01014020},

5741

{0x21, 0x0221101f}),

5744

{0x21, 0x0221101f}),

5742

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5745

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5743

{0x12, 0x90a60160},

5746

{0x12, 0x90a60160},

5744

{0x14, 0x90170120},

5747

{0x14, 0x90170120},

5745

{0x17, 0x90170140},

5748

{0x17, 0x90170140},

5746

{0x21, 0x0321102f}),

5749

{0x21, 0x0321102f}),

5747

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5750

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5748

{0x12, 0x90a60160},

5751

{0x12, 0x90a60160},

5749

{0x14, 0x90170130},

5752

{0x14, 0x90170130},

5750

{0x21, 0x02211040}),

5753

{0x21, 0x02211040}),

5751

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5754

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5752

{0x12, 0x90a60160},

5755

{0x12, 0x90a60160},

5753

{0x14, 0x90170140},

5756

{0x14, 0x90170140},

5754

{0x21, 0x02211050}),

5757

{0x21, 0x02211050}),

5755

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5758

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5756

{0x12, 0x90a60170},

5759

{0x12, 0x90a60170},

5757

{0x14, 0x90170120},

5760

{0x14, 0x90170120},

5758

{0x21, 0x02211030}),

5761

{0x21, 0x02211030}),

5759

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5762

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5760

{0x12, 0x90a60170},

5763

{0x12, 0x90a60170},

5761

{0x14, 0x90170130},

5764

{0x14, 0x90170130},

5762

{0x21, 0x02211040}),

5765

{0x21, 0x02211040}),

5763

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5766

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5764

{0x12, 0x90a60170},

5767

{0x12, 0x90a60170},

5765

{0x14, 0x90171130},

5768

{0x14, 0x90171130},

5766

{0x21, 0x02211040}),

5769

{0x21, 0x02211040}),

5767

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5770

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5768

{0x12, 0x90a60170},

5771

{0x12, 0x90a60170},

5769

{0x14, 0x90170140},

5772

{0x14, 0x90170140},

5770

{0x21, 0x02211050}),

5773

{0x21, 0x02211050}),

5771

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5774

SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5772

{0x12, 0x90a60180},

5775

{0x12, 0x90a60180},

5773

{0x14, 0x90170130},

5776

{0x14, 0x90170130},

5774

{0x21, 0x02211040}),

5777

{0x21, 0x02211040}),

5775

SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5778

SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5776

{0x12, 0x90a60160},

5779

{0x12, 0x90a60160},

5777

{0x14, 0x90170120},

5780

{0x14, 0x90170120},

5778

{0x21, 0x02211030}),

5781

{0x21, 0x02211030}),

5779

SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5782

SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,

5780

ALC256_STANDARD_PINS),

5783

ALC256_STANDARD_PINS),

5781

SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,

5784

SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,

5782

{0x12, 0x90a60130},

5785

{0x12, 0x90a60130},

5783

{0x14, 0x90170110},

5786

{0x14, 0x90170110},

5784

{0x15, 0x0421101f},

5787

{0x15, 0x0421101f},

5785

{0x1a, 0x04a11020}),

5788

{0x1a, 0x04a11020}),

5786

SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,

5789

SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,

5787

{0x12, 0x90a60140},

5790

{0x12, 0x90a60140},

5788

{0x14, 0x90170110},

5791

{0x14, 0x90170110},

5789

{0x15, 0x0421101f},

5792

{0x15, 0x0421101f},

5790

{0x18, 0x02811030},

5793

{0x18, 0x02811030},

5791

{0x1a, 0x04a1103f},

5794

{0x1a, 0x04a1103f},

5792

{0x1b, 0x02011020}),

5795

{0x1b, 0x02011020}),

5793

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5796

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5794

ALC282_STANDARD_PINS,

5797

ALC282_STANDARD_PINS,

5795

{0x12, 0x99a30130},

5798

{0x12, 0x99a30130},

5796

{0x19, 0x03a11020},

5799

{0x19, 0x03a11020},

5797

{0x21, 0x0321101f}),

5800

{0x21, 0x0321101f}),

5798

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5801

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5799

ALC282_STANDARD_PINS,

5802

ALC282_STANDARD_PINS,

5800

{0x12, 0x99a30130},

5803

{0x12, 0x99a30130},

5801

{0x19, 0x03a11020},

5804

{0x19, 0x03a11020},

5802

{0x21, 0x03211040}),

5805

{0x21, 0x03211040}),

5803

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5806

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5804

ALC282_STANDARD_PINS,

5807

ALC282_STANDARD_PINS,

5805

{0x12, 0x99a30130},

5808

{0x12, 0x99a30130},

5806

{0x19, 0x03a11030},

5809

{0x19, 0x03a11030},

5807

{0x21, 0x03211020}),

5810

{0x21, 0x03211020}),

5808

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5811

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5809

ALC282_STANDARD_PINS,

5812

ALC282_STANDARD_PINS,

5810

{0x12, 0x99a30130},

5813

{0x12, 0x99a30130},

5811

{0x19, 0x04a11020},

5814

{0x19, 0x04a11020},

5812

{0x21, 0x0421101f}),

5815

{0x21, 0x0421101f}),

5813

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,

5816

SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,

5814

ALC282_STANDARD_PINS,

5817

ALC282_STANDARD_PINS,

5815

{0x12, 0x90a60140},

5818

{0x12, 0x90a60140},

5816

{0x19, 0x04a11030},

5819

{0x19, 0x04a11030},

5817

{0x21, 0x04211020}),

5820

{0x21, 0x04211020}),

5818

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5821

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5819

ALC282_STANDARD_PINS,

5822

ALC282_STANDARD_PINS,

5820

{0x12, 0x90a60130},

5823

{0x12, 0x90a60130},

5821

{0x21, 0x0321101f}),

5824

{0x21, 0x0321101f}),

5822

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5825

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5823

{0x12, 0x90a60160},

5826

{0x12, 0x90a60160},

5824

{0x14, 0x90170120},

5827

{0x14, 0x90170120},

5825

{0x21, 0x02211030}),

5828

{0x21, 0x02211030}),

5826

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5829

SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,

5827

ALC282_STANDARD_PINS,

5830

ALC282_STANDARD_PINS,

5828

{0x12, 0x90a60130},

5831

{0x12, 0x90a60130},

5829

{0x19, 0x03a11020},

5832

{0x19, 0x03a11020},

5830

{0x21, 0x0321101f}),

5833

{0x21, 0x0321101f}),

5831

SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,

5834

SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,

5832

{0x12, 0x90a60120},

5835

{0x12, 0x90a60120},

5833

{0x14, 0x90170110},

5836

{0x14, 0x90170110},

5834

{0x21, 0x0321101f}),

5837

{0x21, 0x0321101f}),

5835

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5838

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5836

ALC290_STANDARD_PINS,

5839

ALC290_STANDARD_PINS,

5837

{0x15, 0x04211040},

5840

{0x15, 0x04211040},

5838

{0x18, 0x90170112},

5841

{0x18, 0x90170112},

5839

{0x1a, 0x04a11020}),

5842

{0x1a, 0x04a11020}),

5840

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5843

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5841

ALC290_STANDARD_PINS,

5844

ALC290_STANDARD_PINS,

5842

{0x15, 0x04211040},

5845

{0x15, 0x04211040},

5843

{0x18, 0x90170110},

5846

{0x18, 0x90170110},

5844

{0x1a, 0x04a11020}),

5847

{0x1a, 0x04a11020}),

5845

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5848

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5846

ALC290_STANDARD_PINS,

5849

ALC290_STANDARD_PINS,

5847

{0x15, 0x0421101f},

5850

{0x15, 0x0421101f},

5848

{0x1a, 0x04a11020}),

5851

{0x1a, 0x04a11020}),

5849

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5852

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5850

ALC290_STANDARD_PINS,

5853

ALC290_STANDARD_PINS,

5851

{0x15, 0x04211020},

5854

{0x15, 0x04211020},

5852

{0x1a, 0x04a11040}),

5855

{0x1a, 0x04a11040}),

5853

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5856

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5854

ALC290_STANDARD_PINS,

5857

ALC290_STANDARD_PINS,

5855

{0x14, 0x90170110},

5858

{0x14, 0x90170110},

5856

{0x15, 0x04211020},

5859

{0x15, 0x04211020},

5857

{0x1a, 0x04a11040}),

5860

{0x1a, 0x04a11040}),

5858

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5861

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5859

ALC290_STANDARD_PINS,

5862

ALC290_STANDARD_PINS,

5860

{0x14, 0x90170110},

5863

{0x14, 0x90170110},

5861

{0x15, 0x04211020},

5864

{0x15, 0x04211020},

5862

{0x1a, 0x04a11020}),

5865

{0x1a, 0x04a11020}),

5863

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5866

SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,

5864

ALC290_STANDARD_PINS,

5867

ALC290_STANDARD_PINS,

5865

{0x14, 0x90170110},

5868

{0x14, 0x90170110},

5866

{0x15, 0x0421101f},

5869

{0x15, 0x0421101f},

5867

{0x1a, 0x04a11020}),

5870

{0x1a, 0x04a11020}),

5868

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

5871

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

5869

ALC292_STANDARD_PINS,

5872

ALC292_STANDARD_PINS,

5870

{0x12, 0x90a60140},

5873

{0x12, 0x90a60140},

5871

{0x16, 0x01014020},

5874

{0x16, 0x01014020},

5872

{0x19, 0x01a19030}),

5875

{0x19, 0x01a19030}),

5873

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

5876

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,

5874

ALC292_STANDARD_PINS,

5877

ALC292_STANDARD_PINS,

5875

{0x12, 0x90a60140},

5878

{0x12, 0x90a60140},

5876

{0x16, 0x01014020},

5879

{0x16, 0x01014020},

5877

{0x18, 0x02a19031},

5880

{0x18, 0x02a19031},

5878

{0x19, 0x01a1903e}),

5881

{0x19, 0x01a1903e}),

5879

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

5882

SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,

5880

ALC292_STANDARD_PINS,

5883

ALC292_STANDARD_PINS,

5881

{0x12, 0x90a60140}),

5884

{0x12, 0x90a60140}),

5882

SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

5885

SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

5883

ALC292_STANDARD_PINS,

5886

ALC292_STANDARD_PINS,

5884

{0x13, 0x90a60140},

5887

{0x13, 0x90a60140},

5885

{0x16, 0x21014020},

5888

{0x16, 0x21014020},

5886

{0x19, 0x21a19030}),

5889

{0x19, 0x21a19030}),

5887

SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

5890

SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,

5888

ALC292_STANDARD_PINS,

5891

ALC292_STANDARD_PINS,

5889

{0x13, 0x90a60140}),

5892

{0x13, 0x90a60140}),

5890

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5893

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5891

ALC298_STANDARD_PINS,

5894

ALC298_STANDARD_PINS,

5892

{0x17, 0x90170110}),

5895

{0x17, 0x90170110}),

5893

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5896

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5894

ALC298_STANDARD_PINS,

5897

ALC298_STANDARD_PINS,

5895

{0x17, 0x90170140}),

5898

{0x17, 0x90170140}),

5896

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5899

SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,

5897

ALC298_STANDARD_PINS,

5900

ALC298_STANDARD_PINS,

5898

{0x17, 0x90170150}),

5901

{0x17, 0x90170150}),

5899

{}

5902

{}

5900

};

5903

};

5901

5904

5902

static void alc269_fill_coef(struct hda_codec *codec)

5905

static void alc269_fill_coef(struct hda_codec *codec)

5903

{

5906

{

5904

struct alc_spec *spec = codec->spec;

5907

struct alc_spec *spec = codec->spec;

5905

int val;

5908

int val;

5906

5909

5907

if (spec->codec_variant != ALC269_TYPE_ALC269VB)

5910

if (spec->codec_variant != ALC269_TYPE_ALC269VB)

5908

return;

5911

return;

5909

5912

5910

if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {

5913

if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {

5911

alc_write_coef_idx(codec, 0xf, 0x960b);

5914

alc_write_coef_idx(codec, 0xf, 0x960b);

5912

alc_write_coef_idx(codec, 0xe, 0x8817);

5915

alc_write_coef_idx(codec, 0xe, 0x8817);

5913

}

5916

}

5914

5917

5915

if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {

5918

if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {

5916

alc_write_coef_idx(codec, 0xf, 0x960b);

5919

alc_write_coef_idx(codec, 0xf, 0x960b);

5917

alc_write_coef_idx(codec, 0xe, 0x8814);

5920

alc_write_coef_idx(codec, 0xe, 0x8814);

5918

}

5921

}

5919

5922

5920

if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {

5923

if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {

5921

/* Power up output pin */

5924

/* Power up output pin */

5922

alc_update_coef_idx(codec, 0x04, 0, 1<<11);

5925

alc_update_coef_idx(codec, 0x04, 0, 1<<11);

5923

}

5926

}

5924

5927

5925

if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {

5928

if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {

5926

val = alc_read_coef_idx(codec, 0xd);

5929

val = alc_read_coef_idx(codec, 0xd);

5927

if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {

5930

if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {

5928

/* Capless ramp up clock control */

5931

/* Capless ramp up clock control */

5929

alc_write_coef_idx(codec, 0xd, val | (1<<10));

5932

alc_write_coef_idx(codec, 0xd, val | (1<<10));

5930

}

5933

}

5931

val = alc_read_coef_idx(codec, 0x17);

5934

val = alc_read_coef_idx(codec, 0x17);

5932

if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {

5935

if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {

5933

/* Class D power on reset */

5936

/* Class D power on reset */

5934

alc_write_coef_idx(codec, 0x17, val | (1<<7));

5937

alc_write_coef_idx(codec, 0x17, val | (1<<7));

5935

}

5938

}

5936

}

5939

}

5937

5940

5938

/* HP */

5941

/* HP */

5939

alc_update_coef_idx(codec, 0x4, 0, 1<<11);

5942

alc_update_coef_idx(codec, 0x4, 0, 1<<11);

5940

}

5943

}

5941

5944

5942

/*

5945

/*

5943

*/

5946

*/

5944

static int patch_alc269(struct hda_codec *codec)

5947

static int patch_alc269(struct hda_codec *codec)

5945

{

5948

{

5946

struct alc_spec *spec;

5949

struct alc_spec *spec;

5947

int err;

5950

int err;

5948

5951

5949

err = alc_alloc_spec(codec, 0x0b);

5952

err = alc_alloc_spec(codec, 0x0b);

5950

if (err < 0)

5953

if (err < 0)

5951

return err;

5954

return err;

5952

5955

5953

spec = codec->spec;

5956

spec = codec->spec;

5954

spec->gen.shared_mic_vref_pin = 0x18;

5957

spec->gen.shared_mic_vref_pin = 0x18;

5955

codec->power_save_node = 1;

5958

codec->power_save_node = 1;

5956

5959

5957

#ifdef CONFIG_PM

5960

#ifdef CONFIG_PM

5958

codec->patch_ops.suspend = alc269_suspend;

5961

codec->patch_ops.suspend = alc269_suspend;

5959

codec->patch_ops.resume = alc269_resume;

5962

codec->patch_ops.resume = alc269_resume;

5960

#endif

5963

#endif

5961

spec->shutup = alc269_shutup;

5964

spec->shutup = alc269_shutup;

5962

5965

5963

snd_hda_pick_fixup(codec, alc269_fixup_models,

5966

snd_hda_pick_fixup(codec, alc269_fixup_models,

5964

alc269_fixup_tbl, alc269_fixups);

5967

alc269_fixup_tbl, alc269_fixups);

5965

snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);

5968

snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);

5966

snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,

5969

snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,

5967

alc269_fixups);

5970

alc269_fixups);

5968

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5971

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5969

5972

5970

alc_auto_parse_customize_define(codec);

5973

alc_auto_parse_customize_define(codec);

5971

5974

5972

if (has_cdefine_beep(codec))

5975

if (has_cdefine_beep(codec))

5973

spec->gen.beep_nid = 0x01;

5976

spec->gen.beep_nid = 0x01;

5974

5977

5975

switch (codec->core.vendor_id) {

5978

switch (codec->core.vendor_id) {

5976

case 0x10ec0269:

5979

case 0x10ec0269:

5977

spec->codec_variant = ALC269_TYPE_ALC269VA;

5980

spec->codec_variant = ALC269_TYPE_ALC269VA;

5978

switch (alc_get_coef0(codec) & 0x00f0) {

5981

switch (alc_get_coef0(codec) & 0x00f0) {

5979

case 0x0010:

5982

case 0x0010:

5980

if (codec->bus->pci &&

5983

if (codec->bus->pci &&

5981

codec->bus->pci->subsystem_vendor == 0x1025 &&

5984

codec->bus->pci->subsystem_vendor == 0x1025 &&

5982

spec->cdefine.platform_type == 1)

5985

spec->cdefine.platform_type == 1)

5983

err = alc_codec_rename(codec, "ALC271X");

5986

err = alc_codec_rename(codec, "ALC271X");

5984

spec->codec_variant = ALC269_TYPE_ALC269VB;

5987

spec->codec_variant = ALC269_TYPE_ALC269VB;

5985

break;

5988

break;

5986

case 0x0020:

5989

case 0x0020:

5987

if (codec->bus->pci &&

5990

if (codec->bus->pci &&

5988

codec->bus->pci->subsystem_vendor == 0x17aa &&

5991

codec->bus->pci->subsystem_vendor == 0x17aa &&

5989

codec->bus->pci->subsystem_device == 0x21f3)

5992

codec->bus->pci->subsystem_device == 0x21f3)

5990

err = alc_codec_rename(codec, "ALC3202");

5993

err = alc_codec_rename(codec, "ALC3202");

5991

spec->codec_variant = ALC269_TYPE_ALC269VC;

5994

spec->codec_variant = ALC269_TYPE_ALC269VC;

5992

break;

5995

break;

5993

case 0x0030:

5996

case 0x0030:

5994

spec->codec_variant = ALC269_TYPE_ALC269VD;

5997

spec->codec_variant = ALC269_TYPE_ALC269VD;

5995

break;

5998

break;

5996

default:

5999

default:

5997

alc_fix_pll_init(codec, 0x20, 0x04, 15);

6000

alc_fix_pll_init(codec, 0x20, 0x04, 15);

5998

}

6001

}

5999

if (err < 0)

6002

if (err < 0)

6000

goto error;

6003

goto error;

6001

spec->init_hook = alc269_fill_coef;

6004

spec->init_hook = alc269_fill_coef;

6002

alc269_fill_coef(codec);

6005

alc269_fill_coef(codec);

6003

break;

6006

break;

6004

6007

6005

case 0x10ec0280:

6008

case 0x10ec0280:

6006

case 0x10ec0290:

6009

case 0x10ec0290:

6007

spec->codec_variant = ALC269_TYPE_ALC280;

6010

spec->codec_variant = ALC269_TYPE_ALC280;

6008

break;

6011

break;

6009

case 0x10ec0282:

6012

case 0x10ec0282:

6010

spec->codec_variant = ALC269_TYPE_ALC282;

6013

spec->codec_variant = ALC269_TYPE_ALC282;

6011

spec->shutup = alc282_shutup;

6014

spec->shutup = alc282_shutup;

6012

spec->init_hook = alc282_init;

6015

spec->init_hook = alc282_init;

6013

break;

6016

break;

6014

case 0x10ec0233:

6017

case 0x10ec0233:

6015

case 0x10ec0283:

6018

case 0x10ec0283:

6016

spec->codec_variant = ALC269_TYPE_ALC283;

6019

spec->codec_variant = ALC269_TYPE_ALC283;

6017

spec->shutup = alc283_shutup;

6020

spec->shutup = alc283_shutup;

6018

spec->init_hook = alc283_init;

6021

spec->init_hook = alc283_init;

6019

break;

6022

break;

6020

case 0x10ec0284:

6023

case 0x10ec0284:

6021

case 0x10ec0292:

6024

case 0x10ec0292:

6022

spec->codec_variant = ALC269_TYPE_ALC284;

6025

spec->codec_variant = ALC269_TYPE_ALC284;

6023

break;

6026

break;

6024

case 0x10ec0285:

6027

case 0x10ec0285:

6025

case 0x10ec0293:

6028

case 0x10ec0293:

6026

spec->codec_variant = ALC269_TYPE_ALC285;

6029

spec->codec_variant = ALC269_TYPE_ALC285;

6027

break;

6030

break;

6028

case 0x10ec0286:

6031

case 0x10ec0286:

6029

case 0x10ec0288:

6032

case 0x10ec0288:

6030

spec->codec_variant = ALC269_TYPE_ALC286;

6033

spec->codec_variant = ALC269_TYPE_ALC286;

6031

spec->shutup = alc286_shutup;

6034

spec->shutup = alc286_shutup;

6032

break;

6035

break;

6033

case 0x10ec0298:

6036

case 0x10ec0298:

6034

spec->codec_variant = ALC269_TYPE_ALC298;

6037

spec->codec_variant = ALC269_TYPE_ALC298;

6035

break;

6038

break;

6036

case 0x10ec0255:

6039

case 0x10ec0255:

6037

spec->codec_variant = ALC269_TYPE_ALC255;

6040

spec->codec_variant = ALC269_TYPE_ALC255;

6038

break;

6041

break;

6039

case 0x10ec0256:

6042

case 0x10ec0256:

6040

spec->codec_variant = ALC269_TYPE_ALC256;

6043

spec->codec_variant = ALC269_TYPE_ALC256;

6041

spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */

6044

spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */

6042

alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/

6045

alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/

6043

break;

6046

break;

6044

case 0x10ec0225:

6047

case 0x10ec0225:

6045

case 0x10ec0295:

6048

case 0x10ec0295:

6046

spec->codec_variant = ALC269_TYPE_ALC225;

6049

spec->codec_variant = ALC269_TYPE_ALC225;

6047

break;

6050

break;

6048

case 0x10ec0234:

6051

case 0x10ec0234:

6049

case 0x10ec0274:

6052

case 0x10ec0274:

6050

case 0x10ec0294:

6053

case 0x10ec0294:

6051

spec->codec_variant = ALC269_TYPE_ALC294;

6054

spec->codec_variant = ALC269_TYPE_ALC294;

6052

break;

6055

break;

6053

}

6056

}

6054

6057

6055

if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {

6058

if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {

6056

spec->has_alc5505_dsp = 1;

6059

spec->has_alc5505_dsp = 1;

6057

spec->init_hook = alc5505_dsp_init;

6060

spec->init_hook = alc5505_dsp_init;

6058

}

6061

}

6059

6062

6060

/* automatic parse from the BIOS config */

6063

/* automatic parse from the BIOS config */

6061

err = alc269_parse_auto_config(codec);

6064

err = alc269_parse_auto_config(codec);

6062

if (err < 0)

6065

if (err < 0)

6063

goto error;

6066

goto error;

6064

6067

6065

if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)

6068

if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)

6066

set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);

6069

set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);

6067

6070

6068

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6071

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6069

6072

6070

return 0;

6073

return 0;

6071

6074

6072

error:

6075

error:

6073

alc_free(codec);

6076

alc_free(codec);

6074

return err;

6077

return err;

6075

}

6078

}

6076

6079

6077

/*

6080

/*

6078

* ALC861

6081

* ALC861

6079

*/

6082

*/

6080

6083

6081

static int alc861_parse_auto_config(struct hda_codec *codec)

6084

static int alc861_parse_auto_config(struct hda_codec *codec)

6082

{

6085

{

6083

static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };

6086

static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };

6084

static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };

6087

static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };

6085

return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);

6088

return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);

6086

}

6089

}

6087

6090

6088

/* Pin config fixes */

6091

/* Pin config fixes */

6089

enum {

6092

enum {

6090

ALC861_FIXUP_FSC_AMILO_PI1505,

6093

ALC861_FIXUP_FSC_AMILO_PI1505,

6091

ALC861_FIXUP_AMP_VREF_0F,

6094

ALC861_FIXUP_AMP_VREF_0F,

6092

ALC861_FIXUP_NO_JACK_DETECT,

6095

ALC861_FIXUP_NO_JACK_DETECT,

6093

ALC861_FIXUP_ASUS_A6RP,

6096

ALC861_FIXUP_ASUS_A6RP,

6094

ALC660_FIXUP_ASUS_W7J,

6097

ALC660_FIXUP_ASUS_W7J,

6095

};

6098

};

6096

6099

6097

/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */

6100

/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */

6098

static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,

6101

static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,

6099

const struct hda_fixup *fix, int action)

6102

const struct hda_fixup *fix, int action)

6100

{

6103

{

6101

struct alc_spec *spec = codec->spec;

6104

struct alc_spec *spec = codec->spec;

6102

unsigned int val;

6105

unsigned int val;

6103

6106

6104

if (action != HDA_FIXUP_ACT_INIT)

6107

if (action != HDA_FIXUP_ACT_INIT)

6105

return;

6108

return;

6106

val = snd_hda_codec_get_pin_target(codec, 0x0f);

6109

val = snd_hda_codec_get_pin_target(codec, 0x0f);

6107

if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))

6110

if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))

6108

val |= AC_PINCTL_IN_EN;

6111

val |= AC_PINCTL_IN_EN;

6109

val |= AC_PINCTL_VREF_50;

6112

val |= AC_PINCTL_VREF_50;

6110

snd_hda_set_pin_ctl(codec, 0x0f, val);

6113

snd_hda_set_pin_ctl(codec, 0x0f, val);

6111

spec->gen.keep_vref_in_automute = 1;

6114

spec->gen.keep_vref_in_automute = 1;

6112

}

6115

}

6113

6116

6114

/* suppress the jack-detection */

6117

/* suppress the jack-detection */

6115

static void alc_fixup_no_jack_detect(struct hda_codec *codec,

6118

static void alc_fixup_no_jack_detect(struct hda_codec *codec,

6116

const struct hda_fixup *fix, int action)

6119

const struct hda_fixup *fix, int action)

6117

{

6120

{

6118

if (action == HDA_FIXUP_ACT_PRE_PROBE)

6121

if (action == HDA_FIXUP_ACT_PRE_PROBE)

6119

codec->no_jack_detect = 1;

6122

codec->no_jack_detect = 1;

6120

}

6123

}

6121

6124

6122

static const struct hda_fixup alc861_fixups[] = {

6125

static const struct hda_fixup alc861_fixups[] = {

6123

[ALC861_FIXUP_FSC_AMILO_PI1505] = {

6126

[ALC861_FIXUP_FSC_AMILO_PI1505] = {

6124

.type = HDA_FIXUP_PINS,

6127

.type = HDA_FIXUP_PINS,

6125

.v.pins = (const struct hda_pintbl[]) {

6128

.v.pins = (const struct hda_pintbl[]) {

6126

{ 0x0b, 0x0221101f }, /* HP */

6129

{ 0x0b, 0x0221101f }, /* HP */

6127

{ 0x0f, 0x90170310 }, /* speaker */

6130

{ 0x0f, 0x90170310 }, /* speaker */

6128

{ }

6131

{ }

6129

}

6132

}

6130

},

6133

},

6131

[ALC861_FIXUP_AMP_VREF_0F] = {

6134

[ALC861_FIXUP_AMP_VREF_0F] = {

6132

.type = HDA_FIXUP_FUNC,

6135

.type = HDA_FIXUP_FUNC,

6133

.v.func = alc861_fixup_asus_amp_vref_0f,

6136

.v.func = alc861_fixup_asus_amp_vref_0f,

6134

},

6137

},

6135

[ALC861_FIXUP_NO_JACK_DETECT] = {

6138

[ALC861_FIXUP_NO_JACK_DETECT] = {

6136

.type = HDA_FIXUP_FUNC,

6139

.type = HDA_FIXUP_FUNC,

6137

.v.func = alc_fixup_no_jack_detect,

6140

.v.func = alc_fixup_no_jack_detect,

6138

},

6141

},

6139

[ALC861_FIXUP_ASUS_A6RP] = {

6142

[ALC861_FIXUP_ASUS_A6RP] = {

6140

.type = HDA_FIXUP_FUNC,

6143

.type = HDA_FIXUP_FUNC,

6141

.v.func = alc861_fixup_asus_amp_vref_0f,

6144

.v.func = alc861_fixup_asus_amp_vref_0f,

6142

.chained = true,

6145

.chained = true,

6143

.chain_id = ALC861_FIXUP_NO_JACK_DETECT,

6146

.chain_id = ALC861_FIXUP_NO_JACK_DETECT,

6144

},

6147

},

6145

[ALC660_FIXUP_ASUS_W7J] = {

6148

[ALC660_FIXUP_ASUS_W7J] = {

6146

.type = HDA_FIXUP_VERBS,

6149

.type = HDA_FIXUP_VERBS,

6147

.v.verbs = (const struct hda_verb[]) {

6150

.v.verbs = (const struct hda_verb[]) {

6148

/* ASUS W7J needs a magic pin setup on unused NID 0x10

6151

/* ASUS W7J needs a magic pin setup on unused NID 0x10

6149

* for enabling outputs

6152

* for enabling outputs

6150

*/

6153

*/

6151

{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},

6154

{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},

6152

{ }

6155

{ }

6153

},

6156

},

6154

}

6157

}

6155

};

6158

};

6156

6159

6157

static const struct snd_pci_quirk alc861_fixup_tbl[] = {

6160

static const struct snd_pci_quirk alc861_fixup_tbl[] = {

6158

SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),

6161

SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),

6159

SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),

6162

SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),

6160

SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),

6163

SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),

6161

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),

6164

SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),

6162

SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),

6165

SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),

6163

SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),

6166

SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),

6164

SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),

6167

SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),

6165

SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),

6168

SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),

6166

{}

6169

{}

6167

};

6170

};

6168

6171

6169

/*

6172

/*

6170

*/

6173

*/

6171

static int patch_alc861(struct hda_codec *codec)

6174

static int patch_alc861(struct hda_codec *codec)

6172

{

6175

{

6173

struct alc_spec *spec;

6176

struct alc_spec *spec;

6174

int err;

6177

int err;

6175

6178

6176

err = alc_alloc_spec(codec, 0x15);

6179

err = alc_alloc_spec(codec, 0x15);

6177

if (err < 0)

6180

if (err < 0)

6178

return err;

6181

return err;

6179

6182

6180

spec = codec->spec;

6183

spec = codec->spec;

6181

spec->gen.beep_nid = 0x23;

6184

spec->gen.beep_nid = 0x23;

6182

6185

6183

#ifdef CONFIG_PM

6186

#ifdef CONFIG_PM

6184

spec->power_hook = alc_power_eapd;

6187

spec->power_hook = alc_power_eapd;

6185

#endif

6188

#endif

6186

6189

6187

snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);

6190

snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);

6188

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6191

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6189

6192

6190

/* automatic parse from the BIOS config */

6193

/* automatic parse from the BIOS config */

6191

err = alc861_parse_auto_config(codec);

6194

err = alc861_parse_auto_config(codec);

6192

if (err < 0)

6195

if (err < 0)

6193

goto error;

6196

goto error;

6194

6197

6195

if (!spec->gen.no_analog)

6198

if (!spec->gen.no_analog)

6196

set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);

6199

set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);

6197

6200

6198

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6201

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6199

6202

6200

return 0;

6203

return 0;

6201

6204

6202

error:

6205

error:

6203

alc_free(codec);

6206

alc_free(codec);

6204

return err;

6207

return err;

6205

}

6208

}

6206

6209

6207

/*

6210

/*

6208

* ALC861-VD support

6211

* ALC861-VD support

6209

*

6212

*

6210

* Based on ALC882

6213

* Based on ALC882

6211

*

6214

*

6212

* In addition, an independent DAC

6215

* In addition, an independent DAC

6213

*/

6216

*/

6214

static int alc861vd_parse_auto_config(struct hda_codec *codec)

6217

static int alc861vd_parse_auto_config(struct hda_codec *codec)

6215

{

6218

{

6216

static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };

6219

static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };

6217

static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };

6220

static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };

6218

return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);

6221

return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);

6219

}

6222

}

6220

6223

6221

enum {

6224

enum {

6222

ALC660VD_FIX_ASUS_GPIO1,

6225

ALC660VD_FIX_ASUS_GPIO1,

6223

ALC861VD_FIX_DALLAS,

6226

ALC861VD_FIX_DALLAS,

6224

};

6227

};

6225

6228

6226

/* exclude VREF80 */

6229

/* exclude VREF80 */

6227

static void alc861vd_fixup_dallas(struct hda_codec *codec,

6230

static void alc861vd_fixup_dallas(struct hda_codec *codec,

6228

const struct hda_fixup *fix, int action)

6231

const struct hda_fixup *fix, int action)

6229

{

6232

{

6230

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

6233

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

6231

snd_hda_override_pin_caps(codec, 0x18, 0x00000734);

6234

snd_hda_override_pin_caps(codec, 0x18, 0x00000734);

6232

snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);

6235

snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);

6233

}

6236

}

6234

}

6237

}

6235

6238

6236

static const struct hda_fixup alc861vd_fixups[] = {

6239

static const struct hda_fixup alc861vd_fixups[] = {

6237

[ALC660VD_FIX_ASUS_GPIO1] = {

6240

[ALC660VD_FIX_ASUS_GPIO1] = {

6238

.type = HDA_FIXUP_VERBS,

6241

.type = HDA_FIXUP_VERBS,

6239

.v.verbs = (const struct hda_verb[]) {

6242

.v.verbs = (const struct hda_verb[]) {

6240

/* reset GPIO1 */

6243

/* reset GPIO1 */

6241

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

6244

{0x01, AC_VERB_SET_GPIO_MASK, 0x03},

6242

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

6245

{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},

6243

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

6246

{0x01, AC_VERB_SET_GPIO_DATA, 0x01},

6244

{ }

6247

{ }

6245

}

6248

}

6246

},

6249

},

6247

[ALC861VD_FIX_DALLAS] = {

6250

[ALC861VD_FIX_DALLAS] = {

6248

.type = HDA_FIXUP_FUNC,

6251

.type = HDA_FIXUP_FUNC,

6249

.v.func = alc861vd_fixup_dallas,

6252

.v.func = alc861vd_fixup_dallas,

6250

},

6253

},

6251

};

6254

};

6252

6255

6253

static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {

6256

static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {

6254

SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),

6257

SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),

6255

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),

6258

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),

6256

SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),

6259

SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),

6257

{}

6260

{}

6258

};

6261

};

6259

6262

6260

/*

6263

/*

6261

*/

6264

*/

6262

static int patch_alc861vd(struct hda_codec *codec)

6265

static int patch_alc861vd(struct hda_codec *codec)

6263

{

6266

{

6264

struct alc_spec *spec;

6267

struct alc_spec *spec;

6265

int err;

6268

int err;

6266

6269

6267

err = alc_alloc_spec(codec, 0x0b);

6270

err = alc_alloc_spec(codec, 0x0b);

6268

if (err < 0)

6271

if (err < 0)

6269

return err;

6272

return err;

6270

6273

6271

spec = codec->spec;

6274

spec = codec->spec;

6272

spec->gen.beep_nid = 0x23;

6275

spec->gen.beep_nid = 0x23;

6273

6276

6274

spec->shutup = alc_eapd_shutup;

6277

spec->shutup = alc_eapd_shutup;

6275

6278

6276

snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);

6279

snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);

6277

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6280

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6278

6281

6279

/* automatic parse from the BIOS config */

6282

/* automatic parse from the BIOS config */

6280

err = alc861vd_parse_auto_config(codec);

6283

err = alc861vd_parse_auto_config(codec);

6281

if (err < 0)

6284

if (err < 0)

6282

goto error;

6285

goto error;

6283

6286

6284

if (!spec->gen.no_analog)

6287

if (!spec->gen.no_analog)

6285

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

6288

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

6286

6289

6287

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6290

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6288

6291

6289

return 0;

6292

return 0;

6290

6293

6291

error:

6294

error:

6292

alc_free(codec);

6295

alc_free(codec);

6293

return err;

6296

return err;

6294

}

6297

}

6295

6298

6296

/*

6299

/*

6297

* ALC662 support

6300

* ALC662 support

6298

*

6301

*

6299

* ALC662 is almost identical with ALC880 but has cleaner and more flexible

6302

* ALC662 is almost identical with ALC880 but has cleaner and more flexible

6300

* configuration. Each pin widget can choose any input DACs and a mixer.

6303

* configuration. Each pin widget can choose any input DACs and a mixer.

6301

* Each ADC is connected from a mixer of all inputs. This makes possible

6304

* Each ADC is connected from a mixer of all inputs. This makes possible

6302

* 6-channel independent captures.

6305

* 6-channel independent captures.

6303

*

6306

*

6304

* In addition, an independent DAC for the multi-playback (not used in this

6307

* In addition, an independent DAC for the multi-playback (not used in this

6305

* driver yet).

6308

* driver yet).

6306

*/

6309

*/

6307

6310

6308

/*

6311

/*

6309

* BIOS auto configuration

6312

* BIOS auto configuration

6310

*/

6313

*/

6311

6314

6312

static int alc662_parse_auto_config(struct hda_codec *codec)

6315

static int alc662_parse_auto_config(struct hda_codec *codec)

6313

{

6316

{

6314

static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };

6317

static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };

6315

static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };

6318

static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };

6316

static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };

6319

static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };

6317

const hda_nid_t *ssids;

6320

const hda_nid_t *ssids;

6318

6321

6319

if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||

6322

if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||

6320

codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||

6323

codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||

6321

codec->core.vendor_id == 0x10ec0671)

6324

codec->core.vendor_id == 0x10ec0671)

6322

ssids = alc663_ssids;

6325

ssids = alc663_ssids;

6323

else

6326

else

6324

ssids = alc662_ssids;

6327

ssids = alc662_ssids;

6325

return alc_parse_auto_config(codec, alc662_ignore, ssids);

6328

return alc_parse_auto_config(codec, alc662_ignore, ssids);

6326

}

6329

}

6327

6330

6328

static void alc272_fixup_mario(struct hda_codec *codec,

6331

static void alc272_fixup_mario(struct hda_codec *codec,

6329

const struct hda_fixup *fix, int action)

6332

const struct hda_fixup *fix, int action)

6330

{

6333

{

6331

if (action != HDA_FIXUP_ACT_PRE_PROBE)

6334

if (action != HDA_FIXUP_ACT_PRE_PROBE)

6332

return;

6335

return;

6333

if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,

6336

if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,

6334

(0x3b << AC_AMPCAP_OFFSET_SHIFT) |

6337

(0x3b << AC_AMPCAP_OFFSET_SHIFT) |

6335

(0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |

6338

(0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |

6336

(0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |

6339

(0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |

6337

(0 << AC_AMPCAP_MUTE_SHIFT)))

6340

(0 << AC_AMPCAP_MUTE_SHIFT)))

6338

codec_warn(codec, "failed to override amp caps for NID 0x2\n");

6341

codec_warn(codec, "failed to override amp caps for NID 0x2\n");

6339

}

6342

}

6340

6343

6341

static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {

6344

static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {

6342

{ .channels = 2,

6345

{ .channels = 2,

6343

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },

6346

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },

6344

{ .channels = 4,

6347

{ .channels = 4,

6345

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,

6348

.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,

6346

SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */

6349

SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */

6347

{ }

6350

{ }

6348

};

6351

};

6349

6352

6350

/* override the 2.1 chmap */

6353

/* override the 2.1 chmap */

6351

static void alc_fixup_bass_chmap(struct hda_codec *codec,

6354

static void alc_fixup_bass_chmap(struct hda_codec *codec,

6352

const struct hda_fixup *fix, int action)

6355

const struct hda_fixup *fix, int action)

6353

{

6356

{

6354

if (action == HDA_FIXUP_ACT_BUILD) {

6357

if (action == HDA_FIXUP_ACT_BUILD) {

6355

struct alc_spec *spec = codec->spec;

6358

struct alc_spec *spec = codec->spec;

6356

spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;

6359

spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;

6357

}

6360

}

6358

}

6361

}

6359

6362

6360

/* avoid D3 for keeping GPIO up */

6363

/* avoid D3 for keeping GPIO up */

6361

static unsigned int gpio_led_power_filter(struct hda_codec *codec,

6364

static unsigned int gpio_led_power_filter(struct hda_codec *codec,

6362

hda_nid_t nid,

6365

hda_nid_t nid,

6363

unsigned int power_state)

6366

unsigned int power_state)

6364

{

6367

{

6365

struct alc_spec *spec = codec->spec;

6368

struct alc_spec *spec = codec->spec;

6366

if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)

6369

if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)

6367

return AC_PWRST_D0;

6370

return AC_PWRST_D0;

6368

return power_state;

6371

return power_state;

6369

}

6372

}

6370

6373

6371

static void alc662_fixup_led_gpio1(struct hda_codec *codec,

6374

static void alc662_fixup_led_gpio1(struct hda_codec *codec,

6372

const struct hda_fixup *fix, int action)

6375

const struct hda_fixup *fix, int action)

6373

{

6376

{

6374

struct alc_spec *spec = codec->spec;

6377

struct alc_spec *spec = codec->spec;

6375

static const struct hda_verb gpio_init[] = {

6378

static const struct hda_verb gpio_init[] = {

6376

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },

6379

{ 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },

6377

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },

6380

{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },

6378

{}

6381

{}

6379

};

6382

};

6380

6383

6381

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

6384

if (action == HDA_FIXUP_ACT_PRE_PROBE) {

6382

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

6385

spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;

6383

spec->gpio_led = 0;

6386

spec->gpio_led = 0;

6384

spec->mute_led_polarity = 1;

6387

spec->mute_led_polarity = 1;

6385

spec->gpio_mute_led_mask = 0x01;

6388

spec->gpio_mute_led_mask = 0x01;

6386

snd_hda_add_verbs(codec, gpio_init);

6389

snd_hda_add_verbs(codec, gpio_init);

6387

codec->power_filter = gpio_led_power_filter;

6390

codec->power_filter = gpio_led_power_filter;

6388

}

6391

}

6389

}

6392

}

6390

6393

6391

static struct coef_fw alc668_coefs[] = {

6394

static struct coef_fw alc668_coefs[] = {

6392

WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),

6395

WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),

6393

WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),

6396

WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),

6394

WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),

6397

WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),

6395

WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),

6398

WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),

6396

WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),

6399

WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),

6397

WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),

6400

WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),

6398

WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),

6401

WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),

6399

WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),

6402

WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),

6400

WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),

6403

WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),

6401

WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),

6404

WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),

6402

WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),

6405

WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),

6403

WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),

6406

WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),

6404

WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),

6407

WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),

6405

WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),

6408

WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),

6406

WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),

6409

WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),

6407

WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),

6410

WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),

6408

WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),

6411

WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),

6409

WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),

6412

WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),

6410

WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),

6413

WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),

6411

WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),

6414

WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),

6412

{}

6415

{}

6413

};

6416

};

6414

6417

6415

static void alc668_restore_default_value(struct hda_codec *codec)

6418

static void alc668_restore_default_value(struct hda_codec *codec)

6416

{

6419

{

6417

alc_process_coef_fw(codec, alc668_coefs);

6420

alc_process_coef_fw(codec, alc668_coefs);

6418

}

6421

}

6419

6422

6420

enum {

6423

enum {

6421

ALC662_FIXUP_ASPIRE,

6424

ALC662_FIXUP_ASPIRE,

6422

ALC662_FIXUP_LED_GPIO1,

6425

ALC662_FIXUP_LED_GPIO1,

6423

ALC662_FIXUP_IDEAPAD,

6426

ALC662_FIXUP_IDEAPAD,

6424

ALC272_FIXUP_MARIO,

6427

ALC272_FIXUP_MARIO,

6425

ALC662_FIXUP_CZC_P10T,

6428

ALC662_FIXUP_CZC_P10T,

6426

ALC662_FIXUP_SKU_IGNORE,

6429

ALC662_FIXUP_SKU_IGNORE,

6427

ALC662_FIXUP_HP_RP5800,

6430

ALC662_FIXUP_HP_RP5800,

6428

ALC662_FIXUP_ASUS_MODE1,

6431

ALC662_FIXUP_ASUS_MODE1,

6429

ALC662_FIXUP_ASUS_MODE2,

6432

ALC662_FIXUP_ASUS_MODE2,

6430

ALC662_FIXUP_ASUS_MODE3,

6433

ALC662_FIXUP_ASUS_MODE3,

6431

ALC662_FIXUP_ASUS_MODE4,

6434

ALC662_FIXUP_ASUS_MODE4,

6432

ALC662_FIXUP_ASUS_MODE5,

6435

ALC662_FIXUP_ASUS_MODE5,

6433

ALC662_FIXUP_ASUS_MODE6,

6436

ALC662_FIXUP_ASUS_MODE6,

6434

ALC662_FIXUP_ASUS_MODE7,

6437

ALC662_FIXUP_ASUS_MODE7,

6435

ALC662_FIXUP_ASUS_MODE8,

6438

ALC662_FIXUP_ASUS_MODE8,

6436

ALC662_FIXUP_NO_JACK_DETECT,

6439

ALC662_FIXUP_NO_JACK_DETECT,

6437

ALC662_FIXUP_ZOTAC_Z68,

6440

ALC662_FIXUP_ZOTAC_Z68,

6438

ALC662_FIXUP_INV_DMIC,

6441

ALC662_FIXUP_INV_DMIC,

6439

ALC662_FIXUP_DELL_MIC_NO_PRESENCE,

6442

ALC662_FIXUP_DELL_MIC_NO_PRESENCE,

6440

ALC668_FIXUP_DELL_MIC_NO_PRESENCE,

6443

ALC668_FIXUP_DELL_MIC_NO_PRESENCE,

6441

ALC662_FIXUP_HEADSET_MODE,

6444

ALC662_FIXUP_HEADSET_MODE,

6442

ALC668_FIXUP_HEADSET_MODE,

6445

ALC668_FIXUP_HEADSET_MODE,

6443

ALC662_FIXUP_BASS_MODE4_CHMAP,

6446

ALC662_FIXUP_BASS_MODE4_CHMAP,

6444

ALC662_FIXUP_BASS_16,

6447

ALC662_FIXUP_BASS_16,

6445

ALC662_FIXUP_BASS_1A,

6448

ALC662_FIXUP_BASS_1A,

6446

ALC662_FIXUP_BASS_CHMAP,

6449

ALC662_FIXUP_BASS_CHMAP,

6447

ALC668_FIXUP_AUTO_MUTE,

6450

ALC668_FIXUP_AUTO_MUTE,

6448

ALC668_FIXUP_DELL_DISABLE_AAMIX,

6451

ALC668_FIXUP_DELL_DISABLE_AAMIX,

6449

ALC668_FIXUP_DELL_XPS13,

6452

ALC668_FIXUP_DELL_XPS13,

6450

ALC662_FIXUP_ASUS_Nx50,

6453

ALC662_FIXUP_ASUS_Nx50,

6451

ALC668_FIXUP_ASUS_Nx51,

6454

ALC668_FIXUP_ASUS_Nx51,

6452

};

6455

};

6453

6456

6454

static const struct hda_fixup alc662_fixups[] = {

6457

static const struct hda_fixup alc662_fixups[] = {

6455

[ALC662_FIXUP_ASPIRE] = {

6458

[ALC662_FIXUP_ASPIRE] = {

6456

.type = HDA_FIXUP_PINS,

6459

.type = HDA_FIXUP_PINS,

6457

.v.pins = (const struct hda_pintbl[]) {

6460

.v.pins = (const struct hda_pintbl[]) {

6458

{ 0x15, 0x99130112 }, /* subwoofer */

6461

{ 0x15, 0x99130112 }, /* subwoofer */

6459

{ }

6462

{ }

6460

}

6463

}

6461

},

6464

},

6462

[ALC662_FIXUP_LED_GPIO1] = {

6465

[ALC662_FIXUP_LED_GPIO1] = {

6463

.type = HDA_FIXUP_FUNC,

6466

.type = HDA_FIXUP_FUNC,

6464

.v.func = alc662_fixup_led_gpio1,

6467

.v.func = alc662_fixup_led_gpio1,

6465

},

6468

},

6466

[ALC662_FIXUP_IDEAPAD] = {

6469

[ALC662_FIXUP_IDEAPAD] = {

6467

.type = HDA_FIXUP_PINS,

6470

.type = HDA_FIXUP_PINS,

6468

.v.pins = (const struct hda_pintbl[]) {

6471

.v.pins = (const struct hda_pintbl[]) {

6469

{ 0x17, 0x99130112 }, /* subwoofer */

6472

{ 0x17, 0x99130112 }, /* subwoofer */

6470

{ }

6473

{ }

6471

},

6474

},

6472

.chained = true,

6475

.chained = true,

6473

.chain_id = ALC662_FIXUP_LED_GPIO1,

6476

.chain_id = ALC662_FIXUP_LED_GPIO1,

6474

},

6477

},

6475

[ALC272_FIXUP_MARIO] = {

6478

[ALC272_FIXUP_MARIO] = {

6476

.type = HDA_FIXUP_FUNC,

6479

.type = HDA_FIXUP_FUNC,

6477

.v.func = alc272_fixup_mario,

6480

.v.func = alc272_fixup_mario,

6478

},

6481

},

6479

[ALC662_FIXUP_CZC_P10T] = {

6482

[ALC662_FIXUP_CZC_P10T] = {

6480

.type = HDA_FIXUP_VERBS,

6483

.type = HDA_FIXUP_VERBS,

6481

.v.verbs = (const struct hda_verb[]) {

6484

.v.verbs = (const struct hda_verb[]) {

6482

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

6485

{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},

6483

{}

6486

{}

6484

}

6487

}

6485

},

6488

},

6486

[ALC662_FIXUP_SKU_IGNORE] = {

6489

[ALC662_FIXUP_SKU_IGNORE] = {

6487

.type = HDA_FIXUP_FUNC,

6490

.type = HDA_FIXUP_FUNC,

6488

.v.func = alc_fixup_sku_ignore,

6491

.v.func = alc_fixup_sku_ignore,

6489

},

6492

},

6490

[ALC662_FIXUP_HP_RP5800] = {

6493

[ALC662_FIXUP_HP_RP5800] = {

6491

.type = HDA_FIXUP_PINS,

6494

.type = HDA_FIXUP_PINS,

6492

.v.pins = (const struct hda_pintbl[]) {

6495

.v.pins = (const struct hda_pintbl[]) {

6493

{ 0x14, 0x0221201f }, /* HP out */

6496

{ 0x14, 0x0221201f }, /* HP out */

6494

{ }

6497

{ }

6495

},

6498

},

6496

.chained = true,

6499

.chained = true,

6497

.chain_id = ALC662_FIXUP_SKU_IGNORE

6500

.chain_id = ALC662_FIXUP_SKU_IGNORE

6498

},

6501

},

6499

[ALC662_FIXUP_ASUS_MODE1] = {

6502

[ALC662_FIXUP_ASUS_MODE1] = {

6500

.type = HDA_FIXUP_PINS,

6503

.type = HDA_FIXUP_PINS,

6501

.v.pins = (const struct hda_pintbl[]) {

6504

.v.pins = (const struct hda_pintbl[]) {

6502

{ 0x14, 0x99130110 }, /* speaker */

6505

{ 0x14, 0x99130110 }, /* speaker */

6503

{ 0x18, 0x01a19c20 }, /* mic */

6506

{ 0x18, 0x01a19c20 }, /* mic */

6504

{ 0x19, 0x99a3092f }, /* int-mic */

6507

{ 0x19, 0x99a3092f }, /* int-mic */

6505

{ 0x21, 0x0121401f }, /* HP out */

6508

{ 0x21, 0x0121401f }, /* HP out */

6506

{ }

6509

{ }

6507

},

6510

},

6508

.chained = true,

6511

.chained = true,

6509

.chain_id = ALC662_FIXUP_SKU_IGNORE

6512

.chain_id = ALC662_FIXUP_SKU_IGNORE

6510

},

6513

},

6511

[ALC662_FIXUP_ASUS_MODE2] = {

6514

[ALC662_FIXUP_ASUS_MODE2] = {

6512

.type = HDA_FIXUP_PINS,

6515

.type = HDA_FIXUP_PINS,

6513

.v.pins = (const struct hda_pintbl[]) {

6516

.v.pins = (const struct hda_pintbl[]) {

6514

{ 0x14, 0x99130110 }, /* speaker */

6517

{ 0x14, 0x99130110 }, /* speaker */

6515

{ 0x18, 0x01a19820 }, /* mic */

6518

{ 0x18, 0x01a19820 }, /* mic */

6516

{ 0x19, 0x99a3092f }, /* int-mic */

6519

{ 0x19, 0x99a3092f }, /* int-mic */

6517

{ 0x1b, 0x0121401f }, /* HP out */

6520

{ 0x1b, 0x0121401f }, /* HP out */

6518

{ }

6521

{ }

6519

},

6522

},

6520

.chained = true,

6523

.chained = true,

6521

.chain_id = ALC662_FIXUP_SKU_IGNORE

6524

.chain_id = ALC662_FIXUP_SKU_IGNORE

6522

},

6525

},

6523

[ALC662_FIXUP_ASUS_MODE3] = {

6526

[ALC662_FIXUP_ASUS_MODE3] = {

6524

.type = HDA_FIXUP_PINS,

6527

.type = HDA_FIXUP_PINS,

6525

.v.pins = (const struct hda_pintbl[]) {

6528

.v.pins = (const struct hda_pintbl[]) {

6526

{ 0x14, 0x99130110 }, /* speaker */

6529

{ 0x14, 0x99130110 }, /* speaker */

6527

{ 0x15, 0x0121441f }, /* HP */

6530

{ 0x15, 0x0121441f }, /* HP */

6528

{ 0x18, 0x01a19840 }, /* mic */

6531

{ 0x18, 0x01a19840 }, /* mic */

6529

{ 0x19, 0x99a3094f }, /* int-mic */

6532

{ 0x19, 0x99a3094f }, /* int-mic */

6530

{ 0x21, 0x01211420 }, /* HP2 */

6533

{ 0x21, 0x01211420 }, /* HP2 */

6531

{ }

6534

{ }

6532

},

6535

},

6533

.chained = true,

6536

.chained = true,

6534

.chain_id = ALC662_FIXUP_SKU_IGNORE

6537

.chain_id = ALC662_FIXUP_SKU_IGNORE

6535

},

6538

},

6536

[ALC662_FIXUP_ASUS_MODE4] = {

6539

[ALC662_FIXUP_ASUS_MODE4] = {

6537

.type = HDA_FIXUP_PINS,

6540

.type = HDA_FIXUP_PINS,

6538

.v.pins = (const struct hda_pintbl[]) {

6541

.v.pins = (const struct hda_pintbl[]) {

6539

{ 0x14, 0x99130110 }, /* speaker */

6542

{ 0x14, 0x99130110 }, /* speaker */

6540

{ 0x16, 0x99130111 }, /* speaker */

6543

{ 0x16, 0x99130111 }, /* speaker */

6541

{ 0x18, 0x01a19840 }, /* mic */

6544

{ 0x18, 0x01a19840 }, /* mic */

6542

{ 0x19, 0x99a3094f }, /* int-mic */

6545

{ 0x19, 0x99a3094f }, /* int-mic */

6543

{ 0x21, 0x0121441f }, /* HP */

6546

{ 0x21, 0x0121441f }, /* HP */

6544

{ }

6547

{ }

6545

},

6548

},

6546

.chained = true,

6549

.chained = true,

6547

.chain_id = ALC662_FIXUP_SKU_IGNORE

6550

.chain_id = ALC662_FIXUP_SKU_IGNORE

6548

},

6551

},

6549

[ALC662_FIXUP_ASUS_MODE5] = {

6552

[ALC662_FIXUP_ASUS_MODE5] = {

6550

.type = HDA_FIXUP_PINS,

6553

.type = HDA_FIXUP_PINS,

6551

.v.pins = (const struct hda_pintbl[]) {

6554

.v.pins = (const struct hda_pintbl[]) {

6552

{ 0x14, 0x99130110 }, /* speaker */

6555

{ 0x14, 0x99130110 }, /* speaker */

6553

{ 0x15, 0x0121441f }, /* HP */

6556

{ 0x15, 0x0121441f }, /* HP */

6554

{ 0x16, 0x99130111 }, /* speaker */

6557

{ 0x16, 0x99130111 }, /* speaker */

6555

{ 0x18, 0x01a19840 }, /* mic */

6558

{ 0x18, 0x01a19840 }, /* mic */

6556

{ 0x19, 0x99a3094f }, /* int-mic */

6559

{ 0x19, 0x99a3094f }, /* int-mic */

6557

{ }

6560

{ }

6558

},

6561

},

6559

.chained = true,

6562

.chained = true,

6560

.chain_id = ALC662_FIXUP_SKU_IGNORE

6563

.chain_id = ALC662_FIXUP_SKU_IGNORE

6561

},

6564

},

6562

[ALC662_FIXUP_ASUS_MODE6] = {

6565

[ALC662_FIXUP_ASUS_MODE6] = {

6563

.type = HDA_FIXUP_PINS,

6566

.type = HDA_FIXUP_PINS,

6564

.v.pins = (const struct hda_pintbl[]) {

6567

.v.pins = (const struct hda_pintbl[]) {

6565

{ 0x14, 0x99130110 }, /* speaker */

6568

{ 0x14, 0x99130110 }, /* speaker */

6566

{ 0x15, 0x01211420 }, /* HP2 */

6569

{ 0x15, 0x01211420 }, /* HP2 */

6567

{ 0x18, 0x01a19840 }, /* mic */

6570

{ 0x18, 0x01a19840 }, /* mic */

6568

{ 0x19, 0x99a3094f }, /* int-mic */

6571

{ 0x19, 0x99a3094f }, /* int-mic */

6569

{ 0x1b, 0x0121441f }, /* HP */

6572

{ 0x1b, 0x0121441f }, /* HP */

6570

{ }

6573

{ }

6571

},

6574

},

6572

.chained = true,

6575

.chained = true,

6573

.chain_id = ALC662_FIXUP_SKU_IGNORE

6576

.chain_id = ALC662_FIXUP_SKU_IGNORE

6574

},

6577

},

6575

[ALC662_FIXUP_ASUS_MODE7] = {

6578

[ALC662_FIXUP_ASUS_MODE7] = {

6576

.type = HDA_FIXUP_PINS,

6579

.type = HDA_FIXUP_PINS,

6577

.v.pins = (const struct hda_pintbl[]) {

6580

.v.pins = (const struct hda_pintbl[]) {

6578

{ 0x14, 0x99130110 }, /* speaker */

6581

{ 0x14, 0x99130110 }, /* speaker */

6579

{ 0x17, 0x99130111 }, /* speaker */

6582

{ 0x17, 0x99130111 }, /* speaker */

6580

{ 0x18, 0x01a19840 }, /* mic */

6583

{ 0x18, 0x01a19840 }, /* mic */

6581

{ 0x19, 0x99a3094f }, /* int-mic */

6584

{ 0x19, 0x99a3094f }, /* int-mic */

6582

{ 0x1b, 0x01214020 }, /* HP */

6585

{ 0x1b, 0x01214020 }, /* HP */

6583

{ 0x21, 0x0121401f }, /* HP */

6586

{ 0x21, 0x0121401f }, /* HP */

6584

{ }

6587

{ }

6585

},

6588

},

6586

.chained = true,

6589

.chained = true,

6587

.chain_id = ALC662_FIXUP_SKU_IGNORE

6590

.chain_id = ALC662_FIXUP_SKU_IGNORE

6588

},

6591

},

6589

[ALC662_FIXUP_ASUS_MODE8] = {

6592

[ALC662_FIXUP_ASUS_MODE8] = {

6590

.type = HDA_FIXUP_PINS,

6593

.type = HDA_FIXUP_PINS,

6591

.v.pins = (const struct hda_pintbl[]) {

6594

.v.pins = (const struct hda_pintbl[]) {

6592

{ 0x14, 0x99130110 }, /* speaker */

6595

{ 0x14, 0x99130110 }, /* speaker */

6593

{ 0x12, 0x99a30970 }, /* int-mic */

6596

{ 0x12, 0x99a30970 }, /* int-mic */

6594

{ 0x15, 0x01214020 }, /* HP */

6597

{ 0x15, 0x01214020 }, /* HP */

6595

{ 0x17, 0x99130111 }, /* speaker */

6598

{ 0x17, 0x99130111 }, /* speaker */

6596

{ 0x18, 0x01a19840 }, /* mic */

6599

{ 0x18, 0x01a19840 }, /* mic */

6597

{ 0x21, 0x0121401f }, /* HP */

6600

{ 0x21, 0x0121401f }, /* HP */

6598

{ }

6601

{ }

6599

},

6602

},

6600

.chained = true,

6603

.chained = true,

6601

.chain_id = ALC662_FIXUP_SKU_IGNORE

6604

.chain_id = ALC662_FIXUP_SKU_IGNORE

6602

},

6605

},

6603

[ALC662_FIXUP_NO_JACK_DETECT] = {

6606

[ALC662_FIXUP_NO_JACK_DETECT] = {

6604

.type = HDA_FIXUP_FUNC,

6607

.type = HDA_FIXUP_FUNC,

6605

.v.func = alc_fixup_no_jack_detect,

6608

.v.func = alc_fixup_no_jack_detect,

6606

},

6609

},

6607

[ALC662_FIXUP_ZOTAC_Z68] = {

6610

[ALC662_FIXUP_ZOTAC_Z68] = {

6608

.type = HDA_FIXUP_PINS,

6611

.type = HDA_FIXUP_PINS,

6609

.v.pins = (const struct hda_pintbl[]) {

6612

.v.pins = (const struct hda_pintbl[]) {

6610

{ 0x1b, 0x02214020 }, /* Front HP */

6613

{ 0x1b, 0x02214020 }, /* Front HP */

6611

{ }

6614

{ }

6612

}

6615

}

6613

},

6616

},

6614

[ALC662_FIXUP_INV_DMIC] = {

6617

[ALC662_FIXUP_INV_DMIC] = {

6615

.type = HDA_FIXUP_FUNC,

6618

.type = HDA_FIXUP_FUNC,

6616

.v.func = alc_fixup_inv_dmic,

6619

.v.func = alc_fixup_inv_dmic,

6617

},

6620

},

6618

[ALC668_FIXUP_DELL_XPS13] = {

6621

[ALC668_FIXUP_DELL_XPS13] = {

6619

.type = HDA_FIXUP_FUNC,

6622

.type = HDA_FIXUP_FUNC,

6620

.v.func = alc_fixup_dell_xps13,

6623

.v.func = alc_fixup_dell_xps13,

6621

.chained = true,

6624

.chained = true,

6622

.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX

6625

.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX

6623

},

6626

},

6624

[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {

6627

[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {

6625

.type = HDA_FIXUP_FUNC,

6628

.type = HDA_FIXUP_FUNC,

6626

.v.func = alc_fixup_disable_aamix,

6629

.v.func = alc_fixup_disable_aamix,

6627

.chained = true,

6630

.chained = true,

6628

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

6631

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

6629

},

6632

},

6630

[ALC668_FIXUP_AUTO_MUTE] = {

6633

[ALC668_FIXUP_AUTO_MUTE] = {

6631

.type = HDA_FIXUP_FUNC,

6634

.type = HDA_FIXUP_FUNC,

6632

.v.func = alc_fixup_auto_mute_via_amp,

6635

.v.func = alc_fixup_auto_mute_via_amp,

6633

.chained = true,

6636

.chained = true,

6634

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

6637

.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE

6635

},

6638

},

6636

[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {

6639

[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {

6637

.type = HDA_FIXUP_PINS,

6640

.type = HDA_FIXUP_PINS,

6638

.v.pins = (const struct hda_pintbl[]) {

6641

.v.pins = (const struct hda_pintbl[]) {

6639

{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */

6642

{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */

6640

/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */

6643

/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */

6641

{ }

6644

{ }

6642

},

6645

},

6643

.chained = true,

6646

.chained = true,

6644

.chain_id = ALC662_FIXUP_HEADSET_MODE

6647

.chain_id = ALC662_FIXUP_HEADSET_MODE

6645

},

6648

},

6646

[ALC662_FIXUP_HEADSET_MODE] = {

6649

[ALC662_FIXUP_HEADSET_MODE] = {

6647

.type = HDA_FIXUP_FUNC,

6650

.type = HDA_FIXUP_FUNC,

6648

.v.func = alc_fixup_headset_mode_alc662,

6651

.v.func = alc_fixup_headset_mode_alc662,

6649

},

6652

},

6650

[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {

6653

[ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {

6651

.type = HDA_FIXUP_PINS,

6654

.type = HDA_FIXUP_PINS,

6652

.v.pins = (const struct hda_pintbl[]) {

6655

.v.pins = (const struct hda_pintbl[]) {

6653

{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */

6656

{ 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */

6654

{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */

6657

{ 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */

6655

{ }

6658

{ }

6656

},

6659

},

6657

.chained = true,

6660

.chained = true,

6658

.chain_id = ALC668_FIXUP_HEADSET_MODE

6661

.chain_id = ALC668_FIXUP_HEADSET_MODE

6659

},

6662

},

6660

[ALC668_FIXUP_HEADSET_MODE] = {

6663

[ALC668_FIXUP_HEADSET_MODE] = {

6661

.type = HDA_FIXUP_FUNC,

6664

.type = HDA_FIXUP_FUNC,

6662

.v.func = alc_fixup_headset_mode_alc668,

6665

.v.func = alc_fixup_headset_mode_alc668,

6663

},

6666

},

6664

[ALC662_FIXUP_BASS_MODE4_CHMAP] = {

6667

[ALC662_FIXUP_BASS_MODE4_CHMAP] = {

6665

.type = HDA_FIXUP_FUNC,

6668

.type = HDA_FIXUP_FUNC,

6666

.v.func = alc_fixup_bass_chmap,

6669

.v.func = alc_fixup_bass_chmap,

6667

.chained = true,

6670

.chained = true,

6668

.chain_id = ALC662_FIXUP_ASUS_MODE4

6671

.chain_id = ALC662_FIXUP_ASUS_MODE4

6669

},

6672

},

6670

[ALC662_FIXUP_BASS_16] = {

6673

[ALC662_FIXUP_BASS_16] = {

6671

.type = HDA_FIXUP_PINS,

6674

.type = HDA_FIXUP_PINS,

6672

.v.pins = (const struct hda_pintbl[]) {

6675

.v.pins = (const struct hda_pintbl[]) {

6673

{0x16, 0x80106111}, /* bass speaker */

6676

{0x16, 0x80106111}, /* bass speaker */

6674

{}

6677

{}

6675

},

6678

},

6676

.chained = true,

6679

.chained = true,

6677

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6680

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6678

},

6681

},

6679

[ALC662_FIXUP_BASS_1A] = {

6682

[ALC662_FIXUP_BASS_1A] = {

6680

.type = HDA_FIXUP_PINS,

6683

.type = HDA_FIXUP_PINS,

6681

.v.pins = (const struct hda_pintbl[]) {

6684

.v.pins = (const struct hda_pintbl[]) {

6682

{0x1a, 0x80106111}, /* bass speaker */

6685

{0x1a, 0x80106111}, /* bass speaker */

6683

{}

6686

{}

6684

},

6687

},

6685

.chained = true,

6688

.chained = true,

6686

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6689

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6687

},

6690

},

6688

[ALC662_FIXUP_BASS_CHMAP] = {

6691

[ALC662_FIXUP_BASS_CHMAP] = {

6689

.type = HDA_FIXUP_FUNC,

6692

.type = HDA_FIXUP_FUNC,

6690

.v.func = alc_fixup_bass_chmap,

6693

.v.func = alc_fixup_bass_chmap,

6691

},

6694

},

6692

[ALC662_FIXUP_ASUS_Nx50] = {

6695

[ALC662_FIXUP_ASUS_Nx50] = {

6693

.type = HDA_FIXUP_FUNC,

6696

.type = HDA_FIXUP_FUNC,

6694

.v.func = alc_fixup_auto_mute_via_amp,

6697

.v.func = alc_fixup_auto_mute_via_amp,

6695

.chained = true,

6698

.chained = true,

6696

.chain_id = ALC662_FIXUP_BASS_1A

6699

.chain_id = ALC662_FIXUP_BASS_1A

6697

},

6700

},

6698

[ALC668_FIXUP_ASUS_Nx51] = {

6701

[ALC668_FIXUP_ASUS_Nx51] = {

6699

.type = HDA_FIXUP_PINS,

6702

.type = HDA_FIXUP_PINS,

6700

.v.pins = (const struct hda_pintbl[]) {

6703

.v.pins = (const struct hda_pintbl[]) {

6701

{0x1a, 0x90170151}, /* bass speaker */

6704

{0x1a, 0x90170151}, /* bass speaker */

6702

{}

6705

{}

6703

},

6706

},

6704

.chained = true,

6707

.chained = true,

6705

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6708

.chain_id = ALC662_FIXUP_BASS_CHMAP,

6706

},

6709

},

6707

};

6710

};

6708

6711

6709

static const struct snd_pci_quirk alc662_fixup_tbl[] = {

6712

static const struct snd_pci_quirk alc662_fixup_tbl[] = {

6710

SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),

6713

SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),

6711

SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),

6714

SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),

6712

SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),

6715

SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),

6713

SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),

6716

SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),

6714

SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),

6717

SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),

6715

SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),

6718

SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),

6716

SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),

6719

SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),

6717

SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),

6720

SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),

6718

SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6721

SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6719

SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6722

SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6720

SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),

6723

SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),

6721

SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),

6724

SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),

6722

SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),

6725

SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),

6723

SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6726

SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6724

SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6727

SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6725

SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6728

SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6726

SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6729

SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6727

SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6730

SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),

6728

SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),

6731

SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),

6729

SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),

6732

SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),

6730

SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),

6733

SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),

6731

SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),

6734

SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),

6732

SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),

6735

SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),

6733

SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

6736

SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

6734

SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),

6737

SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),

6735

SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),

6738

SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),

6736

SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),

6739

SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),

6737

SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),

6740

SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),

6738

SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

6741

SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),

6739

SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),

6742

SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),

6740

SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),

6743

SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),

6741

SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),

6744

SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),

6742

SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),

6745

SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),

6743

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),

6746

SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),

6744

SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),

6747

SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),

6745

SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),

6748

SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),

6746

6749

6747

#if 0

6750

#if 0

6748

/* Below is a quirk table taken from the old code.

6751

/* Below is a quirk table taken from the old code.

6749

* Basically the device should work as is without the fixup table.

6752

* Basically the device should work as is without the fixup table.

6750

* If BIOS doesn't give a proper info, enable the corresponding

6753

* If BIOS doesn't give a proper info, enable the corresponding

6751

* fixup entry.

6754

* fixup entry.

6752

*/

6755

*/

6753

SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),

6756

SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),

6754

SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),

6757

SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),

6755

SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),

6758

SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),

6756

SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),

6759

SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),

6757

SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6760

SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6758

SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6761

SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6759

SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6762

SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6760

SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),

6763

SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),

6761

SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),

6764

SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),

6762

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6765

SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6763

SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),

6766

SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),

6764

SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),

6767

SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),

6765

SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),

6768

SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),

6766

SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),

6769

SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),

6767

SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),

6770

SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),

6768

SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6771

SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6769

SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),

6772

SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),

6770

SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),

6773

SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),

6771

SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6774

SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6772

SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6775

SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6773

SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6776

SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6774

SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6777

SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6775

SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),

6778

SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),

6776

SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),

6779

SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),

6777

SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),

6780

SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),

6778

SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6781

SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6779

SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),

6782

SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),

6780

SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6783

SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),

6781

SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6784

SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6782

SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),

6785

SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),

6783

SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6786

SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6784

SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6787

SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6785

SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),

6788

SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),

6786

SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),

6789

SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),

6787

SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),

6790

SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),

6788

SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),

6791

SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),

6789

SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),

6792

SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),

6790

SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),

6793

SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),

6791

SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),

6794

SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),

6792

SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6795

SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),

6793

SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),

6796

SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),

6794

SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),

6797

SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),

6795

SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6798

SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6796

SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),

6799

SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),

6797

SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),

6800

SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),

6798

SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),

6801

SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),

6799

SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),

6802

SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),

6800

SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),

6803

SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),

6801

SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6804

SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),

6802

SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),

6805

SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),

6803

#endif

6806

#endif

6804

{}

6807

{}

6805

};

6808

};

6806

6809

6807

static const struct hda_model_fixup alc662_fixup_models[] = {

6810

static const struct hda_model_fixup alc662_fixup_models[] = {

6808

{.id = ALC272_FIXUP_MARIO, .name = "mario"},

6811

{.id = ALC272_FIXUP_MARIO, .name = "mario"},

6809

{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},

6812

{.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},

6810

{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},

6813

{.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},

6811

{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},

6814

{.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},

6812

{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},

6815

{.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},

6813

{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},

6816

{.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},

6814

{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},

6817

{.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},

6815

{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},

6818

{.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},

6816

{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},

6819

{.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},

6817

{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},

6820

{.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},

6818

{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

6821

{.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},

6819

{}

6822

{}

6820

};

6823

};

6821

6824

6822

static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {

6825

static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {

6823

SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,

6826

SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,

6824

{0x14, 0x01014010},

6827

{0x14, 0x01014010},

6825

{0x18, 0x01a19020},

6828

{0x18, 0x01a19020},

6826

{0x1a, 0x0181302f},

6829

{0x1a, 0x0181302f},

6827

{0x1b, 0x0221401f}),

6830

{0x1b, 0x0221401f}),

6828

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6831

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6829

{0x12, 0x99a30130},

6832

{0x12, 0x99a30130},

6830

{0x14, 0x90170110},

6833

{0x14, 0x90170110},

6831

{0x15, 0x0321101f},

6834

{0x15, 0x0321101f},

6832

{0x16, 0x03011020}),

6835

{0x16, 0x03011020}),

6833

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6836

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6834

{0x12, 0x99a30140},

6837

{0x12, 0x99a30140},

6835

{0x14, 0x90170110},

6838

{0x14, 0x90170110},

6836

{0x15, 0x0321101f},

6839

{0x15, 0x0321101f},

6837

{0x16, 0x03011020}),

6840

{0x16, 0x03011020}),

6838

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6841

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6839

{0x12, 0x99a30150},

6842

{0x12, 0x99a30150},

6840

{0x14, 0x90170110},

6843

{0x14, 0x90170110},

6841

{0x15, 0x0321101f},

6844

{0x15, 0x0321101f},

6842

{0x16, 0x03011020}),

6845

{0x16, 0x03011020}),

6843

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6846

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,

6844

{0x14, 0x90170110},

6847

{0x14, 0x90170110},

6845

{0x15, 0x0321101f},

6848

{0x15, 0x0321101f},

6846

{0x16, 0x03011020}),

6849

{0x16, 0x03011020}),

6847

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,

6850

SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,

6848

{0x12, 0x90a60130},

6851

{0x12, 0x90a60130},

6849

{0x14, 0x90170110},

6852

{0x14, 0x90170110},

6850

{0x15, 0x0321101f}),

6853

{0x15, 0x0321101f}),

6851

{}

6854

{}

6852

};

6855

};

6853

6856

6854

/*

6857

/*

6855

*/

6858

*/

6856

static int patch_alc662(struct hda_codec *codec)

6859

static int patch_alc662(struct hda_codec *codec)

6857

{

6860

{

6858

struct alc_spec *spec;

6861

struct alc_spec *spec;

6859

int err;

6862

int err;

6860

6863

6861

err = alc_alloc_spec(codec, 0x0b);

6864

err = alc_alloc_spec(codec, 0x0b);

6862

if (err < 0)

6865

if (err < 0)

6863

return err;

6866

return err;

6864

6867

6865

spec = codec->spec;

6868

spec = codec->spec;

6866

6869

6867

spec->shutup = alc_eapd_shutup;

6870

spec->shutup = alc_eapd_shutup;

6868

6871

6869

/* handle multiple HPs as is */

6872

/* handle multiple HPs as is */

6870

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

6873

spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;

6871

6874

6872

alc_fix_pll_init(codec, 0x20, 0x04, 15);

6875

alc_fix_pll_init(codec, 0x20, 0x04, 15);

6873

6876

6874

switch (codec->core.vendor_id) {

6877

switch (codec->core.vendor_id) {

6875

case 0x10ec0668:

6878

case 0x10ec0668:

6876

spec->init_hook = alc668_restore_default_value;

6879

spec->init_hook = alc668_restore_default_value;

6877

break;

6880

break;

6878

}

6881

}

6879

6882

6880

snd_hda_pick_fixup(codec, alc662_fixup_models,

6883

snd_hda_pick_fixup(codec, alc662_fixup_models,

6881

alc662_fixup_tbl, alc662_fixups);

6884

alc662_fixup_tbl, alc662_fixups);

6882

snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);

6885

snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);

6883

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6886

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6884

6887

6885

alc_auto_parse_customize_define(codec);

6888

alc_auto_parse_customize_define(codec);

6886

6889

6887

if (has_cdefine_beep(codec))

6890

if (has_cdefine_beep(codec))

6888

spec->gen.beep_nid = 0x01;

6891

spec->gen.beep_nid = 0x01;

6889

6892

6890

if ((alc_get_coef0(codec) & (1 << 14)) &&

6893

if ((alc_get_coef0(codec) & (1 << 14)) &&

6891

codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&

6894

codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&

6892

spec->cdefine.platform_type == 1) {

6895

spec->cdefine.platform_type == 1) {

6893

err = alc_codec_rename(codec, "ALC272X");

6896

err = alc_codec_rename(codec, "ALC272X");

6894

if (err < 0)

6897

if (err < 0)

6895

goto error;

6898

goto error;

6896

}

6899

}

6897

6900

6898

/* automatic parse from the BIOS config */

6901

/* automatic parse from the BIOS config */

6899

err = alc662_parse_auto_config(codec);

6902

err = alc662_parse_auto_config(codec);

6900

if (err < 0)

6903

if (err < 0)

6901

goto error;

6904

goto error;

6902

6905

6903

if (!spec->gen.no_analog && spec->gen.beep_nid) {

6906

if (!spec->gen.no_analog && spec->gen.beep_nid) {

6904

switch (codec->core.vendor_id) {

6907

switch (codec->core.vendor_id) {

6905

case 0x10ec0662:

6908

case 0x10ec0662:

6906

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

6909

set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);

6907

break;

6910

break;

6908

case 0x10ec0272:

6911

case 0x10ec0272:

6909

case 0x10ec0663:

6912

case 0x10ec0663:

6910

case 0x10ec0665:

6913

case 0x10ec0665:

6911

case 0x10ec0668:

6914

case 0x10ec0668:

6912

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

6915

set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);

6913

break;

6916

break;

6914

case 0x10ec0273:

6917

case 0x10ec0273:

6915

set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);

6918

set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);

6916

break;

6919

break;

6917

}

6920

}

6918

}

6921

}

6919

6922

6920

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6923

snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6921

6924

6922

return 0;

6925

return 0;

6923

6926

6924

error:

6927

error:

6925

alc_free(codec);

6928

alc_free(codec);

6926

return err;

6929

return err;

6927

}

6930

}

6928

6931

6929

/*

6932

/*

6930

* ALC680 support

6933

* ALC680 support

6931

*/

6934

*/

6932

6935

6933

static int alc680_parse_auto_config(struct hda_codec *codec)

6936

static int alc680_parse_auto_config(struct hda_codec *codec)

6934

{

6937

{

6935

return alc_parse_auto_config(codec, NULL, NULL);

6938

return alc_parse_auto_config(codec, NULL, NULL);

6936

}

6939

}

6937

6940

6938

/*

6941

/*

6939

*/

6942

*/

6940

static int patch_alc680(struct hda_codec *codec)

6943

static int patch_alc680(struct hda_codec *codec)

6941

{

6944

{

6942

int err;

6945

int err;

6943

6946

6944

/* ALC680 has no aa-loopback mixer */

6947

/* ALC680 has no aa-loopback mixer */

6945

err = alc_alloc_spec(codec, 0);

6948

err = alc_alloc_spec(codec, 0);

6946

if (err < 0)

6949

if (err < 0)

6947

return err;

6950

return err;

6948

6951

6949

/* automatic parse from the BIOS config */

6952

/* automatic parse from the BIOS config */

6950

err = alc680_parse_auto_config(codec);

6953

err = alc680_parse_auto_config(codec);

6951

if (err < 0) {

6954

if (err < 0) {

6952

alc_free(codec);

6955

alc_free(codec);

6953

return err;

6956

return err;

6954

}

6957

}

6955

6958

6956

return 0;

6959

return 0;

6957

}

6960

}

6958

6961

6959

/*

6962

/*

6960

* patch entries

6963

* patch entries

6961

*/

6964

*/

6962

static const struct hda_device_id snd_hda_id_realtek[] = {

6965

static const struct hda_device_id snd_hda_id_realtek[] = {

6963

HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),

6966

HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),

6964

HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),

6967

HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),

6965

HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),

6968

HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),

6966

HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),

6969

HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),

6967

HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),

6970

HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),

6968

HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),

6971

HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),

6969

HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),

6972

HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),

6970

HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),

6973

HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),

6971

HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),

6974

HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),

6972

HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),

6975

HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),

6973

HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),

6976

HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),

6974

HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),

6977

HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),

6975

HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),

6978

HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),

6976

HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),

6979

HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),

6977

HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),

6980

HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),

6978

HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),

6981

HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),

6979

HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),

6982

HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),

6980

HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),

6983

HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),

6981

HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),

6984

HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),

6982

HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),

6985

HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),

6983

HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),

6986

HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),

6984

HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),

6987

HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),

6985

HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),

6988

HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),

6986

HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),

6989

HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),

6987

HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),

6990

HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),

6988

HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),

6991

HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),

6989

HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),

6992

HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),

6990

HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),

6993

HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),

6991

HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),

6994

HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),

6992

HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),

6995

HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),

6993

HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),

6996

HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),

6994

HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),

6997

HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),

6995

HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),

6998

HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),

6996

HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),

6999

HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),

6997

HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),

7000

HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),

6998

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),

7001

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),

6999

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),

7002

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),

7000

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),

7003

HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),

7001

HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),

7004

HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),

7002

HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),

7005

HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),

7003

HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),

7006

HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),

7004

HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),

7007

HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),

7005

HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),

7008

HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),

7006

HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),

7009

HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),

7007

HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),

7010

HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),

7008

HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),

7011

HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),

7009

HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),

7012

HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),

7010

HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),

7013

HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),

7011

HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),

7014

HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),

7012

HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),

7015

HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),

7013

HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),

7016

HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),

7014

HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),

7017

HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),

7015

HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),

7018

HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),

7016

HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),

7019

HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),

7017

HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),

7020

HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),

7018

HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),

7021

HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),

7019

HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),

7022

HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),

7020

HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),

7023

HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),

7021

HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),

7024

HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),

7022

{} /* terminator */

7025

{} /* terminator */

7023

};

7026

};

7024

MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);

7027

MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);

7025

7028

7026

MODULE_LICENSE("GPL");

7029

MODULE_LICENSE("GPL");

7027

MODULE_DESCRIPTION("Realtek HD-audio codec");

7030

MODULE_DESCRIPTION("Realtek HD-audio codec");

7028

7031

7029

static struct hda_codec_driver realtek_driver = {

7032

static struct hda_codec_driver realtek_driver = {

7030

.id = snd_hda_id_realtek,

7033

.id = snd_hda_id_realtek,

7031

};

7034

};

7032

7035

7033

module_hda_codec_driver(realtek_driver);

7036

module_hda_codec_driver(realtek_driver);

7034

7037

GITLAB

ALSA: hda - Fix headset mic detection problem for one Dell machine

 /*
  * 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 <linux/input.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
 /* 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,
 };
 enum {
 	ALC_KEY_MICMUTE_INDEX,
 };
 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() */
 	/* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
 	int mute_led_polarity;
 	hda_nid_t mute_led_nid;
 	hda_nid_t cap_mute_led_nid;
 	unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
 	unsigned int gpio_mute_led_mask;
 	unsigned int gpio_mic_led_mask;
 	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);
 	void (*reboot_notify)(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;
 	struct input_dev *kb_dev;
 	u8 alc_mute_keycode_map[1];
 };
 /*
  * 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)
 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 				  unsigned int coef_idx, unsigned int mask,
 				  unsigned int bits_set)
 {
 	unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
 	if (val != -1)
 		alc_write_coefex_idx(codec, nid, coef_idx,
 				     (val & ~mask) | bits_set);
 }
 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)	\
 	alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 /* 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;
 }
 /* coef writes/updates batch */
 struct coef_fw {
 	unsigned char nid;
 	unsigned char idx;
 	unsigned short mask;
 	unsigned short val;
 };
 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 	{ .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 static void alc_process_coef_fw(struct hda_codec *codec,
 				const struct coef_fw *fw)
 {
 	for (; fw->nid; fw++) {
 		if (fw->mask == (unsigned short)-1)
 			alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 		else
 			alc_update_coefex_idx(codec, fw->nid, fw->idx,
 					      fw->mask, fw->val);
 	}
 }
 /*
  * 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;
 	if (spec->pll_nid)
 		alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 				      1 << spec->pll_coef_bit, 0);
 }
 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_callback *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);
 }
 /* Change EAPD to verb control */
 static void alc_fill_eapd_coef(struct hda_codec *codec)
 {
 	int coef;
 	coef = alc_get_coef0(codec);
 	switch (codec->core.vendor_id) {
 	case 0x10ec0262:
 		alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 		break;
 	case 0x10ec0267:
 	case 0x10ec0268:
 		alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 		break;
 	case 0x10ec0269:
 		if ((coef & 0x00f0) == 0x0010)
 			alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 		if ((coef & 0x00f0) == 0x0020)
 			alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 		if ((coef & 0x00f0) == 0x0030)
 			alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 		break;
 	case 0x10ec0280:
 	case 0x10ec0284:
 	case 0x10ec0290:
 	case 0x10ec0292:
 		alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 		break;
 	case 0x10ec0225:
 	case 0x10ec0233:
 	case 0x10ec0255:
 	case 0x10ec0256:
 	case 0x10ec0282:
 	case 0x10ec0283:
 	case 0x10ec0286:
 	case 0x10ec0288:
 	case 0x10ec0295:
 	case 0x10ec0298:
 		alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 		break;
 	case 0x10ec0285:
 	case 0x10ec0293:
 		alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 		break;
 	case 0x10ec0234:
 	case 0x10ec0274:
 	case 0x10ec0294:
 		alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 		break;
 	case 0x10ec0662:
 		if ((coef & 0x00f0) == 0x0030)
 			alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 		break;
 	case 0x10ec0272:
 	case 0x10ec0273:
 	case 0x10ec0663:
 	case 0x10ec0665:
 	case 0x10ec0670:
 	case 0x10ec0671:
 	case 0x10ec0672:
 		alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 		break;
 	case 0x10ec0668:
 		alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 		break;
 	case 0x10ec0867:
 		alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 		break;
 	case 0x10ec0888:
 		if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 			alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 		break;
 	case 0x10ec0892:
 		alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 		break;
 	case 0x10ec0899:
 	case 0x10ec0900:
 		alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 		break;
 	}
 }
 /* additional initialization for ALC888 variants */
 static void alc888_coef_init(struct hda_codec *codec)
 {
 	switch (alc_get_coef0(codec) & 0x00f0) {
 	/* alc888-VA */
 	case 0x00:
 	/* alc888-VB */
 	case 0x10:
 		alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 		break;
 	}
 }
 /* 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, 0x17, 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)
 {
 	alc_fill_eapd_coef(codec);
 	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->core.vendor_id) {
 		case 0x10ec0260:
 			alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 			break;
 		case 0x10ec0880:
 		case 0x10ec0882:
 		case 0x10ec0883:
 		case 0x10ec0885:
 			alc_update_coef_idx(codec, 7, 0, 0x2030);
 			break;
 		case 0x10ec0888:
 			alc888_coef_init(codec);
 			break;
 		}
 		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->core.subsystem_id & 0xffff;
 	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 		goto do_sku;
 	nid = 0x1d;
 	if (codec->core.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->core.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->core.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->core.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->core.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;
 	}
 }
 /*
  */
 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 			       const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	spec->gen.inv_dmic_split = 1;
 }
 #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);
 }
 static void alc_reboot_notify(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	if (spec && spec->reboot_notify)
 		spec->reboot_notify(codec);
 	else
 		alc_shutup(codec);
 }
 /* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */
 static void alc_d3_at_reboot(struct hda_codec *codec)
 {
 	snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
 	snd_hda_codec_write(codec, codec->core.afg, 0,
 			    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 	msleep(10);
 }
 #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);
 	regcache_sync(codec->core.regmap);
 	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_reboot_notify,
 };
 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
 /*
  * 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[] = {
 	{ 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
 	{ 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" },
 	{ 0x10ec0662, 0xffff, 0x4020, "ALC656" },
 	{ 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" },
 	{ 0x10ec0288, 0x1028, 0, "ALC3263" },
 	{ 0x10ec0292, 0x1028, 0, "ALC3226" },
 	{ 0x10ec0293, 0x1028, 0, "ALC3235" },
 	{ 0x10ec0255, 0x1028, 0, "ALC3234" },
 	{ 0x10ec0668, 0x1028, 0, "ALC3661" },
 	{ 0x10ec0275, 0x1028, 0, "ALC3260" },
 	{ 0x10ec0899, 0x1028, 0, "ALC3861" },
 	{ 0x10ec0298, 0x1028, 0, "ALC3266" },
 	{ 0x10ec0256, 0x1028, 0, "ALC3246" },
 	{ 0x10ec0225, 0x1028, 0, "ALC3253" },
 	{ 0x10ec0295, 0x1028, 0, "ALC3254" },
 	{ 0x10ec0670, 0x1025, 0, "ALC669X" },
 	{ 0x10ec0676, 0x1025, 0, "ALC679X" },
 	{ 0x10ec0282, 0x1043, 0, "ALC3229" },
 	{ 0x10ec0233, 0x1043, 0, "ALC3236" },
 	{ 0x10ec0280, 0x103c, 0, "ALC3228" },
 	{ 0x10ec0282, 0x103c, 0, "ALC3227" },
 	{ 0x10ec0286, 0x103c, 0, "ALC3242" },
 	{ 0x10ec0290, 0x103c, 0, "ALC3241" },
 	{ 0x10ec0668, 0x103c, 0, "ALC3662" },
 	{ 0x10ec0283, 0x17aa, 0, "ALC3239" },
 	{ 0x10ec0292, 0x17aa, 0, "ALC3232" },
 	{ } /* 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->core.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->core.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;
 	codec->patch_ops = alc_patch_ops;
 	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_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, 0x0121401f }, /* 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, 0x0121401f }, /* 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(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
 	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 Amilo M1437", ALC880_FIXUP_FUJITSU),
 	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;
 	codec->patch_ops.unsol_event = alc880_unsol_event;
 	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);
 	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,
 						    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[]) {
 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
 			{ }
 		},
 	},
 	[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[]) {
 			{ 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
 			{ 0x1a, 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;
 	spec->shutup = alc_eapd_shutup;
 	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);
 	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,
 	ALC889_FIXUP_MP41_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;
 	alc_update_coef_idx(codec, 7, 0, 0x2030);
 }
 /* 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->core.afg, 0,
 				       AC_VERB_GET_GPIO_DATA, 0);
 	if (!muted)
 		gpiostate |= (1 << pin);
 	else
 		gpiostate &= ~(1 << pin);
 	gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
 				      AC_VERB_GET_GPIO_MASK, 0);
 	gpiomask |= (1 << pin);
 	gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
 				     AC_VERB_GET_GPIO_DIRECTION, 0);
 	gpiodir |= (1 << pin);
 	snd_hda_codec_write(codec, codec->core.afg, 0,
 			    AC_VERB_SET_GPIO_MASK, gpiomask);
 	snd_hda_codec_write(codec, codec->core.afg, 0,
 			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
 	msleep(1);
 	snd_hda_codec_write(codec, codec->core.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[3] = { 0x14, 0x15, 0x19 };
 	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,
 	},
 	[ALC889_FIXUP_MP41_VREF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc889_fixup_mbp_vref,
 		.chained = true,
 		.chain_id = ALC885_FIXUP_MACPRO_GPIO,
 	},
 	[ALC882_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic,
 	},
 	[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, 0x0107, "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),
 	SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", 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 4,1/5,1", ALC889_FIXUP_MP41_VREF),
 	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_MBA11_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->core.vendor_id) {
 	case 0x10ec0882:
 	case 0x10ec0885:
 	case 0x10ec0900:
 		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);
 	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,
 	},
 	[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;
 	spec->shutup = alc_eapd_shutup;
 #if 0
 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
 	 * under-run
 	 */
 	alc_update_coefex_idx(codec, 0x1a, 7, 0, 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);
 	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,
 	},
 	[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;
 	spec->shutup = alc_eapd_shutup;
 	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));
 	}
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
  error:
 	alc_free(codec);
 	return err;
 }
 /*
  * ALC269
  */
 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
 };
 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
 };
 /* 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_ALC298,
 	ALC269_TYPE_ALC255,
 	ALC269_TYPE_ALC256,
 	ALC269_TYPE_ALC225,
 	ALC269_TYPE_ALC294,
 };
 /*
  * 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_ALC298:
 	case ALC269_TYPE_ALC255:
 	case ALC269_TYPE_ALC256:
 	case ALC269_TYPE_ALC225:
 	case ALC269_TYPE_ALC294:
 		ssids = alc269_ssids;
 		break;
 	default:
 		ssids = alc269_ssids;
 		break;
 	}
 	return alc_parse_auto_config(codec, alc269_ignore, ssids);
 }
 static int find_ext_mic_pin(struct hda_codec *codec);
 static void alc286_shutup(struct hda_codec *codec)
 {
 	int i;
 	int mic_pin = find_ext_mic_pin(codec);
 	/* don't shut up pins when unloading the driver; otherwise it breaks
 	 * the default pin setup at the next load of the driver
 	 */
 	if (codec->bus->shutdown)
 		return;
 	for (i = 0; i < codec->init_pins.used; i++) {
 		struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
 		/* use read here for syncing after issuing each verb */
 		if (pin->nid != mic_pin)
 			snd_hda_codec_read(codec, pin->nid, 0,
 					AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 	}
 	codec->pins_shutup = 1;
 }
 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
 {
 	alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
 }
 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 struct coef_fw alc282_coefs[] = {
 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
 	WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
 	WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
 	UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
 	WRITE_COEF(0x34, 0xa0c0), /* ANC */
 	UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
 	WRITE_COEF(0x63, 0x2902), /* PLL */
 	WRITE_COEF(0x68, 0xa080), /* capless control 2 */
 	WRITE_COEF(0x69, 0x3400), /* capless control 3 */
 	WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
 	WRITE_COEF(0x6b, 0x0), /* capless control 5 */
 	UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
 	WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
 	UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
 	WRITE_COEF(0x71, 0x0014), /* class D test 6 */
 	WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
 	UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
 	WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
 	{}
 };
 static void alc282_restore_default_value(struct hda_codec *codec)
 {
 	alc_process_coef_fw(codec, alc282_coefs);
 }
 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 struct coef_fw alc283_coefs[] = {
 	WRITE_COEF(0x03, 0x0002), /* Power Down Control */
 	UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
 	WRITE_COEF(0x07, 0x0200), /* DMIC control */
 	UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
 	UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
 	WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
 	WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
 	WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
 	UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
 	UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
 	WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
 	UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
 	WRITE_COEF(0x22, 0xa0c0), /* ANC */
 	UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
 	UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
 	UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
 	WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
 	WRITE_COEF(0x2e, 0x2902), /* PLL */
 	WRITE_COEF(0x33, 0xa080), /* capless control 2 */
 	WRITE_COEF(0x34, 0x3400), /* capless control 3 */
 	WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
 	WRITE_COEF(0x36, 0x0), /* capless control 5 */
 	UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
 	WRITE_COEF(0x39, 0x110a), /* class D test 3 */
 	UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
 	WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
 	WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
 	UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
 	WRITE_COEF(0x49, 0x0), /* test mode */
 	UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
 	UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
 	WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
 	UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
 	{}
 };
 static void alc283_restore_default_value(struct hda_codec *codec)
 {
 	alc_process_coef_fw(codec, alc283_coefs);
 }
 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;
 	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;
 	msleep(30);
 	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. */
 	alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
 	/* 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;
 	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);
 	/*depop hp during suspend*/
 	alc_write_coef_idx(codec, 0x06, 0x2100);
 	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);
 	alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
 	if (hp_pin_sense)
 		msleep(100);
 	alc_auto_setup_eapd(codec, false);
 	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);
 	}
 	regcache_sync(codec->core.regmap);
 	hda_call_check_power_status(codec, 0x01);
 	/* on some machine, the BIOS will clear the codec gpio data when enter
 	 * suspend, and won't restore the data after resume, so we restore it
 	 * in the driver.
 	 */
 	if (spec->gpio_led)
 		snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
 			    spec->gpio_led);
 	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)
 {
 	if (action == HDA_FIXUP_ACT_INIT)
 		alc_update_coef_idx(codec, 0x1e, 0, 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->core.chip_name, "ALC271X") &&
 	    strcmp(codec->core.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)
 {
 	/* 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.
 	 */
 	if (action == HDA_FIXUP_ACT_INIT)
 		alc_update_coef_idx(codec, 0x07, 0, 0x80);
 }
 static void alc269_quanta_automute(struct hda_codec *codec)
 {
 	snd_hda_gen_update_outputs(codec);
 	alc_write_coef_idx(codec, 0x0c, 0x680);
 	alc_write_coef_idx(codec, 0x0c, 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_callback *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 == 0 ||
 	    (nid != spec->mute_led_nid && nid != spec->cap_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 snd_hda_gen_path_power_filter(codec, nid, power_state);
 }
 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;
 	}
 }
 /* update LED status via GPIO */
 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
 				bool enabled)
 {
 	struct alc_spec *spec = codec->spec;
 	unsigned int oldval = spec->gpio_led;
 	if (spec->mute_led_polarity)
 		enabled = !enabled;
 	if (enabled)
 		spec->gpio_led &= ~mask;
 	else
 		spec->gpio_led |= mask;
 	if (spec->gpio_led != oldval)
 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 				    spec->gpio_led);
 }
 /* turn on/off mute LED via GPIO per vmaster hook */
 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
 {
 	struct hda_codec *codec = private_data;
 	struct alc_spec *spec = codec->spec;
 	alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
 }
 /* turn on/off mic-mute LED via GPIO per capture hook */
 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
 					 struct snd_kcontrol *kcontrol,
 					 struct snd_ctl_elem_value *ucontrol)
 {
 	struct alc_spec *spec = codec->spec;
 	if (ucontrol)
 		alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
 				    ucontrol->value.integer.value[0] ||
 				    ucontrol->value.integer.value[1]);
 }
 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 = alc_fixup_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x08;
 		spec->gpio_mic_led_mask = 0x10;
 		snd_hda_add_verbs(codec, gpio_init);
 	}
 }
 static void alc286_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, 0x22 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
 		{}
 	};
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x02;
 		spec->gpio_mic_led_mask = 0x20;
 		snd_hda_add_verbs(codec, gpio_init);
 	}
 }
 /* turn on/off mic-mute LED per capture hook */
 static void alc269_fixup_hp_cap_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 pinval, enable, disable;
 	pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
 	pinval &= ~AC_PINCTL_VREFEN;
 	enable  = pinval | AC_PINCTL_VREF_80;
 	disable = pinval | AC_PINCTL_VREF_HIZ;
 	if (!ucontrol)
 		return;
 	if (ucontrol->value.integer.value[0] ||
 	    ucontrol->value.integer.value[1])
 		pinval = disable;
 	else
 		pinval = enable;
 	if (spec->cap_mute_led_nid)
 		snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
 }
 static void alc269_fixup_hp_gpio_mic1_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, 0x08 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
 		{}
 	};
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x08;
 		spec->cap_mute_led_nid = 0x18;
 		snd_hda_add_verbs(codec, gpio_init);
 		codec->power_filter = led_power_filter;
 	}
 }
 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	/* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
 	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 = alc_fixup_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x08;
 		spec->cap_mute_led_nid = 0x18;
 		snd_hda_add_verbs(codec, gpio_init);
 		codec->power_filter = led_power_filter;
 	}
 }
 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
 				   struct hda_jack_callback *event)
 {
 	struct alc_spec *spec = codec->spec;
 	/* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
 	   send both key on and key off event for every interrupt. */
 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
 	input_sync(spec->kb_dev);
 	input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
 	input_sync(spec->kb_dev);
 }
 static int alc_register_micmute_input_device(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	int i;
 	spec->kb_dev = input_allocate_device();
 	if (!spec->kb_dev) {
 		codec_err(codec, "Out of memory (input_allocate_device)\n");
 		return -ENOMEM;
 	}
 	spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
 	spec->kb_dev->name = "Microphone Mute Button";
 	spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
 	spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
 	spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
 	spec->kb_dev->keycode = spec->alc_mute_keycode_map;
 	for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
 		set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
 	if (input_register_device(spec->kb_dev)) {
 		codec_err(codec, "input_register_device failed\n");
 		input_free_device(spec->kb_dev);
 		spec->kb_dev = NULL;
 		return -ENOMEM;
 	}
 	return 0;
 }
 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
 					     const struct hda_fixup *fix, int action)
 {
 	/* GPIO1 = set according to SKU external amp
 	   GPIO2 = mic mute hotkey
 	   GPIO3 = mute LED
 	   GPIO4 = mic mute LED */
 	static const struct hda_verb gpio_init[] = {
 		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
 		{ 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
 		{}
 	};
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		if (alc_register_micmute_input_device(codec) != 0)
 			return;
 		snd_hda_add_verbs(codec, gpio_init);
 		snd_hda_codec_write_cache(codec, codec->core.afg, 0,
 					  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
 		snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
 						    gpio2_mic_hotkey_event);
 		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
 		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x08;
 		spec->gpio_mic_led_mask = 0x10;
 		return;
 	}
 	if (!spec->kb_dev)
 		return;
 	switch (action) {
 	case HDA_FIXUP_ACT_PROBE:
 		spec->init_amp = ALC_INIT_DEFAULT;
 		break;
 	case HDA_FIXUP_ACT_FREE:
 		input_unregister_device(spec->kb_dev);
 		spec->kb_dev = NULL;
 	}
 }
 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
 					     const struct hda_fixup *fix, int action)
 {
 	/* Line2 = mic mute hotkey
 	   GPIO2 = mic mute LED */
 	static const struct hda_verb gpio_init[] = {
 		{ 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
 		{ 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
 		{}
 	};
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		if (alc_register_micmute_input_device(codec) != 0)
 			return;
 		snd_hda_add_verbs(codec, gpio_init);
 		snd_hda_jack_detect_enable_callback(codec, 0x1b,
 						    gpio2_mic_hotkey_event);
 		spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 0;
 		spec->gpio_mic_led_mask = 0x04;
 		return;
 	}
 	if (!spec->kb_dev)
 		return;
 	switch (action) {
 	case HDA_FIXUP_ACT_PROBE:
 		spec->init_amp = ALC_INIT_DEFAULT;
 		break;
 	case HDA_FIXUP_ACT_FREE:
 		input_unregister_device(spec->kb_dev);
 		spec->kb_dev = NULL;
 	}
 }
 static void alc269_fixup_hp_line1_mic1_led(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.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
 		spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
 		spec->mute_led_polarity = 0;
 		spec->mute_led_nid = 0x1a;
 		spec->cap_mute_led_nid = 0x18;
 		spec->gen.vmaster_mute_enum = 1;
 		codec->power_filter = led_power_filter;
 	}
 }
 static void alc_headset_mode_unplugged(struct hda_codec *codec)
 {
 	static struct coef_fw coef0255[] = {
 		WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
 		WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
 		WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
 		WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
 		{}
 	};
 	static struct coef_fw coef0233[] = {
 		WRITE_COEF(0x1b, 0x0c0b),
 		WRITE_COEF(0x45, 0xc429),
 		UPDATE_COEF(0x35, 0x4000, 0),
 		WRITE_COEF(0x06, 0x2104),
 		WRITE_COEF(0x1a, 0x0001),
 		WRITE_COEF(0x26, 0x0004),
 		WRITE_COEF(0x32, 0x42a3),
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
 		UPDATE_COEF(0x50, 0x2000, 0x2000),
 		UPDATE_COEF(0x56, 0x0006, 0x0006),
 		UPDATE_COEF(0x66, 0x0008, 0),
 		UPDATE_COEF(0x67, 0x2000, 0),
 		{}
 	};
 	static struct coef_fw coef0292[] = {
 		WRITE_COEF(0x76, 0x000e),
 		WRITE_COEF(0x6c, 0x2400),
 		WRITE_COEF(0x18, 0x7308),
 		WRITE_COEF(0x6b, 0xc429),
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
 		UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
 		UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
 		WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
 		{}
 	};
 	static struct coef_fw coef0668[] = {
 		WRITE_COEF(0x15, 0x0d40),
 		WRITE_COEF(0xb7, 0x802b),
 		{}
 	};
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEF(0x4a, 1<<8, 0),
 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
 		UPDATE_COEF(0x63, 3<<14, 3<<14),
 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
 		UPDATE_COEF(0x4a, 3<<10, 3<<10),
 		UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
 		UPDATE_COEF(0x4a, 3<<10, 0),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_process_coef_fw(codec, coef0255);
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		alc_process_coef_fw(codec, coef0233);
 		break;
 	case 0x10ec0286:
 	case 0x10ec0288:
 	case 0x10ec0298:
 		alc_process_coef_fw(codec, coef0288);
 		break;
 	case 0x10ec0292:
 		alc_process_coef_fw(codec, coef0292);
 		break;
 	case 0x10ec0293:
 		alc_process_coef_fw(codec, coef0293);
 		break;
 	case 0x10ec0668:
 		alc_process_coef_fw(codec, coef0668);
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_process_coef_fw(codec, coef0225);
 		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)
 {
 	static struct coef_fw coef0255[] = {
 		WRITE_COEFEX(0x57, 0x03, 0x8aa6),
 		WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
 		{}
 	};
 	static struct coef_fw coef0233[] = {
 		UPDATE_COEF(0x35, 0, 1<<14),
 		WRITE_COEF(0x06, 0x2100),
 		WRITE_COEF(0x1a, 0x0021),
 		WRITE_COEF(0x26, 0x008c),
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x50, 0x2000, 0),
 		UPDATE_COEF(0x56, 0x0006, 0),
 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
 		UPDATE_COEF(0x66, 0x0008, 0x0008),
 		UPDATE_COEF(0x67, 0x2000, 0x2000),
 		{}
 	};
 	static struct coef_fw coef0292[] = {
 		WRITE_COEF(0x19, 0xa208),
 		WRITE_COEF(0x2e, 0xacf0),
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
 		UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
 		{}
 	};
 	static struct coef_fw coef0688[] = {
 		WRITE_COEF(0xb7, 0x802b),
 		WRITE_COEF(0xb5, 0x1040),
 		UPDATE_COEF(0xc3, 0, 1<<12),
 		{}
 	};
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
 		UPDATE_COEF(0x4a, 3<<4, 2<<4),
 		UPDATE_COEF(0x63, 3<<14, 0),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_write_coef_idx(codec, 0x45, 0xc489);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0255);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		alc_write_coef_idx(codec, 0x45, 0xc429);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0233);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0286:
 	case 0x10ec0288:
 	case 0x10ec0298:
 		alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0288);
 		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_process_coef_fw(codec, coef0292);
 		break;
 	case 0x10ec0293:
 		/* Set to TRS mode */
 		alc_write_coef_idx(codec, 0x45, 0xc429);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0293);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0662:
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0668:
 		alc_write_coef_idx(codec, 0x11, 0x0001);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0688);
 		snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
 		snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
 		alc_process_coef_fw(codec, coef0225);
 		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)
 {
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
 		{}
 	};
 	static struct coef_fw coef0255[] = {
 		WRITE_COEF(0x45, 0xc089),
 		WRITE_COEF(0x45, 0xc489),
 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
 		WRITE_COEF(0x49, 0x0049),
 		{}
 	};
 	static struct coef_fw coef0233[] = {
 		WRITE_COEF(0x06, 0x2100),
 		WRITE_COEF(0x32, 0x4ea3),
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
 		UPDATE_COEF(0x50, 0x2000, 0x2000),
 		UPDATE_COEF(0x56, 0x0006, 0x0006),
 		UPDATE_COEF(0x66, 0x0008, 0),
 		UPDATE_COEF(0x67, 0x2000, 0),
 		{}
 	};
 	static struct coef_fw coef0292[] = {
 		WRITE_COEF(0x76, 0x000e),
 		WRITE_COEF(0x6c, 0x2400),
 		WRITE_COEF(0x6b, 0xc429),
 		WRITE_COEF(0x18, 0x7308),
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
 		WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
 		UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
 		{}
 	};
 	static struct coef_fw coef0688[] = {
 		WRITE_COEF(0x11, 0x0041),
 		WRITE_COEF(0x15, 0x0d40),
 		WRITE_COEF(0xb7, 0x802b),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_process_coef_fw(codec, coef0225);
 		break;
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_process_coef_fw(codec, coef0255);
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		alc_process_coef_fw(codec, coef0233);
 		break;
 	case 0x10ec0286:
 	case 0x10ec0288:
 	case 0x10ec0298:
 		alc_process_coef_fw(codec, coef0288);
 		break;
 	case 0x10ec0292:
 		alc_process_coef_fw(codec, coef0292);
 		break;
 	case 0x10ec0293:
 		alc_process_coef_fw(codec, coef0293);
 		break;
 	case 0x10ec0668:
 		alc_process_coef_fw(codec, coef0688);
 		break;
 	}
 	codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
 }
 /* Iphone type */
 static void alc_headset_mode_ctia(struct hda_codec *codec)
 {
 	static struct coef_fw coef0255[] = {
 		WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
 		WRITE_COEF(0x1b, 0x0c2b),
 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
 		{}
 	};
 	static struct coef_fw coef0233[] = {
 		WRITE_COEF(0x45, 0xd429),
 		WRITE_COEF(0x1b, 0x0c2b),
 		WRITE_COEF(0x32, 0x4ea3),
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x50, 0x2000, 0x2000),
 		UPDATE_COEF(0x56, 0x0006, 0x0006),
 		UPDATE_COEF(0x66, 0x0008, 0),
 		UPDATE_COEF(0x67, 0x2000, 0),
 		{}
 	};
 	static struct coef_fw coef0292[] = {
 		WRITE_COEF(0x6b, 0xd429),
 		WRITE_COEF(0x76, 0x0008),
 		WRITE_COEF(0x18, 0x7388),
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
 		{}
 	};
 	static struct coef_fw coef0688[] = {
 		WRITE_COEF(0x11, 0x0001),
 		WRITE_COEF(0x15, 0x0d60),
 		WRITE_COEF(0xc3, 0x0000),
 		{}
 	};
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
 		UPDATE_COEF(0x49, 1<<8, 1<<8),
 		UPDATE_COEF(0x4a, 7<<6, 7<<6),
 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_process_coef_fw(codec, coef0255);
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		alc_process_coef_fw(codec, coef0233);
 		break;
 	case 0x10ec0298:
 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */
 		/* ALC298 jack type setting is the same with ALC286/ALC288 */
 	case 0x10ec0286:
 	case 0x10ec0288:
 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
 		msleep(300);
 		alc_process_coef_fw(codec, coef0288);
 		break;
 	case 0x10ec0292:
 		alc_process_coef_fw(codec, coef0292);
 		break;
 	case 0x10ec0293:
 		alc_process_coef_fw(codec, coef0293);
 		break;
 	case 0x10ec0668:
 		alc_process_coef_fw(codec, coef0688);
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_process_coef_fw(codec, coef0225);
 		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)
 {
 	static struct coef_fw coef0255[] = {
 		WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
 		WRITE_COEF(0x1b, 0x0c2b),
 		WRITE_COEFEX(0x57, 0x03, 0x8ea6),
 		{}
 	};
 	static struct coef_fw coef0233[] = {
 		WRITE_COEF(0x45, 0xe429),
 		WRITE_COEF(0x1b, 0x0c2b),
 		WRITE_COEF(0x32, 0x4ea3),
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x50, 0x2000, 0x2000),
 		UPDATE_COEF(0x56, 0x0006, 0x0006),
 		UPDATE_COEF(0x66, 0x0008, 0),
 		UPDATE_COEF(0x67, 0x2000, 0),
 		{}
 	};
 	static struct coef_fw coef0292[] = {
 		WRITE_COEF(0x6b, 0xe429),
 		WRITE_COEF(0x76, 0x0008),
 		WRITE_COEF(0x18, 0x7388),
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
 		UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
 		{}
 	};
 	static struct coef_fw coef0688[] = {
 		WRITE_COEF(0x11, 0x0001),
 		WRITE_COEF(0x15, 0x0d50),
 		WRITE_COEF(0xc3, 0x0000),
 		{}
 	};
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
 		UPDATE_COEF(0x49, 1<<8, 1<<8),
 		UPDATE_COEF(0x4a, 7<<6, 7<<6),
 		UPDATE_COEF(0x4a, 3<<4, 3<<4),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_process_coef_fw(codec, coef0255);
 		break;
 	case 0x10ec0233:
 	case 0x10ec0283:
 		alc_process_coef_fw(codec, coef0233);
 		break;
 	case 0x10ec0298:
 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
 		/* ALC298 jack type setting is the same with ALC286/ALC288 */
 	case 0x10ec0286:
 	case 0x10ec0288:
 		alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
 		msleep(300);
 		alc_process_coef_fw(codec, coef0288);
 		break;
 	case 0x10ec0292:
 		alc_process_coef_fw(codec, coef0292);
 		break;
 	case 0x10ec0293:
 		alc_process_coef_fw(codec, coef0293);
 		break;
 	case 0x10ec0668:
 		alc_process_coef_fw(codec, coef0688);
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_process_coef_fw(codec, coef0225);
 		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;
 	static struct coef_fw coef0255[] = {
 		WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
 		WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
  conteol) */
 		{}
 	};
 	static struct coef_fw coef0288[] = {
 		UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
 		{}
 	};
 	static struct coef_fw coef0293[] = {
 		UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
 		WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
 		{}
 	};
 	static struct coef_fw coef0688[] = {
 		WRITE_COEF(0x11, 0x0001),
 		WRITE_COEF(0xb7, 0x802b),
 		WRITE_COEF(0x15, 0x0d60),
 		WRITE_COEF(0xc3, 0x0c00),
 		{}
 	};
 	static struct coef_fw coef0225[] = {
 		UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
 		UPDATE_COEF(0x49, 1<<8, 1<<8),
 		{}
 	};
 	switch (codec->core.vendor_id) {
 	case 0x10ec0255:
 	case 0x10ec0256:
 		alc_process_coef_fw(codec, coef0255);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x0070) == 0x0070;
 		break;
 	case 0x10ec0233:
 	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 0x10ec0298:
 		alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */
 		/* ALC298 check jack type is the same with ALC286/ALC288 */
 	case 0x10ec0286:
 	case 0x10ec0288:
 		alc_process_coef_fw(codec, coef0288);
 		msleep(350);
 		val = alc_read_coef_idx(codec, 0x50);
 		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 0x10ec0293:
 		alc_process_coef_fw(codec, coef0293);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x0070) == 0x0070;
 		break;
 	case 0x10ec0668:
 		alc_process_coef_fw(codec, coef0688);
 		msleep(300);
 		val = alc_read_coef_idx(codec, 0xbe);
 		is_ctia = (val & 0x1c02) == 0x1c02;
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		alc_process_coef_fw(codec, coef0225);
 		msleep(800);
 		val = alc_read_coef_idx(codec, 0x46);
 		is_ctia = (val & 0x00f0) == 0x00f0;
 		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 && spec->headphone_mic_pin != hp_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_callback *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 */
 	static struct coef_fw fw[] = {
 		WRITE_COEF(0x1b, 0x880b),
 		WRITE_COEF(0x45, 0xd089),
 		WRITE_COEF(0x1b, 0x080b),
 		WRITE_COEF(0x46, 0x0004),
 		WRITE_COEF(0x1b, 0x0c0b),
 		{}
 	};
 	alc_process_coef_fw(codec, fw);
 	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 alc288_update_headset_jack_cb(struct hda_codec *codec,
 				       struct hda_jack_callback *jack)
 {
 	struct alc_spec *spec = codec->spec;
 	int present;
 	alc_update_headset_jack_cb(codec, jack);
 	/* Headset Mic enable or disable, only for Dell Dino */
 	present = spec->gen.hp_jack_present ? 0x40 : 0;
 	snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 				present);
 }
 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	alc_fixup_headset_mode(codec, fix, action);
 	if (action == HDA_FIXUP_ACT_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
 	}
 }
 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_disable_aamix(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		struct alc_spec *spec = codec->spec;
 		/* Disable AA-loopback as it causes white noise */
 		spec->gen.mixer_nid = 0;
 	}
 }
 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
 				  const struct hda_fixup *fix, int action)
 {
 	static const struct hda_pintbl pincfgs[] = {
 		{ 0x16, 0x21211010 }, /* dock headphone */
 		{ 0x19, 0x21a11010 }, /* dock mic */
 		{ }
 	};
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->shutup = alc_no_shutup; /* reduce click noise */
 		spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 		codec->power_save_node = 0; /* avoid click noises */
 		snd_hda_apply_pincfgs(codec, pincfgs);
 	}
 }
 static void alc_shutup_dell_xps13(struct hda_codec *codec)
 {
 	struct alc_spec *spec = codec->spec;
 	int hp_pin = spec->gen.autocfg.hp_pins[0];
 	/* Prevent pop noises when headphones are plugged in */
 	snd_hda_codec_write(codec, hp_pin, 0,
 			    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 	msleep(20);
 }
 static void alc_fixup_dell_xps13(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct alc_spec *spec = codec->spec;
 	struct hda_input_mux *imux = &spec->gen.input_mux;
 	int i;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		/* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
 		 * it causes a click noise at start up
 		 */
 		snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
 		break;
 	case HDA_FIXUP_ACT_PROBE:
 		spec->shutup = alc_shutup_dell_xps13;
 		/* Make the internal mic the default input source. */
 		for (i = 0; i < imux->num_items; i++) {
 			if (spec->gen.imux_pins[i] == 0x12) {
 				spec->gen.cur_mux[0] = i;
 				break;
 			}
 		}
 		break;
 	}
 }
 static void alc_fixup_headset_mode_alc662(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_mic = 1; /* Mic-in is same pin as headphone */
 		/* Disable boost for mic-in permanently. (This code is only called
 		   from quirks that guarantee that the headphone is at NID 0x1b.) */
 		snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
 		snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
 	} else
 		alc_fixup_headset_mode(codec, fix, action);
 }
 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) {
 		alc_write_coef_idx(codec, 0xc4, 0x8000);
 		alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
 		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_callback *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;
 	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 */
 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
 		/* Enable Line1 input control by verb */
 		alc_update_coef_idx(codec, 0x1a, 0, 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;
 	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 */
 		alc_update_coef_idx(codec, 0x06, 0x000c, 0);
 		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,
 						    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);
 	}
 }
 /* Hook to update amp GPIO4 for automute */
 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
 					  struct hda_jack_callback *jack)
 {
 	struct alc_spec *spec = codec->spec;
 	snd_hda_gen_hp_automute(codec, jack);
 	/* mute_led_polarity is set to 0, so we pass inverted value here */
 	alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
 }
 /* Manage GPIOs for HP EliteBook Folio 9480m.
  *
  * GPIO4 is the headphone amplifier power control
  * GPIO3 is the audio output mute indicator LED
  */
 static void alc280_fixup_hp_9480m(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) {
 		/* Set the hooks to turn the headphone amp on/off
 		 * as needed
 		 */
 		spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
 		spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
 		/* The GPIOs are currently off */
 		spec->gpio_led = 0;
 		/* GPIO3 is connected to the output mute LED,
 		 * high is on, low is off
 		 */
 		spec->mute_led_polarity = 0;
 		spec->gpio_mute_led_mask = 0x08;
 		/* Initialize GPIO configuration */
 		snd_hda_add_verbs(codec, gpio_init);
 	}
 }
 /* for hda_fixup_thinkpad_acpi() */
 #include "thinkpad_helper.c"
 /* for dell wmi mic mute led */
 #include "dell_wmi_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,
 	ALC275_FIXUP_SONY_DISABLE_AAMIX,
 	ALC271_FIXUP_DMIC,
 	ALC269_FIXUP_PCM_44K,
 	ALC269_FIXUP_STEREO_DMIC,
 	ALC269_FIXUP_HEADSET_MIC,
 	ALC269_FIXUP_QUANTA_MUTE,
 	ALC269_FIXUP_LIFEBOOK,
 	ALC269_FIXUP_LIFEBOOK_EXTMIC,
 	ALC269_FIXUP_LIFEBOOK_HP_PIN,
 	ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
 	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_HP_GPIO_MIC1_LED,
 	ALC269_FIXUP_HP_LINE1_MIC1_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_ASPIRE_HEADSET_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,
 	ALC269_FIXUP_DMIC_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,
 	ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC292_FIXUP_TPT440_DOCK,
 	ALC292_FIXUP_TPT440,
 	ALC283_FIXUP_BXBT2807_MIC,
 	ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
 	ALC282_FIXUP_ASPIRE_V5_PINS,
 	ALC280_FIXUP_HP_GPIO4,
 	ALC286_FIXUP_HP_GPIO_LED,
 	ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
 	ALC280_FIXUP_HP_DOCK_PINS,
 	ALC280_FIXUP_HP_9480M,
 	ALC288_FIXUP_DELL_HEADSET_MODE,
 	ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC288_FIXUP_DELL_XPS_13_GPIO6,
 	ALC288_FIXUP_DELL_XPS_13,
 	ALC288_FIXUP_DISABLE_AAMIX,
 	ALC292_FIXUP_DELL_E7X,
 	ALC292_FIXUP_DISABLE_AAMIX,
 	ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
 	ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC275_FIXUP_DELL_XPS,
 	ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
 	ALC293_FIXUP_LENOVO_SPK_NOISE,
 	ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
 	ALC255_FIXUP_DELL_SPK_NOISE,
 	ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
 	ALC280_FIXUP_HP_HEADSET_MIC,
 	ALC221_FIXUP_HP_FRONT_MIC,
 	ALC292_FIXUP_TPT460,
 };
 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
 	},
 	[ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_SONY_VAIO
 	},
 	[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_LIFEBOOK_EXTMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1903c }, /* headset mic, with jack detect */
 			{ }
 		},
 	},
 	[ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x21, 0x0221102f }, /* HP out */
 			{ }
 		},
 	},
 	[ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_pincfg_no_hp_to_lineout,
 	},
 	[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_HP_GPIO_MIC1_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_gpio_mic1_led,
 	},
 	[ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc269_fixup_hp_line1_mic1_led,
 	},
 	[ALC269_FIXUP_INV_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic,
 	},
 	[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,
 		.chained = true,
 		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
 	},
 	[ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_no_hp_mic,
 	},
 	[ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
 	},
 	[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,
 	},
 	[ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_inv_dmic,
 		.chained = true,
 		.chain_id = ALC269_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,
 		.chained = true,
 		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
 	},
 	[ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
 	},
 	[ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
 			{ 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE
 	},
 	[ALC292_FIXUP_TPT440_DOCK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_tpt440_dock,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
 	},
 	[ALC292_FIXUP_TPT440] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC292_FIXUP_TPT440_DOCK,
 	},
 	[ALC283_FIXUP_BXBT2807_MIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x04a110f0 },
 			{ },
 		},
 	},
 	[ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_dell_wmi,
 	},
 	[ALC282_FIXUP_ASPIRE_V5_PINS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x12, 0x90a60130 },
 			{ 0x14, 0x90170110 },
 			{ 0x17, 0x40000008 },
 			{ 0x18, 0x411111f0 },
 			{ 0x19, 0x01a1913c },
 			{ 0x1a, 0x411111f0 },
 			{ 0x1b, 0x411111f0 },
 			{ 0x1d, 0x40f89b2d },
 			{ 0x1e, 0x411111f0 },
 			{ 0x21, 0x0321101f },
 			{ },
 		},
 	},
 	[ALC280_FIXUP_HP_GPIO4] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc280_fixup_hp_gpio4,
 	},
 	[ALC286_FIXUP_HP_GPIO_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc286_fixup_hp_gpio_led,
 	},
 	[ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc280_fixup_hp_gpio2_mic_hotkey,
 	},
 	[ALC280_FIXUP_HP_DOCK_PINS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x1b, 0x21011020 }, /* line-out */
 			{ 0x1a, 0x01a1903c }, /* headset mic */
 			{ 0x18, 0x2181103f }, /* line-in */
 			{ },
 		},
 		.chained = true,
 		.chain_id = ALC280_FIXUP_HP_GPIO4
 	},
 	[ALC280_FIXUP_HP_9480M] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc280_fixup_hp_9480m,
 	},
 	[ALC288_FIXUP_DELL_HEADSET_MODE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_dell_alc288,
 		.chained = true,
 		.chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
 	},
 	[ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x18, 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 = ALC288_FIXUP_DELL_HEADSET_MODE
 	},
 	[ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x01, AC_VERB_SET_GPIO_MASK, 0x40},
 			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
 			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
 	},
 	[ALC288_FIXUP_DISABLE_AAMIX] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
 	},
 	[ALC288_FIXUP_DELL_XPS_13] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_dell_xps13,
 		.chained = true,
 		.chain_id = ALC288_FIXUP_DISABLE_AAMIX
 	},
 	[ALC292_FIXUP_DISABLE_AAMIX] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
 	},
 	[ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
 	},
 	[ALC292_FIXUP_DELL_E7X] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_dell_xps13,
 		.chained = true,
 		.chain_id = ALC292_FIXUP_DISABLE_AAMIX
 	},
 	[ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x18, 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
 	},
 	[ALC275_FIXUP_DELL_XPS] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* Enables internal speaker */
 			{0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
 			{0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
 			{0x20, AC_VERB_SET_COEF_INDEX, 0x30},
 			{0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
 			{}
 		}
 	},
 	[ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* Disable pass-through path for FRONT 14h */
 			{0x20, AC_VERB_SET_COEF_INDEX, 0x36},
 			{0x20, AC_VERB_SET_PROC_COEF, 0x1737},
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
 	},
 	[ALC293_FIXUP_LENOVO_SPK_NOISE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_THINKPAD_ACPI
 	},
 	[ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc233_fixup_lenovo_line2_mic_hotkey,
 	},
 	[ALC255_FIXUP_DELL_SPK_NOISE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
 	},
 	[ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			/* Disable pass-through path for FRONT 14h */
 			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
 			{ 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
 	},
 	[ALC280_FIXUP_HP_HEADSET_MIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MIC,
 	},
 	[ALC221_FIXUP_HP_FRONT_MIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x02a19020 }, /* Front Mic */
 			{ }
 		},
 	},
 	[ALC292_FIXUP_TPT460] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_tpt440_dock,
 		.chained = true,
 		.chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
 	},
 };
 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, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
 	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(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
 	SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
 	SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
 	SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
 	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, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
 	SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
 	SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
 	SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
 	SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
 	SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
 	SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
 	SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
 	SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
 	SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
 	SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_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, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
 	SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
 	/* ALC282 */
 	SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2268, "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, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
 	SND_PCI_QUIRK(0x103c, 0x229e, "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, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
 	SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	/* ALC290 */
 	SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2260, "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, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
 	SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x228b, "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, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
 	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
 	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
 	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(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
 	SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
 	SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
 	SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
 	SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
 	SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
 	SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),
 	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 T440s", ALC292_FIXUP_TPT440),
 	SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
 	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, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
 	SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
 	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(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 snd_pci_quirk alc269_fixup_vendor_tbl[] = {
 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
 	SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
 	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
 	SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
 	{}
 };
 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_HEADSET_MODE, .name = "headset-mode"},
 	{.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-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-dac-wcaps"},
 	{.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
 	{.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
 	{.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
 	{.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
 	{}
 };
 #define ALC225_STANDARD_PINS \
 	{0x12, 0xb7a60130}, \
 	{0x21, 0x04211020}
 #define ALC256_STANDARD_PINS \
 	{0x12, 0x90a60140}, \
 	{0x14, 0x90170110}, \
 	{0x21, 0x02211020}
 #define ALC282_STANDARD_PINS \
 	{0x14, 0x90170110}
 #define ALC290_STANDARD_PINS \
 	{0x12, 0x99a30130}
 #define ALC292_STANDARD_PINS \
 	{0x14, 0x90170110}, \
 	{0x15, 0x0221401f}
 #define ALC298_STANDARD_PINS \
 	{0x12, 0x90a60130}, \
 	{0x21, 0x03211020}
 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC225_STANDARD_PINS,
 		{0x14, 0x901701a0}),
 	SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC225_STANDARD_PINS,
 		{0x14, 0x901701b0}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
 		{0x14, 0x90170110},
 		{0x21, 0x02211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
+		{0x14, 0x90170130},
+		{0x21, 0x02211040}),
+	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60140},
 		{0x14, 0x90170110},
 		{0x21, 0x02211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170120},
 		{0x21, 0x02211030}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x14, 0x90170130},
 		{0x1b, 0x01014020},
 		{0x21, 0x0221103f}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x14, 0x90170150},
 		{0x1b, 0x02011020},
 		{0x21, 0x0221105f}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x14, 0x90170110},
 		{0x1b, 0x01014020},
 		{0x21, 0x0221101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170120},
 		{0x17, 0x90170140},
 		{0x21, 0x0321102f}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170130},
 		{0x21, 0x02211040}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170140},
 		{0x21, 0x02211050}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60170},
 		{0x14, 0x90170120},
 		{0x21, 0x02211030}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60170},
 		{0x14, 0x90170130},
 		{0x21, 0x02211040}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60170},
 		{0x14, 0x90171130},
 		{0x21, 0x02211040}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60170},
 		{0x14, 0x90170140},
 		{0x21, 0x02211050}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60180},
 		{0x14, 0x90170130},
 		{0x21, 0x02211040}),
 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170120},
 		{0x21, 0x02211030}),
 	SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC256_STANDARD_PINS),
 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
 		{0x12, 0x90a60130},
 		{0x14, 0x90170110},
 		{0x15, 0x0421101f},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
 		{0x12, 0x90a60140},
 		{0x14, 0x90170110},
 		{0x15, 0x0421101f},
 		{0x18, 0x02811030},
 		{0x1a, 0x04a1103f},
 		{0x1b, 0x02011020}),
 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x99a30130},
 		{0x19, 0x03a11020},
 		{0x21, 0x0321101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x99a30130},
 		{0x19, 0x03a11020},
 		{0x21, 0x03211040}),
 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x99a30130},
 		{0x19, 0x03a11030},
 		{0x21, 0x03211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x99a30130},
 		{0x19, 0x04a11020},
 		{0x21, 0x0421101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x90a60140},
 		{0x19, 0x04a11030},
 		{0x21, 0x04211020}),
 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x90a60130},
 		{0x21, 0x0321101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170120},
 		{0x21, 0x02211030}),
 	SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC282_STANDARD_PINS,
 		{0x12, 0x90a60130},
 		{0x19, 0x03a11020},
 		{0x21, 0x0321101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
 		{0x12, 0x90a60120},
 		{0x14, 0x90170110},
 		{0x21, 0x0321101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x15, 0x04211040},
 		{0x18, 0x90170112},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x15, 0x04211040},
 		{0x18, 0x90170110},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x15, 0x0421101f},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x15, 0x04211020},
 		{0x1a, 0x04a11040}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x14, 0x90170110},
 		{0x15, 0x04211020},
 		{0x1a, 0x04a11040}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x14, 0x90170110},
 		{0x15, 0x04211020},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
 		ALC290_STANDARD_PINS,
 		{0x14, 0x90170110},
 		{0x15, 0x0421101f},
 		{0x1a, 0x04a11020}),
 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x90a60140},
 		{0x16, 0x01014020},
 		{0x19, 0x01a19030}),
 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x90a60140},
 		{0x16, 0x01014020},
 		{0x18, 0x02a19031},
 		{0x19, 0x01a1903e}),
 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x90a60140}),
 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x13, 0x90a60140},
 		{0x16, 0x21014020},
 		{0x19, 0x21a19030}),
 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x13, 0x90a60140}),
 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC298_STANDARD_PINS,
 		{0x17, 0x90170110}),
 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC298_STANDARD_PINS,
 		{0x17, 0x90170140}),
 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC298_STANDARD_PINS,
 		{0x17, 0x90170150}),
 	{}
 };
 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) {
 		/* Power up output pin */
 		alc_update_coef_idx(codec, 0x04, 0, 1<<11);
 	}
 	if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
 		val = alc_read_coef_idx(codec, 0xd);
 		if (val != -1 && (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 != -1 && (val & 0x01c0) >> 6 != 0x4) {
 			/* Class D power on reset */
 			alc_write_coef_idx(codec, 0x17, val | (1<<7));
 		}
 	}
 	/* HP */
 	alc_update_coef_idx(codec, 0x4, 0, 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;
 	codec->power_save_node = 1;
 #ifdef CONFIG_PM
 	codec->patch_ops.suspend = alc269_suspend;
 	codec->patch_ops.resume = alc269_resume;
 #endif
 	spec->shutup = alc269_shutup;
 	snd_hda_pick_fixup(codec, alc269_fixup_models,
 		       alc269_fixup_tbl, alc269_fixups);
 	snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
 	snd_hda_pick_fixup(codec, NULL,	alc269_fixup_vendor_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->core.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:
 	case 0x10ec0288:
 		spec->codec_variant = ALC269_TYPE_ALC286;
 		spec->shutup = alc286_shutup;
 		break;
 	case 0x10ec0298:
 		spec->codec_variant = ALC269_TYPE_ALC298;
 		break;
 	case 0x10ec0255:
 		spec->codec_variant = ALC269_TYPE_ALC255;
 		break;
 	case 0x10ec0256:
 		spec->codec_variant = ALC269_TYPE_ALC256;
 		spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
 		alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
 		break;
 	case 0x10ec0225:
 	case 0x10ec0295:
 		spec->codec_variant = ALC269_TYPE_ALC225;
 		break;
 	case 0x10ec0234:
 	case 0x10ec0274:
 	case 0x10ec0294:
 		spec->codec_variant = ALC269_TYPE_ALC294;
 		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 && spec->gen.mixer_nid)
 		set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
 	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;
 #ifdef CONFIG_PM
 	spec->power_hook = alc_power_eapd;
 #endif
 	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);
 	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;
 	spec->shutup = alc_eapd_shutup;
 	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);
 	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->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
 	    codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
 	    codec->core.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;
 	}
 }
 /* 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->core.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 = alc_fixup_gpio_mute_hook;
 		spec->gpio_led = 0;
 		spec->mute_led_polarity = 1;
 		spec->gpio_mute_led_mask = 0x01;
 		snd_hda_add_verbs(codec, gpio_init);
 		codec->power_filter = gpio_led_power_filter;
 	}
 }
 static struct coef_fw alc668_coefs[] = {
 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
 	WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
 	WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
 	WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
 	WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
 	WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
 	WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
 	WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
 	WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
 	WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
 	WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
 	WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
 	WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
 	WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
 	WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
 	WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
 	WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
 	WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
 	WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
 	{}
 };
 static void alc668_restore_default_value(struct hda_codec *codec)
 {
 	alc_process_coef_fw(codec, alc668_coefs);
 }
 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,
 	ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
 	ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
 	ALC662_FIXUP_HEADSET_MODE,
 	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,
 	ALC668_FIXUP_DELL_DISABLE_AAMIX,
 	ALC668_FIXUP_DELL_XPS13,
 	ALC662_FIXUP_ASUS_Nx50,
 	ALC668_FIXUP_ASUS_Nx51,
 };
 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,
 	},
 	[ALC668_FIXUP_DELL_XPS13] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_dell_xps13,
 		.chained = true,
 		.chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
 	},
 	[ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_disable_aamix,
 		.chained = true,
 		.chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
 	},
 	[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
 	},
 	[ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
 			/* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
 			{ }
 		},
 		.chained = true,
 		.chain_id = ALC662_FIXUP_HEADSET_MODE
 	},
 	[ALC662_FIXUP_HEADSET_MODE] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_headset_mode_alc662,
 	},
 	[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,
 	},
 	[ALC662_FIXUP_ASUS_Nx50] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc_fixup_auto_mute_via_amp,
 		.chained = true,
 		.chain_id = ALC662_FIXUP_BASS_1A
 	},
 	[ALC668_FIXUP_ASUS_Nx51] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{0x1a, 0x90170151}, /* bass speaker */
 			{}
 		},
 		.chained = true,
 		.chain_id = ALC662_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, 0x0241, "Packard Bell DOTS", 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, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
 	SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
 	SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
 	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, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
 	SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
 	SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
 	SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
 	SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
 	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, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
 	SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
 	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 const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
 	SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
 		{0x14, 0x01014010},
 		{0x18, 0x01a19020},
 		{0x1a, 0x0181302f},
 		{0x1b, 0x0221401f}),
 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
 		{0x12, 0x99a30130},
 		{0x14, 0x90170110},
 		{0x15, 0x0321101f},
 		{0x16, 0x03011020}),
 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
 		{0x12, 0x99a30140},
 		{0x14, 0x90170110},
 		{0x15, 0x0321101f},
 		{0x16, 0x03011020}),
 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
 		{0x12, 0x99a30150},
 		{0x14, 0x90170110},
 		{0x15, 0x0321101f},
 		{0x16, 0x03011020}),
 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
 		{0x14, 0x90170110},
 		{0x15, 0x0321101f},
 		{0x16, 0x03011020}),
 	SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
 		{0x12, 0x90a60130},
 		{0x14, 0x90170110},
 		{0x15, 0x0321101f}),
 	{}
 };
 /*
  */
 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;
 	spec->shutup = alc_eapd_shutup;
 	/* handle multiple HPs as is */
 	spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
 	switch (codec->core.vendor_id) {
 	case 0x10ec0668:
 		spec->init_hook = alc668_restore_default_value;
 		break;
 	}
 	snd_hda_pick_fixup(codec, alc662_fixup_models,
 		       alc662_fixup_tbl, alc662_fixups);
 	snd_hda_pick_pin_fixup(codec, alc662_pin_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->core.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;
 		}
 	}
 	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;
 	}
 	return 0;
 }
 /*
  * patch entries
  */
 static const struct hda_device_id snd_hda_id_realtek[] = {
 	HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
 	HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
 	HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
 	HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
 	HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
 	HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
 	HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
 	HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
 	HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
 	HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
 	HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
 	HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
 	HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
 	HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
 	HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
 	HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
 	HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
 	{} /* terminator */
 };
 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Realtek HD-audio codec");
 static struct hda_codec_driver realtek_driver = {
 	.id = snd_hda_id_realtek,
 };
 module_hda_codec_driver(realtek_driver);