sound/pci/hda/alc268_quirks.c

   1 /*
   2  * ALC267/ALC268 quirk models
   3  * included by patch_realtek.c
   4  */
   5
   6 /* ALC268 models */
   7 enum {
   8         ALC268_AUTO,
   9         ALC267_QUANTA_IL1,
  10         ALC268_3ST,
  11         ALC268_ACER,
  12         ALC268_ACER_DMIC,
  13         ALC268_ACER_ASPIRE_ONE,
  14 #ifdef CONFIG_SND_DEBUG
  15         ALC268_TEST,
  16 #endif
  17         ALC268_MODEL_LAST /* last tag */
  18 };
  19
  20 /*
  21  *  ALC268 channel source setting (2 channel)
  22  */
  23 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
  24 #define alc268_modes            alc260_modes
  25
  26 static const hda_nid_t alc268_dac_nids[2] = {
  27         /* front, hp */
  28         0x02, 0x03
  29 };
  30
  31 static const hda_nid_t alc268_adc_nids[2] = {
  32         /* ADC0-1 */
  33         0x08, 0x07
  34 };
  35
  36 static const hda_nid_t alc268_adc_nids_alt[1] = {
  37         /* ADC0 */
  38         0x08
  39 };
  40
  41 static const hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
  42
  43 static const struct snd_kcontrol_new alc268_base_mixer[] = {
  44         /* output mixer control */
  45         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
  46         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
  47         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
  48         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  49         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
  50         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
  51         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
  52         { }
  53 };
  54
  55 static const struct hda_verb alc268_eapd_verbs[] = {
  56         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
  57         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
  58         { }
  59 };
  60
  61 /* Acer specific */
  62 /* bind volumes of both NID 0x02 and 0x03 */
  63 static const struct hda_bind_ctls alc268_acer_bind_master_vol = {
  64         .ops = &snd_hda_bind_vol,
  65         .values = {
  66                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
  67                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
  68                 0
  69         },
  70 };
  71
  72 static void alc268_acer_setup(struct hda_codec *codec)
  73 {
  74         struct alc_spec *spec = codec->spec;
  75
  76         spec->autocfg.hp_pins[0] = 0x14;
  77         spec->autocfg.speaker_pins[0] = 0x15;
  78         spec->automute = 1;
  79         spec->automute_mode = ALC_AUTOMUTE_AMP;
  80 }
  81
  82 #define alc268_acer_master_sw_get       alc262_hp_master_sw_get
  83 #define alc268_acer_master_sw_put       alc262_hp_master_sw_put
  84
  85 static const struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
  86         /* output mixer control */
  87         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
  88         {
  89                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  90                 .name = "Master Playback Switch",
  91                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x15,
  92                 .info = snd_ctl_boolean_mono_info,
  93                 .get = alc268_acer_master_sw_get,
  94                 .put = alc268_acer_master_sw_put,
  95         },
  96         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
  97         { }
  98 };
  99
 100 static const struct snd_kcontrol_new alc268_acer_mixer[] = {
 101         /* output mixer control */
 102         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
 103         {
 104                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 105                 .name = "Master Playback Switch",
 106                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
 107                 .info = snd_ctl_boolean_mono_info,
 108                 .get = alc268_acer_master_sw_get,
 109                 .put = alc268_acer_master_sw_put,
 110         },
 111         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 112         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
 113         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
 114         { }
 115 };
 116
 117 static const struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
 118         /* output mixer control */
 119         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
 120         {
 121                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 122                 .name = "Master Playback Switch",
 123                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
 124                 .info = snd_ctl_boolean_mono_info,
 125                 .get = alc268_acer_master_sw_get,
 126                 .put = alc268_acer_master_sw_put,
 127         },
 128         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 129         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
 130         { }
 131 };
 132
 133 static const struct hda_verb alc268_acer_aspire_one_verbs[] = {
 134         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 135         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 136         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
 137         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
 138         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
 139         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
 140         { }
 141 };
 142
 143 static const struct hda_verb alc268_acer_verbs[] = {
 144         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
 145         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 146         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 147         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 148         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 149         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 150         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
 151         { }
 152 };
 153
 154 static void alc268_acer_lc_setup(struct hda_codec *codec)
 155 {
 156         struct alc_spec *spec = codec->spec;
 157         spec->autocfg.hp_pins[0] = 0x15;
 158         spec->autocfg.speaker_pins[0] = 0x14;
 159         spec->automute = 1;
 160         spec->automute_mode = ALC_AUTOMUTE_AMP;
 161         spec->ext_mic_pin = 0x18;
 162         spec->int_mic_pin = 0x12;
 163         spec->auto_mic = 1;
 164 }
 165
 166 static const struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
 167         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
 168         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 169         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
 170         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 171         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
 172         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
 173         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
 174         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
 175         { }
 176 };
 177
 178 static const struct hda_verb alc267_quanta_il1_verbs[] = {
 179         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
 180         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT | AC_USRSP_EN},
 181         { }
 182 };
 183
 184 static void alc267_quanta_il1_setup(struct hda_codec *codec)
 185 {
 186         struct alc_spec *spec = codec->spec;
 187         spec->autocfg.hp_pins[0] = 0x15;
 188         spec->autocfg.speaker_pins[0] = 0x14;
 189         spec->ext_mic_pin = 0x18;
 190         spec->int_mic_pin = 0x19;
 191         spec->auto_mic = 1;
 192         spec->automute = 1;
 193         spec->automute_mode = ALC_AUTOMUTE_PIN;
 194 }
 195
 196 /*
 197  * generic initialization of ADC, input mixers and output mixers
 198  */
 199 static const struct hda_verb alc268_base_init_verbs[] = {
 200         /* Unmute DAC0-1 and set vol = 0 */
 201         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 202         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 203
 204         /*
 205          * Set up output mixers (0x0c - 0x0e)
 206          */
 207         /* set vol=0 to output mixers */
 208         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 209         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
 210
 211         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 212         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 213
 214         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 215         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 216         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 217         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 218         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 219         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 220         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 221         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 222
 223         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 224         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 225         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 226         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 227         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 228
 229         /* set PCBEEP vol = 0, mute connections */
 230         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 231         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 232         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 233
 234         /* Unmute Selector 23h,24h and set the default input to mic-in */
 235
 236         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
 237         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 238         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
 239         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 240
 241         { }
 242 };
 243
 244 /* only for model=test */
 245 #ifdef CONFIG_SND_DEBUG
 246 /*
 247  * generic initialization of ADC, input mixers and output mixers
 248  */
 249 static const struct hda_verb alc268_volume_init_verbs[] = {
 250         /* set output DAC */
 251         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 252         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 253
 254         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 255         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 256         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 257         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 258         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 259
 260         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 261         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 262         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 263
 264         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 265         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 266         { }
 267 };
 268 #endif /* CONFIG_SND_DEBUG */
 269
 270 static const struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
 271         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
 272         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
 273         { } /* end */
 274 };
 275
 276 static const struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
 277         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
 278         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
 279         _DEFINE_CAPSRC(1),
 280         { } /* end */
 281 };
 282
 283 static const struct snd_kcontrol_new alc268_capture_mixer[] = {
 284         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
 285         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
 286         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
 287         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
 288         _DEFINE_CAPSRC(2),
 289         { } /* end */
 290 };
 291
 292 static const struct hda_input_mux alc268_capture_source = {
 293         .num_items = 4,
 294         .items = {
 295                 { "Mic", 0x0 },
 296                 { "Front Mic", 0x1 },
 297                 { "Line", 0x2 },
 298                 { "CD", 0x3 },
 299         },
 300 };
 301
 302 static const struct hda_input_mux alc268_acer_capture_source = {
 303         .num_items = 3,
 304         .items = {
 305                 { "Mic", 0x0 },
 306                 { "Internal Mic", 0x1 },
 307                 { "Line", 0x2 },
 308         },
 309 };
 310
 311 static const struct hda_input_mux alc268_acer_dmic_capture_source = {
 312         .num_items = 3,
 313         .items = {
 314                 { "Mic", 0x0 },
 315                 { "Internal Mic", 0x6 },
 316                 { "Line", 0x2 },
 317         },
 318 };
 319
 320 #ifdef CONFIG_SND_DEBUG
 321 static const struct snd_kcontrol_new alc268_test_mixer[] = {
 322         /* Volume widgets */
 323         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
 324         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 325         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 326         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
 327         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
 328         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
 329         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
 330         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
 331         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
 332         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
 333         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
 334         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
 335         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
 336         /* The below appears problematic on some hardwares */
 337         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
 338         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
 339         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
 340         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
 341         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
 342
 343         /* Modes for retasking pin widgets */
 344         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
 345         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
 346         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
 347         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
 348
 349         /* Controls for GPIO pins, assuming they are configured as outputs */
 350         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
 351         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
 352         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
 353         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
 354
 355         /* Switches to allow the digital SPDIF output pin to be enabled.
 356          * The ALC268 does not have an SPDIF input.
 357          */
 358         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
 359
 360         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
 361          * this output to turn on an external amplifier.
 362          */
 363         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
 364         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
 365
 366         { } /* end */
 367 };
 368 #endif
 369
 370 /*
 371  * configuration and preset
 372  */
 373 static const char * const alc268_models[ALC268_MODEL_LAST] = {
 374         [ALC267_QUANTA_IL1]     = "quanta-il1",
 375         [ALC268_3ST]            = "3stack",
 376         [ALC268_ACER]           = "acer",
 377         [ALC268_ACER_DMIC]      = "acer-dmic",
 378         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
 379 #ifdef CONFIG_SND_DEBUG
 380         [ALC268_TEST]           = "test",
 381 #endif
 382         [ALC268_AUTO]           = "auto",
 383 };
 384
 385 static const struct snd_pci_quirk alc268_cfg_tbl[] = {
 386         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
 387         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
 388         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
 389         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
 390         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
 391         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
 392                                                 ALC268_ACER_ASPIRE_ONE),
 393         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
 394         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
 395         {}
 396 };
 397
 398 static const struct alc_config_preset alc268_presets[] = {
 399         [ALC267_QUANTA_IL1] = {
 400                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
 401                             alc268_capture_nosrc_mixer },
 402                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
 403                                 alc267_quanta_il1_verbs },
 404                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 405                 .dac_nids = alc268_dac_nids,
 406                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 407                 .adc_nids = alc268_adc_nids_alt,
 408                 .hp_nid = 0x03,
 409                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 410                 .channel_mode = alc268_modes,
 411                 .unsol_event = alc_sku_unsol_event,
 412                 .setup = alc267_quanta_il1_setup,
 413                 .init_hook = alc_inithook,
 414         },
 415         [ALC268_3ST] = {
 416                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
 417                             alc268_beep_mixer },
 418                 .init_verbs = { alc268_base_init_verbs },
 419                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 420                 .dac_nids = alc268_dac_nids,
 421                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 422                 .adc_nids = alc268_adc_nids_alt,
 423                 .capsrc_nids = alc268_capsrc_nids,
 424                 .hp_nid = 0x03,
 425                 .dig_out_nid = ALC268_DIGOUT_NID,
 426                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 427                 .channel_mode = alc268_modes,
 428                 .input_mux = &alc268_capture_source,
 429         },
 430         [ALC268_ACER] = {
 431                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
 432                             alc268_beep_mixer },
 433                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
 434                                 alc268_acer_verbs },
 435                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 436                 .dac_nids = alc268_dac_nids,
 437                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 438                 .adc_nids = alc268_adc_nids_alt,
 439                 .capsrc_nids = alc268_capsrc_nids,
 440                 .hp_nid = 0x02,
 441                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 442                 .channel_mode = alc268_modes,
 443                 .input_mux = &alc268_acer_capture_source,
 444                 .unsol_event = alc_sku_unsol_event,
 445                 .setup = alc268_acer_setup,
 446                 .init_hook = alc_inithook,
 447         },
 448         [ALC268_ACER_DMIC] = {
 449                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
 450                             alc268_beep_mixer },
 451                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
 452                                 alc268_acer_verbs },
 453                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 454                 .dac_nids = alc268_dac_nids,
 455                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 456                 .adc_nids = alc268_adc_nids_alt,
 457                 .capsrc_nids = alc268_capsrc_nids,
 458                 .hp_nid = 0x02,
 459                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 460                 .channel_mode = alc268_modes,
 461                 .input_mux = &alc268_acer_dmic_capture_source,
 462                 .unsol_event = alc_sku_unsol_event,
 463                 .setup = alc268_acer_setup,
 464                 .init_hook = alc_inithook,
 465         },
 466         [ALC268_ACER_ASPIRE_ONE] = {
 467                 .mixers = { alc268_acer_aspire_one_mixer,
 468                             alc268_beep_mixer,
 469                             alc268_capture_nosrc_mixer },
 470                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
 471                                 alc268_acer_aspire_one_verbs },
 472                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 473                 .dac_nids = alc268_dac_nids,
 474                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 475                 .adc_nids = alc268_adc_nids_alt,
 476                 .capsrc_nids = alc268_capsrc_nids,
 477                 .hp_nid = 0x03,
 478                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 479                 .channel_mode = alc268_modes,
 480                 .unsol_event = alc_sku_unsol_event,
 481                 .setup = alc268_acer_lc_setup,
 482                 .init_hook = alc_inithook,
 483         },
 484 #ifdef CONFIG_SND_DEBUG
 485         [ALC268_TEST] = {
 486                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
 487                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
 488                                 alc268_volume_init_verbs,
 489                                 alc268_beep_init_verbs },
 490                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
 491                 .dac_nids = alc268_dac_nids,
 492                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
 493                 .adc_nids = alc268_adc_nids_alt,
 494                 .capsrc_nids = alc268_capsrc_nids,
 495                 .hp_nid = 0x03,
 496                 .dig_out_nid = ALC268_DIGOUT_NID,
 497                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
 498                 .channel_mode = alc268_modes,
 499                 .input_mux = &alc268_capture_source,
 500         },
 501 #endif
 502 };
 503