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