sound/pci/hda/alc262_quirks.c

   1 /*
   2  * ALC262 quirk models
   3  * included by patch_realtek.c
   4  */
   5
   6 /* ALC262 models */
   7 enum {
   8         ALC262_AUTO,
   9         ALC262_BASIC,
  10         ALC262_HIPPO,
  11         ALC262_HIPPO_1,
  12         ALC262_FUJITSU,
  13         ALC262_BENQ_ED8,
  14         ALC262_BENQ_T31,
  15         ALC262_ULTRA,
  16         ALC262_LENOVO_3000,
  17         ALC262_NEC,
  18         ALC262_TOSHIBA_S06,
  19         ALC262_TOSHIBA_RX1,
  20         ALC262_TYAN,
  21         ALC262_MODEL_LAST /* last tag */
  22 };
  23
  24 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
  25 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
  26
  27 #define alc262_dac_nids         alc260_dac_nids
  28 #define alc262_adc_nids         alc882_adc_nids
  29 #define alc262_adc_nids_alt     alc882_adc_nids_alt
  30 #define alc262_capsrc_nids      alc882_capsrc_nids
  31 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
  32
  33 #define alc262_modes            alc260_modes
  34 #define alc262_capture_source   alc882_capture_source
  35
  36 static const hda_nid_t alc262_dmic_adc_nids[1] = {
  37         /* ADC0 */
  38         0x09
  39 };
  40
  41 static const hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
  42
  43 static const struct snd_kcontrol_new alc262_base_mixer[] = {
  44         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
  45         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
  46         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
  47         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
  48         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
  49         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
  50         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
  51         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
  52         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
  53         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
  54         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
  55         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
  56         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
  57         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  58         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
  59         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
  60         { } /* end */
  61 };
  62
  63 /* update HP, line and mono-out pins according to the master switch */
  64 #define alc262_hp_master_update         alc260_hp_master_update
  65
  66 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
  67 #define alc262_hp_master_sw_put         alc260_hp_master_sw_put
  68
  69 #define ALC262_HP_MASTER_SWITCH                                 \
  70         {                                                       \
  71                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
  72                 .name = "Master Playback Switch",               \
  73                 .info = snd_ctl_boolean_mono_info,              \
  74                 .get = alc262_hp_master_sw_get,                 \
  75                 .put = alc262_hp_master_sw_put,                 \
  76         }, \
  77         {                                                       \
  78                 .iface = NID_MAPPING,                           \
  79                 .name = "Master Playback Switch",               \
  80                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
  81         }
  82
  83 /* bind hp and internal speaker mute (with plug check) as master switch */
  84 #define alc262_hippo_master_update      alc262_hp_master_update
  85 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
  86 #define alc262_hippo_master_sw_put      alc262_hp_master_sw_put
  87
  88 #define ALC262_HIPPO_MASTER_SWITCH                              \
  89         {                                                       \
  90                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
  91                 .name = "Master Playback Switch",               \
  92                 .info = snd_ctl_boolean_mono_info,              \
  93                 .get = alc262_hippo_master_sw_get,              \
  94                 .put = alc262_hippo_master_sw_put,              \
  95         },                                                      \
  96         {                                                       \
  97                 .iface = NID_MAPPING,                           \
  98                 .name = "Master Playback Switch",               \
  99                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
 100                              (SUBDEV_SPEAKER(0) << 16), \
 101         }
 102
 103 static const struct snd_kcontrol_new alc262_hippo_mixer[] = {
 104         ALC262_HIPPO_MASTER_SWITCH,
 105         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 108         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 109         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 110         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 111         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 112         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 113         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 114         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 115         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
 116         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 117         { } /* end */
 118 };
 119
 120 static const struct snd_kcontrol_new alc262_hippo1_mixer[] = {
 121         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 122         ALC262_HIPPO_MASTER_SWITCH,
 123         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 124         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 125         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 126         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 127         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 128         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 129         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 130         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 131         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 132         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
 133         { } /* end */
 134 };
 135
 136 /* mute/unmute internal speaker according to the hp jack and mute state */
 137 static void alc262_hippo_setup(struct hda_codec *codec)
 138 {
 139         struct alc_spec *spec = codec->spec;
 140
 141         spec->autocfg.hp_pins[0] = 0x15;
 142         spec->autocfg.speaker_pins[0] = 0x14;
 143         spec->automute = 1;
 144         spec->automute_mode = ALC_AUTOMUTE_AMP;
 145 }
 146
 147 static void alc262_hippo1_setup(struct hda_codec *codec)
 148 {
 149         struct alc_spec *spec = codec->spec;
 150
 151         spec->autocfg.hp_pins[0] = 0x1b;
 152         spec->autocfg.speaker_pins[0] = 0x14;
 153         spec->automute = 1;
 154         spec->automute_mode = ALC_AUTOMUTE_AMP;
 155 }
 156
 157
 158 static const struct snd_kcontrol_new alc262_sony_mixer[] = {
 159         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 160         ALC262_HIPPO_MASTER_SWITCH,
 161         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 162         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 163         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 164         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 165         { } /* end */
 166 };
 167
 168 static const struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
 169         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 170         ALC262_HIPPO_MASTER_SWITCH,
 171         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 172         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 173         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 174         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 175         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 176         { } /* end */
 177 };
 178
 179 static const struct snd_kcontrol_new alc262_tyan_mixer[] = {
 180         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 181         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
 182         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
 183         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
 184         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 185         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 186         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 187         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 188         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 189         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 190         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 191         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
 192         { } /* end */
 193 };
 194
 195 static const struct hda_verb alc262_tyan_verbs[] = {
 196         /* Headphone automute */
 197         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 198         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 199         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 200
 201         /* P11 AUX_IN, white 4-pin connector */
 202         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 203         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
 204         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
 205         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
 206
 207         {}
 208 };
 209
 210 /* unsolicited event for HP jack sensing */
 211 static void alc262_tyan_setup(struct hda_codec *codec)
 212 {
 213         struct alc_spec *spec = codec->spec;
 214
 215         spec->autocfg.hp_pins[0] = 0x1b;
 216         spec->autocfg.speaker_pins[0] = 0x15;
 217         spec->automute = 1;
 218         spec->automute_mode = ALC_AUTOMUTE_AMP;
 219 }
 220
 221
 222 #define alc262_capture_mixer            alc882_capture_mixer
 223 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
 224
 225 /*
 226  * generic initialization of ADC, input mixers and output mixers
 227  */
 228 static const struct hda_verb alc262_init_verbs[] = {
 229         /*
 230          * Unmute ADC0-2 and set the default input to mic-in
 231          */
 232         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 234         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 235         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 236         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 237         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 238
 239         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 240          * mixer widget
 241          * Note: PASD motherboards uses the Line In 2 as the input for
 242          * front panel mic (mic 2)
 243          */
 244         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
 245         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 246         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 247         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 248         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 249         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 250
 251         /*
 252          * Set up output mixers (0x0c - 0x0e)
 253          */
 254         /* set vol=0 to output mixers */
 255         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 256         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 257         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 258         /* set up input amps for analog loopback */
 259         /* Amp Indices: DAC = 0, mixer = 1 */
 260         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 261         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 262         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 263         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 264         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 265         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 266
 267         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 268         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 269         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 270         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 271         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 272         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 273
 274         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 275         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 276         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 277         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 278         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 279
 280         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
 281         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
 282
 283         /* FIXME: use matrix-type input source selection */
 284         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
 285         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
 286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 287         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 288         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 289         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 290         /* Input mixer2 */
 291         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 292         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 293         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 295         /* Input mixer3 */
 296         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 298         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 299         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 300
 301         { }
 302 };
 303
 304 static const struct hda_verb alc262_eapd_verbs[] = {
 305         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
 306         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
 307         { }
 308 };
 309
 310 static const struct hda_verb alc262_hippo1_unsol_verbs[] = {
 311         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 312         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
 313         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 314
 315         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 316         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 317         {}
 318 };
 319
 320 static const struct hda_verb alc262_sony_unsol_verbs[] = {
 321         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 322         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 323         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
 324
 325         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 326         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 327         {}
 328 };
 329
 330 static const struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
 331         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 332         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 333         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 336         { } /* end */
 337 };
 338
 339 static const struct hda_verb alc262_toshiba_s06_verbs[] = {
 340         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 341         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 343         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 344         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
 345         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 346         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
 347         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 348         {}
 349 };
 350
 351 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
 352 {
 353         struct alc_spec *spec = codec->spec;
 354
 355         spec->autocfg.hp_pins[0] = 0x15;
 356         spec->autocfg.speaker_pins[0] = 0x14;
 357         spec->ext_mic_pin = 0x18;
 358         spec->int_mic_pin = 0x12;
 359         spec->auto_mic = 1;
 360         spec->automute = 1;
 361         spec->automute_mode = ALC_AUTOMUTE_PIN;
 362 }
 363
 364 /*
 365  * nec model
 366  *  0x15 = headphone
 367  *  0x16 = internal speaker
 368  *  0x18 = external mic
 369  */
 370
 371 static const struct snd_kcontrol_new alc262_nec_mixer[] = {
 372         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 373         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
 374
 375         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 376         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 377         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 378
 379         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 380         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 381         { } /* end */
 382 };
 383
 384 static const struct hda_verb alc262_nec_verbs[] = {
 385         /* Unmute Speaker */
 386         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 387
 388         /* Headphone */
 389         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 390         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 391
 392         /* External mic to headphone */
 393         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 394         /* External mic to speaker */
 395         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 396         {}
 397 };
 398
 399 /*
 400  * fujitsu model
 401  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
 402  *  0x1b = port replicator headphone out
 403  */
 404
 405 static const struct hda_verb alc262_fujitsu_unsol_verbs[] = {
 406         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 407         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 408         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 409         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 410         {}
 411 };
 412
 413 static const struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
 414         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 415         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 416         {}
 417 };
 418
 419 static const struct hda_verb alc262_lenovo_3000_init_verbs[] = {
 420         /* Front Mic pin: input vref at 50% */
 421         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
 422         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 423         {}
 424 };
 425
 426 static const struct hda_input_mux alc262_fujitsu_capture_source = {
 427         .num_items = 3,
 428         .items = {
 429                 { "Mic", 0x0 },
 430                 { "Internal Mic", 0x1 },
 431                 { "CD", 0x4 },
 432         },
 433 };
 434
 435 static void alc262_fujitsu_setup(struct hda_codec *codec)
 436 {
 437         struct alc_spec *spec = codec->spec;
 438
 439         spec->autocfg.hp_pins[0] = 0x14;
 440         spec->autocfg.hp_pins[1] = 0x1b;
 441         spec->autocfg.speaker_pins[0] = 0x15;
 442         spec->automute = 1;
 443         spec->automute_mode = ALC_AUTOMUTE_AMP;
 444 }
 445
 446 /* bind volumes of both NID 0x0c and 0x0d */
 447 static const struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
 448         .ops = &snd_hda_bind_vol,
 449         .values = {
 450                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
 451                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
 452                 0
 453         },
 454 };
 455
 456 static const struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
 457         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
 458         {
 459                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 460                 .name = "Master Playback Switch",
 461                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
 462                 .info = snd_ctl_boolean_mono_info,
 463                 .get = alc262_hp_master_sw_get,
 464                 .put = alc262_hp_master_sw_put,
 465         },
 466         {
 467                 .iface = NID_MAPPING,
 468                 .name = "Master Playback Switch",
 469                 .private_value = 0x1b,
 470         },
 471         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 472         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 473         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 474         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 475         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 476         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
 477         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 478         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 479         { } /* end */
 480 };
 481
 482 static void alc262_lenovo_3000_setup(struct hda_codec *codec)
 483 {
 484         struct alc_spec *spec = codec->spec;
 485
 486         spec->autocfg.hp_pins[0] = 0x1b;
 487         spec->autocfg.speaker_pins[0] = 0x14;
 488         spec->autocfg.speaker_pins[1] = 0x16;
 489         spec->automute = 1;
 490         spec->automute_mode = ALC_AUTOMUTE_AMP;
 491 }
 492
 493 static const struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
 494         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
 495         {
 496                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 497                 .name = "Master Playback Switch",
 498                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
 499                 .info = snd_ctl_boolean_mono_info,
 500                 .get = alc262_hp_master_sw_get,
 501                 .put = alc262_hp_master_sw_put,
 502         },
 503         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 504         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 505         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 506         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 507         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 508         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
 509         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 510         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 511         { } /* end */
 512 };
 513
 514 static const struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
 515         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
 516         ALC262_HIPPO_MASTER_SWITCH,
 517         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 518         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 519         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 520         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 521         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 522         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
 523         { } /* end */
 524 };
 525
 526 /* additional init verbs for Benq laptops */
 527 static const struct hda_verb alc262_EAPD_verbs[] = {
 528         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 529         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
 530         {}
 531 };
 532
 533 static const struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
 534         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 535         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 536
 537         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 538         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
 539         {}
 540 };
 541
 542 /* Samsung Q1 Ultra Vista model setup */
 543 static const struct snd_kcontrol_new alc262_ultra_mixer[] = {
 544         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 545         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
 546         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 547         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 548         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
 549         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
 550         { } /* end */
 551 };
 552
 553 static const struct hda_verb alc262_ultra_verbs[] = {
 554         /* output mixer */
 555         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 556         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 557         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 558         /* speaker */
 559         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 560         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 561         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 562         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
 563         /* HP */
 564         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 565         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 566         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 567         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 568         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 569         /* internal mic */
 570         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 572         /* ADC, choose mic */
 573         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 574         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 575         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 576         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 577         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 578         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 579         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
 580         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
 581         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
 582         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
 583         {}
 584 };
 585
 586 /* mute/unmute internal speaker according to the hp jack and mute state */
 587 static void alc262_ultra_automute(struct hda_codec *codec)
 588 {
 589         struct alc_spec *spec = codec->spec;
 590         unsigned int mute;
 591
 592         mute = 0;
 593         /* auto-mute only when HP is used as HP */
 594         if (!spec->cur_mux[0]) {
 595                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
 596                 if (spec->jack_present)
 597                         mute = HDA_AMP_MUTE;
 598         }
 599         /* mute/unmute internal speaker */
 600         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
 601                                  HDA_AMP_MUTE, mute);
 602         /* mute/unmute HP */
 603         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
 604                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
 605 }
 606
 607 /* unsolicited event for HP jack sensing */
 608 static void alc262_ultra_unsol_event(struct hda_codec *codec,
 609                                        unsigned int res)
 610 {
 611         if ((res >> 26) != ALC_HP_EVENT)
 612                 return;
 613         alc262_ultra_automute(codec);
 614 }
 615
 616 static const struct hda_input_mux alc262_ultra_capture_source = {
 617         .num_items = 2,
 618         .items = {
 619                 { "Mic", 0x1 },
 620                 { "Headphone", 0x7 },
 621         },
 622 };
 623
 624 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
 625                                      struct snd_ctl_elem_value *ucontrol)
 626 {
 627         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 628         struct alc_spec *spec = codec->spec;
 629         int ret;
 630
 631         ret = alc_mux_enum_put(kcontrol, ucontrol);
 632         if (!ret)
 633                 return 0;
 634         /* reprogram the HP pin as mic or HP according to the input source */
 635         snd_hda_codec_write_cache(codec, 0x15, 0,
 636                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
 637                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
 638         alc262_ultra_automute(codec); /* mute/unmute HP */
 639         return ret;
 640 }
 641
 642 static const struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
 643         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
 644         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
 645         {
 646                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 647                 .name = "Capture Source",
 648                 .info = alc_mux_enum_info,
 649                 .get = alc_mux_enum_get,
 650                 .put = alc262_ultra_mux_enum_put,
 651         },
 652         {
 653                 .iface = NID_MAPPING,
 654                 .name = "Capture Source",
 655                 .private_value = 0x15,
 656         },
 657         { } /* end */
 658 };
 659
 660 static const struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
 661
 662         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
 663         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 664         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
 665
 666         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
 667         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
 668         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
 669         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
 670
 671         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
 672         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 673         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 674         {}
 675 };
 676
 677 /*
 678  * configuration and preset
 679  */
 680 static const char * const alc262_models[ALC262_MODEL_LAST] = {
 681         [ALC262_BASIC]          = "basic",
 682         [ALC262_HIPPO]          = "hippo",
 683         [ALC262_HIPPO_1]        = "hippo_1",
 684         [ALC262_FUJITSU]        = "fujitsu",
 685         [ALC262_BENQ_ED8]       = "benq",
 686         [ALC262_BENQ_T31]       = "benq-t31",
 687         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
 688         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
 689         [ALC262_ULTRA]          = "ultra",
 690         [ALC262_LENOVO_3000]    = "lenovo-3000",
 691         [ALC262_NEC]            = "nec",
 692         [ALC262_TYAN]           = "tyan",
 693         [ALC262_AUTO]           = "auto",
 694 };
 695
 696 static const struct snd_pci_quirk alc262_cfg_tbl[] = {
 697         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
 698         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
 699         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
 700                       ALC262_TOSHIBA_RX1),
 701         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
 702         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
 703         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
 704         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
 705         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
 706                            ALC262_ULTRA),
 707         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
 708         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
 709         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
 710         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
 711         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
 712         {}
 713 };
 714
 715 static const struct alc_config_preset alc262_presets[] = {
 716         [ALC262_BASIC] = {
 717                 .mixers = { alc262_base_mixer },
 718                 .init_verbs = { alc262_init_verbs },
 719                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 720                 .dac_nids = alc262_dac_nids,
 721                 .hp_nid = 0x03,
 722                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 723                 .channel_mode = alc262_modes,
 724                 .input_mux = &alc262_capture_source,
 725         },
 726         [ALC262_HIPPO] = {
 727                 .mixers = { alc262_hippo_mixer },
 728                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
 729                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 730                 .dac_nids = alc262_dac_nids,
 731                 .hp_nid = 0x03,
 732                 .dig_out_nid = ALC262_DIGOUT_NID,
 733                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 734                 .channel_mode = alc262_modes,
 735                 .input_mux = &alc262_capture_source,
 736                 .unsol_event = alc_sku_unsol_event,
 737                 .setup = alc262_hippo_setup,
 738                 .init_hook = alc_inithook,
 739         },
 740         [ALC262_HIPPO_1] = {
 741                 .mixers = { alc262_hippo1_mixer },
 742                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
 743                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 744                 .dac_nids = alc262_dac_nids,
 745                 .hp_nid = 0x02,
 746                 .dig_out_nid = ALC262_DIGOUT_NID,
 747                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 748                 .channel_mode = alc262_modes,
 749                 .input_mux = &alc262_capture_source,
 750                 .unsol_event = alc_sku_unsol_event,
 751                 .setup = alc262_hippo1_setup,
 752                 .init_hook = alc_inithook,
 753         },
 754         [ALC262_FUJITSU] = {
 755                 .mixers = { alc262_fujitsu_mixer },
 756                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
 757                                 alc262_fujitsu_unsol_verbs },
 758                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 759                 .dac_nids = alc262_dac_nids,
 760                 .hp_nid = 0x03,
 761                 .dig_out_nid = ALC262_DIGOUT_NID,
 762                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 763                 .channel_mode = alc262_modes,
 764                 .input_mux = &alc262_fujitsu_capture_source,
 765                 .unsol_event = alc_sku_unsol_event,
 766                 .setup = alc262_fujitsu_setup,
 767                 .init_hook = alc_inithook,
 768         },
 769         [ALC262_BENQ_ED8] = {
 770                 .mixers = { alc262_base_mixer },
 771                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
 772                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 773                 .dac_nids = alc262_dac_nids,
 774                 .hp_nid = 0x03,
 775                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 776                 .channel_mode = alc262_modes,
 777                 .input_mux = &alc262_capture_source,
 778         },
 779         [ALC262_BENQ_T31] = {
 780                 .mixers = { alc262_benq_t31_mixer },
 781                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
 782                                 alc_hp15_unsol_verbs },
 783                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 784                 .dac_nids = alc262_dac_nids,
 785                 .hp_nid = 0x03,
 786                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 787                 .channel_mode = alc262_modes,
 788                 .input_mux = &alc262_capture_source,
 789                 .unsol_event = alc_sku_unsol_event,
 790                 .setup = alc262_hippo_setup,
 791                 .init_hook = alc_inithook,
 792         },
 793         [ALC262_ULTRA] = {
 794                 .mixers = { alc262_ultra_mixer },
 795                 .cap_mixer = alc262_ultra_capture_mixer,
 796                 .init_verbs = { alc262_ultra_verbs },
 797                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 798                 .dac_nids = alc262_dac_nids,
 799                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 800                 .channel_mode = alc262_modes,
 801                 .input_mux = &alc262_ultra_capture_source,
 802                 .adc_nids = alc262_adc_nids, /* ADC0 */
 803                 .capsrc_nids = alc262_capsrc_nids,
 804                 .num_adc_nids = 1, /* single ADC */
 805                 .unsol_event = alc262_ultra_unsol_event,
 806                 .init_hook = alc262_ultra_automute,
 807         },
 808         [ALC262_LENOVO_3000] = {
 809                 .mixers = { alc262_lenovo_3000_mixer },
 810                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
 811                                 alc262_lenovo_3000_unsol_verbs,
 812                                 alc262_lenovo_3000_init_verbs },
 813                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 814                 .dac_nids = alc262_dac_nids,
 815                 .hp_nid = 0x03,
 816                 .dig_out_nid = ALC262_DIGOUT_NID,
 817                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 818                 .channel_mode = alc262_modes,
 819                 .input_mux = &alc262_fujitsu_capture_source,
 820                 .unsol_event = alc_sku_unsol_event,
 821                 .setup = alc262_lenovo_3000_setup,
 822                 .init_hook = alc_inithook,
 823         },
 824         [ALC262_NEC] = {
 825                 .mixers = { alc262_nec_mixer },
 826                 .init_verbs = { alc262_nec_verbs },
 827                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 828                 .dac_nids = alc262_dac_nids,
 829                 .hp_nid = 0x03,
 830                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 831                 .channel_mode = alc262_modes,
 832                 .input_mux = &alc262_capture_source,
 833         },
 834         [ALC262_TOSHIBA_S06] = {
 835                 .mixers = { alc262_toshiba_s06_mixer },
 836                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
 837                                                         alc262_eapd_verbs },
 838                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 839                 .capsrc_nids = alc262_dmic_capsrc_nids,
 840                 .dac_nids = alc262_dac_nids,
 841                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
 842                 .num_adc_nids = 1, /* single ADC */
 843                 .dig_out_nid = ALC262_DIGOUT_NID,
 844                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 845                 .channel_mode = alc262_modes,
 846                 .unsol_event = alc_sku_unsol_event,
 847                 .setup = alc262_toshiba_s06_setup,
 848                 .init_hook = alc_inithook,
 849         },
 850         [ALC262_TOSHIBA_RX1] = {
 851                 .mixers = { alc262_toshiba_rx1_mixer },
 852                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
 853                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 854                 .dac_nids = alc262_dac_nids,
 855                 .hp_nid = 0x03,
 856                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 857                 .channel_mode = alc262_modes,
 858                 .input_mux = &alc262_capture_source,
 859                 .unsol_event = alc_sku_unsol_event,
 860                 .setup = alc262_hippo_setup,
 861                 .init_hook = alc_inithook,
 862         },
 863         [ALC262_TYAN] = {
 864                 .mixers = { alc262_tyan_mixer },
 865                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
 866                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
 867                 .dac_nids = alc262_dac_nids,
 868                 .hp_nid = 0x02,
 869                 .dig_out_nid = ALC262_DIGOUT_NID,
 870                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
 871                 .channel_mode = alc262_modes,
 872                 .input_mux = &alc262_capture_source,
 873                 .unsol_event = alc_sku_unsol_event,
 874                 .setup = alc262_tyan_setup,
 875                 .init_hook = alc_hp_automute,
 876         },
 877 };
 878