sound/pci/hda/patch_sigmatel.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for SigmaTel STAC92xx
   5  *
   6  * Copyright (c) 2005 Embedded Alley Solutions, Inc.
   7  * Matt Porter <mporter@embeddedalley.com>
   8  *
   9  * Based on patch_cmedia.c and patch_realtek.c
  10  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  11  *
  12  *  This driver is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This driver is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25  */
  26
  27 #include <sound/driver.h>
  28 #include <linux/init.h>
  29 #include <linux/delay.h>
  30 #include <linux/slab.h>
  31 #include <linux/pci.h>
  32 #include <sound/core.h>
  33 #include <sound/asoundef.h>
  34 #include "hda_codec.h"
  35 #include "hda_local.h"
  36
  37 #define NUM_CONTROL_ALLOC       32
  38 #define STAC_HP_EVENT           0x37
  39
  40 enum {
  41         STAC_REF,
  42         STAC_9200_DELL_D21,
  43         STAC_9200_DELL_D22,
  44         STAC_9200_DELL_D23,
  45         STAC_9200_DELL_M21,
  46         STAC_9200_DELL_M22,
  47         STAC_9200_DELL_M23,
  48         STAC_9200_DELL_M24,
  49         STAC_9200_DELL_M25,
  50         STAC_9200_DELL_M26,
  51         STAC_9200_DELL_M27,
  52         STAC_9200_GATEWAY,
  53         STAC_9200_MODELS
  54 };
  55
  56 enum {
  57         STAC_9205_REF,
  58         STAC_9205_DELL_M42,
  59         STAC_9205_DELL_M43,
  60         STAC_9205_DELL_M44,
  61         STAC_9205_MODELS
  62 };
  63
  64 enum {
  65         STAC_925x_REF,
  66         STAC_M2_2,
  67         STAC_MA6,
  68         STAC_PA6,
  69         STAC_925x_MODELS
  70 };
  71
  72 enum {
  73         STAC_D945_REF,
  74         STAC_D945GTP3,
  75         STAC_D945GTP5,
  76         STAC_INTEL_MAC_V1,
  77         STAC_INTEL_MAC_V2,
  78         STAC_INTEL_MAC_V3,
  79         STAC_INTEL_MAC_V4,
  80         STAC_INTEL_MAC_V5,
  81         /* for backward compatibility */
  82         STAC_MACMINI,
  83         STAC_MACBOOK,
  84         STAC_MACBOOK_PRO_V1,
  85         STAC_MACBOOK_PRO_V2,
  86         STAC_IMAC_INTEL,
  87         STAC_IMAC_INTEL_20,
  88         STAC_922X_DELL_D81,
  89         STAC_922X_DELL_D82,
  90         STAC_922X_DELL_M81,
  91         STAC_922X_DELL_M82,
  92         STAC_922X_MODELS
  93 };
  94
  95 enum {
  96         STAC_D965_REF,
  97         STAC_D965_3ST,
  98         STAC_D965_5ST,
  99         STAC_DELL_3ST,
 100         STAC_927X_MODELS
 101 };
 102
 103 struct sigmatel_spec {
 104         struct snd_kcontrol_new *mixers[4];
 105         unsigned int num_mixers;
 106
 107         int board_config;
 108         unsigned int surr_switch: 1;
 109         unsigned int line_switch: 1;
 110         unsigned int mic_switch: 1;
 111         unsigned int alt_switch: 1;
 112         unsigned int hp_detect: 1;
 113         unsigned int gpio_mute: 1;
 114         unsigned int no_vol_knob :1;
 115
 116         unsigned int gpio_mask, gpio_data;
 117
 118         /* playback */
 119         struct hda_multi_out multiout;
 120         hda_nid_t dac_nids[5];
 121
 122         /* capture */
 123         hda_nid_t *adc_nids;
 124         unsigned int num_adcs;
 125         hda_nid_t *mux_nids;
 126         unsigned int num_muxes;
 127         hda_nid_t *dmic_nids;
 128         unsigned int num_dmics;
 129         hda_nid_t dmux_nid;
 130         hda_nid_t dig_in_nid;
 131
 132         /* pin widgets */
 133         hda_nid_t *pin_nids;
 134         unsigned int num_pins;
 135         unsigned int *pin_configs;
 136         unsigned int *bios_pin_configs;
 137
 138         /* codec specific stuff */
 139         struct hda_verb *init;
 140         struct snd_kcontrol_new *mixer;
 141
 142         /* capture source */
 143         struct hda_input_mux *dinput_mux;
 144         unsigned int cur_dmux;
 145         struct hda_input_mux *input_mux;
 146         unsigned int cur_mux[3];
 147
 148         /* i/o switches */
 149         unsigned int io_switch[2];
 150         unsigned int clfe_swap;
 151         unsigned int aloopback;
 152
 153         struct hda_pcm pcm_rec[2];      /* PCM information */
 154
 155         /* dynamic controls and input_mux */
 156         struct auto_pin_cfg autocfg;
 157         unsigned int num_kctl_alloc, num_kctl_used;
 158         struct snd_kcontrol_new *kctl_alloc;
 159         struct hda_input_mux private_dimux;
 160         struct hda_input_mux private_imux;
 161 };
 162
 163 static hda_nid_t stac9200_adc_nids[1] = {
 164         0x03,
 165 };
 166
 167 static hda_nid_t stac9200_mux_nids[1] = {
 168         0x0c,
 169 };
 170
 171 static hda_nid_t stac9200_dac_nids[1] = {
 172         0x02,
 173 };
 174
 175 static hda_nid_t stac925x_adc_nids[1] = {
 176         0x03,
 177 };
 178
 179 static hda_nid_t stac925x_mux_nids[1] = {
 180         0x0f,
 181 };
 182
 183 static hda_nid_t stac925x_dac_nids[1] = {
 184         0x02,
 185 };
 186
 187 #define STAC925X_NUM_DMICS      1
 188 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
 189         0x15, 0
 190 };
 191
 192 static hda_nid_t stac922x_adc_nids[2] = {
 193         0x06, 0x07,
 194 };
 195
 196 static hda_nid_t stac922x_mux_nids[2] = {
 197         0x12, 0x13,
 198 };
 199
 200 static hda_nid_t stac927x_adc_nids[3] = {
 201         0x07, 0x08, 0x09
 202 };
 203
 204 static hda_nid_t stac927x_mux_nids[3] = {
 205         0x15, 0x16, 0x17
 206 };
 207
 208 static hda_nid_t stac9205_adc_nids[2] = {
 209         0x12, 0x13
 210 };
 211
 212 static hda_nid_t stac9205_mux_nids[2] = {
 213         0x19, 0x1a
 214 };
 215
 216 #define STAC9205_NUM_DMICS      2
 217 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
 218         0x17, 0x18, 0
 219 };
 220
 221 static hda_nid_t stac9200_pin_nids[8] = {
 222         0x08, 0x09, 0x0d, 0x0e,
 223         0x0f, 0x10, 0x11, 0x12,
 224 };
 225
 226 static hda_nid_t stac925x_pin_nids[8] = {
 227         0x07, 0x08, 0x0a, 0x0b,
 228         0x0c, 0x0d, 0x10, 0x11,
 229 };
 230
 231 static hda_nid_t stac922x_pin_nids[10] = {
 232         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 233         0x0f, 0x10, 0x11, 0x15, 0x1b,
 234 };
 235
 236 static hda_nid_t stac927x_pin_nids[14] = {
 237         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 238         0x0f, 0x10, 0x11, 0x12, 0x13,
 239         0x14, 0x21, 0x22, 0x23,
 240 };
 241
 242 static hda_nid_t stac9205_pin_nids[12] = {
 243         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 244         0x0f, 0x14, 0x16, 0x17, 0x18,
 245         0x21, 0x22,
 246 };
 247
 248 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
 249                                    struct snd_ctl_elem_info *uinfo)
 250 {
 251         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 252         struct sigmatel_spec *spec = codec->spec;
 253         return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
 254 }
 255
 256 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
 257                                   struct snd_ctl_elem_value *ucontrol)
 258 {
 259         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 260         struct sigmatel_spec *spec = codec->spec;
 261
 262         ucontrol->value.enumerated.item[0] = spec->cur_dmux;
 263         return 0;
 264 }
 265
 266 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
 267                                   struct snd_ctl_elem_value *ucontrol)
 268 {
 269         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 270         struct sigmatel_spec *spec = codec->spec;
 271
 272         return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
 273                                      spec->dmux_nid, &spec->cur_dmux);
 274 }
 275
 276 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 277 {
 278         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 279         struct sigmatel_spec *spec = codec->spec;
 280         return snd_hda_input_mux_info(spec->input_mux, uinfo);
 281 }
 282
 283 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 284 {
 285         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 286         struct sigmatel_spec *spec = codec->spec;
 287         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 288
 289         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 290         return 0;
 291 }
 292
 293 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 294 {
 295         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 296         struct sigmatel_spec *spec = codec->spec;
 297         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 298
 299         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 300                                      spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
 301 }
 302
 303 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
 304
 305 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
 306         struct snd_ctl_elem_value *ucontrol)
 307 {
 308         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 309         struct sigmatel_spec *spec = codec->spec;
 310
 311         ucontrol->value.integer.value[0] = spec->aloopback;
 312         return 0;
 313 }
 314
 315 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
 316                 struct snd_ctl_elem_value *ucontrol)
 317 {
 318         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 319         struct sigmatel_spec *spec = codec->spec;
 320         unsigned int dac_mode;
 321
 322         if (spec->aloopback == ucontrol->value.integer.value[0])
 323                 return 0;
 324
 325         spec->aloopback = ucontrol->value.integer.value[0];
 326
 327
 328         dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
 329                 kcontrol->private_value & 0xFFFF, 0x0);
 330
 331         if (spec->aloopback) {
 332                 snd_hda_power_up(codec);
 333                 dac_mode |= 0x40;
 334         } else {
 335                 snd_hda_power_down(codec);
 336                 dac_mode &= ~0x40;
 337         }
 338
 339         snd_hda_codec_write_cache(codec, codec->afg, 0,
 340                 kcontrol->private_value >> 16, dac_mode);
 341
 342         return 1;
 343 }
 344
 345 static int stac92xx_volknob_info(struct snd_kcontrol *kcontrol,
 346         struct snd_ctl_elem_info *uinfo)
 347 {
 348         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 349         uinfo->count = 1;
 350         uinfo->value.integer.min = 0;
 351         uinfo->value.integer.max = 127;
 352         return 0;
 353 }
 354
 355 static int stac92xx_volknob_get(struct snd_kcontrol *kcontrol,
 356         struct snd_ctl_elem_value *ucontrol)
 357 {
 358         ucontrol->value.integer.value[0] = kcontrol->private_value & 0xff;
 359         return 0;
 360 }
 361
 362 static int stac92xx_volknob_put(struct snd_kcontrol *kcontrol,
 363                 struct snd_ctl_elem_value *ucontrol)
 364 {
 365         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 366         unsigned int val = kcontrol->private_value & 0xff;
 367
 368         if (val == ucontrol->value.integer.value[0])
 369                 return 0;
 370
 371         val = ucontrol->value.integer.value[0];
 372         kcontrol->private_value &= ~0xff;
 373         kcontrol->private_value |= val;
 374
 375         snd_hda_codec_write_cache(codec, kcontrol->private_value >> 16, 0,
 376                 AC_VERB_SET_VOLUME_KNOB_CONTROL, val | 0x80);
 377         return 1;
 378 }
 379
 380
 381 static struct hda_verb stac9200_core_init[] = {
 382         /* set dac0mux for dac converter */
 383         { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 384         {}
 385 };
 386
 387 static struct hda_verb stac9200_eapd_init[] = {
 388         /* set dac0mux for dac converter */
 389         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 390         {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 391         {}
 392 };
 393
 394 static struct hda_verb stac925x_core_init[] = {
 395         /* set dac0mux for dac converter */
 396         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
 397         {}
 398 };
 399
 400 static struct hda_verb stac922x_core_init[] = {
 401         /* set master volume and direct control */
 402         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 403         {}
 404 };
 405
 406 static struct hda_verb d965_core_init[] = {
 407         /* set master volume and direct control */
 408         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 409         /* unmute node 0x1b */
 410         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 411         /* select node 0x03 as DAC */
 412         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 413         {}
 414 };
 415
 416 static struct hda_verb stac927x_core_init[] = {
 417         /* set master volume and direct control */
 418         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 419         {}
 420 };
 421
 422 static struct hda_verb stac9205_core_init[] = {
 423         /* set master volume and direct control */
 424         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 425         {}
 426 };
 427
 428 #define STAC_INPUT_SOURCE(cnt) \
 429         { \
 430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 431                 .name = "Input Source", \
 432                 .count = cnt, \
 433                 .info = stac92xx_mux_enum_info, \
 434                 .get = stac92xx_mux_enum_get, \
 435                 .put = stac92xx_mux_enum_put, \
 436         }
 437
 438 #define STAC_ANALOG_LOOPBACK(verb_read,verb_write) \
 439         { \
 440                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 441                 .name  = "Analog Loopback", \
 442                 .count = 1, \
 443                 .info  = stac92xx_aloopback_info, \
 444                 .get   = stac92xx_aloopback_get, \
 445                 .put   = stac92xx_aloopback_put, \
 446                 .private_value = verb_read | (verb_write << 16), \
 447         }
 448
 449 #define STAC_VOLKNOB(knob_nid)  \
 450         { \
 451                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 452                 .name  = "Master Playback Volume", \
 453                 .count = 1, \
 454                 .info  = stac92xx_volknob_info, \
 455                 .get   = stac92xx_volknob_get, \
 456                 .put   = stac92xx_volknob_put, \
 457                         .private_value = 127 | (knob_nid << 16), \
 458         }
 459
 460
 461 static struct snd_kcontrol_new stac9200_mixer[] = {
 462         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
 463         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
 464         STAC_INPUT_SOURCE(1),
 465         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
 466         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
 467         HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
 468         { } /* end */
 469 };
 470
 471 static struct snd_kcontrol_new stac925x_mixer[] = {
 472         STAC_INPUT_SOURCE(1),
 473         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
 474         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
 475         HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
 476         { } /* end */
 477 };
 478
 479 static struct snd_kcontrol_new stac9205_mixer[] = {
 480         {
 481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 482                 .name = "Digital Input Source",
 483                 .count = 1,
 484                 .info = stac92xx_dmux_enum_info,
 485                 .get = stac92xx_dmux_enum_get,
 486                 .put = stac92xx_dmux_enum_put,
 487         },
 488         STAC_INPUT_SOURCE(2),
 489         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0),
 490         STAC_VOLKNOB(0x24),
 491
 492         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
 493         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
 494         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
 495
 496         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
 497         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
 498         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
 499
 500         { } /* end */
 501 };
 502
 503 /* This needs to be generated dynamically based on sequence */
 504 static struct snd_kcontrol_new stac922x_mixer[] = {
 505         STAC_INPUT_SOURCE(2),
 506         STAC_VOLKNOB(0x16),
 507         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
 508         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
 509         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
 510
 511         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
 512         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
 513         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
 514         { } /* end */
 515 };
 516
 517
 518 static struct snd_kcontrol_new stac927x_mixer[] = {
 519         STAC_INPUT_SOURCE(3),
 520         STAC_VOLKNOB(0x24),
 521         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB),
 522
 523         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
 524         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
 525         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
 526
 527         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
 528         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
 529         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
 530
 531         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
 532         HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
 533         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
 534         { } /* end */
 535 };
 536
 537 static int stac92xx_build_controls(struct hda_codec *codec)
 538 {
 539         struct sigmatel_spec *spec = codec->spec;
 540         int err;
 541         int i;
 542
 543         err = snd_hda_add_new_ctls(codec, spec->mixer);
 544         if (err < 0)
 545                 return err;
 546
 547         for (i = 0; i < spec->num_mixers; i++) {
 548                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 549                 if (err < 0)
 550                         return err;
 551         }
 552
 553         if (spec->multiout.dig_out_nid) {
 554                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 555                 if (err < 0)
 556                         return err;
 557         }
 558         if (spec->dig_in_nid) {
 559                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 560                 if (err < 0)
 561                         return err;
 562         }
 563         return 0;
 564 }
 565
 566 static unsigned int ref9200_pin_configs[8] = {
 567         0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
 568         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
 569 };
 570
 571 /*
 572     STAC 9200 pin configs for
 573     102801A8
 574     102801DE
 575     102801E8
 576 */
 577 static unsigned int dell9200_d21_pin_configs[8] = {
 578         0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
 579         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
 580 };
 581
 582 /*
 583     STAC 9200 pin configs for
 584     102801C0
 585     102801C1
 586 */
 587 static unsigned int dell9200_d22_pin_configs[8] = {
 588         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
 589         0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
 590 };
 591
 592 /*
 593     STAC 9200 pin configs for
 594     102801C4 (Dell Dimension E310)
 595     102801C5
 596     102801C7
 597     102801D9
 598     102801DA
 599     102801E3
 600 */
 601 static unsigned int dell9200_d23_pin_configs[8] = {
 602         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
 603         0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
 604 };
 605
 606
 607 /*
 608     STAC 9200-32 pin configs for
 609     102801B5 (Dell Inspiron 630m)
 610     102801D8 (Dell Inspiron 640m)
 611 */
 612 static unsigned int dell9200_m21_pin_configs[8] = {
 613         0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
 614         0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
 615 };
 616
 617 /*
 618     STAC 9200-32 pin configs for
 619     102801C2 (Dell Latitude D620)
 620     102801C8
 621     102801CC (Dell Latitude D820)
 622     102801D4
 623     102801D6
 624 */
 625 static unsigned int dell9200_m22_pin_configs[8] = {
 626         0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
 627         0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
 628 };
 629
 630 /*
 631     STAC 9200-32 pin configs for
 632     102801CE (Dell XPS M1710)
 633     102801CF (Dell Precision M90)
 634 */
 635 static unsigned int dell9200_m23_pin_configs[8] = {
 636         0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
 637         0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
 638 };
 639
 640 /*
 641     STAC 9200-32 pin configs for
 642     102801C9
 643     102801CA
 644     102801CB (Dell Latitude 120L)
 645     102801D3
 646 */
 647 static unsigned int dell9200_m24_pin_configs[8] = {
 648         0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
 649         0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
 650 };
 651
 652 /*
 653     STAC 9200-32 pin configs for
 654     102801BD (Dell Inspiron E1505n)
 655     102801EE
 656     102801EF
 657 */
 658 static unsigned int dell9200_m25_pin_configs[8] = {
 659         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
 660         0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
 661 };
 662
 663 /*
 664     STAC 9200-32 pin configs for
 665     102801F5 (Dell Inspiron 1501)
 666     102801F6
 667 */
 668 static unsigned int dell9200_m26_pin_configs[8] = {
 669         0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
 670         0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
 671 };
 672
 673 /*
 674     STAC 9200-32
 675     102801CD (Dell Inspiron E1705/9400)
 676 */
 677 static unsigned int dell9200_m27_pin_configs[8] = {
 678         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
 679         0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
 680 };
 681
 682
 683 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
 684         [STAC_REF] = ref9200_pin_configs,
 685         [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
 686         [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
 687         [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
 688         [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
 689         [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
 690         [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
 691         [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
 692         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
 693         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
 694         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
 695 };
 696
 697 static const char *stac9200_models[STAC_9200_MODELS] = {
 698         [STAC_REF] = "ref",
 699         [STAC_9200_DELL_D21] = "dell-d21",
 700         [STAC_9200_DELL_D22] = "dell-d22",
 701         [STAC_9200_DELL_D23] = "dell-d23",
 702         [STAC_9200_DELL_M21] = "dell-m21",
 703         [STAC_9200_DELL_M22] = "dell-m22",
 704         [STAC_9200_DELL_M23] = "dell-m23",
 705         [STAC_9200_DELL_M24] = "dell-m24",
 706         [STAC_9200_DELL_M25] = "dell-m25",
 707         [STAC_9200_DELL_M26] = "dell-m26",
 708         [STAC_9200_DELL_M27] = "dell-m27",
 709         [STAC_9200_GATEWAY] = "gateway",
 710 };
 711
 712 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
 713         /* SigmaTel reference board */
 714         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 715                       "DFI LanParty", STAC_REF),
 716         /* Dell laptops have BIOS problem */
 717         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
 718                       "unknown Dell", STAC_9200_DELL_D21),
 719         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
 720                       "Dell Inspiron 630m", STAC_9200_DELL_M21),
 721         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
 722                       "Dell Inspiron E1505n", STAC_9200_DELL_M25),
 723         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
 724                       "unknown Dell", STAC_9200_DELL_D22),
 725         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
 726                       "unknown Dell", STAC_9200_DELL_D22),
 727         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
 728                       "Dell Latitude D620", STAC_9200_DELL_M22),
 729         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
 730                       "unknown Dell", STAC_9200_DELL_D23),
 731         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
 732                       "unknown Dell", STAC_9200_DELL_D23),
 733         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
 734                       "unknown Dell", STAC_9200_DELL_M22),
 735         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
 736                       "unknown Dell", STAC_9200_DELL_M24),
 737         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
 738                       "unknown Dell", STAC_9200_DELL_M24),
 739         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
 740                       "Dell Latitude 120L", STAC_9200_DELL_M24),
 741         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
 742                       "Dell Latitude D820", STAC_9200_DELL_M22),
 743         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
 744                       "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
 745         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
 746                       "Dell XPS M1710", STAC_9200_DELL_M23),
 747         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
 748                       "Dell Precision M90", STAC_9200_DELL_M23),
 749         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
 750                       "unknown Dell", STAC_9200_DELL_M22),
 751         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
 752                       "unknown Dell", STAC_9200_DELL_M22),
 753         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
 754                       "unknown Dell", STAC_9200_DELL_M22),
 755         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
 756                       "Dell Inspiron 640m", STAC_9200_DELL_M21),
 757         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
 758                       "unknown Dell", STAC_9200_DELL_D23),
 759         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
 760                       "unknown Dell", STAC_9200_DELL_D23),
 761         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
 762                       "unknown Dell", STAC_9200_DELL_D21),
 763         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
 764                       "unknown Dell", STAC_9200_DELL_D23),
 765         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
 766                       "unknown Dell", STAC_9200_DELL_D21),
 767         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
 768                       "unknown Dell", STAC_9200_DELL_M25),
 769         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
 770                       "unknown Dell", STAC_9200_DELL_M25),
 771         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
 772                       "Dell Inspiron 1501", STAC_9200_DELL_M26),
 773         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
 774                       "unknown Dell", STAC_9200_DELL_M26),
 775         /* Panasonic */
 776         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
 777         /* Gateway machines needs EAPD to be set on resume */
 778         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
 779         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
 780                       STAC_9200_GATEWAY),
 781         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
 782                       STAC_9200_GATEWAY),
 783         {} /* terminator */
 784 };
 785
 786 static unsigned int ref925x_pin_configs[8] = {
 787         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
 788         0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
 789 };
 790
 791 static unsigned int stac925x_MA6_pin_configs[8] = {
 792         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
 793         0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
 794 };
 795
 796 static unsigned int stac925x_PA6_pin_configs[8] = {
 797         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
 798         0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
 799 };
 800
 801 static unsigned int stac925xM2_2_pin_configs[8] = {
 802         0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
 803         0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
 804 };
 805
 806 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
 807         [STAC_REF] = ref925x_pin_configs,
 808         [STAC_M2_2] = stac925xM2_2_pin_configs,
 809         [STAC_MA6] = stac925x_MA6_pin_configs,
 810         [STAC_PA6] = stac925x_PA6_pin_configs,
 811 };
 812
 813 static const char *stac925x_models[STAC_925x_MODELS] = {
 814         [STAC_REF] = "ref",
 815         [STAC_M2_2] = "m2-2",
 816         [STAC_MA6] = "m6",
 817         [STAC_PA6] = "pa6",
 818 };
 819
 820 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
 821         /* SigmaTel reference board */
 822         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
 823         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
 824         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
 825         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
 826         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
 827         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
 828         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
 829         {} /* terminator */
 830 };
 831
 832 static unsigned int ref922x_pin_configs[10] = {
 833         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
 834         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
 835         0x40000100, 0x40000100,
 836 };
 837
 838 /*
 839     STAC 922X pin configs for
 840     102801A7
 841     102801AB
 842     102801A9
 843     102801D1
 844     102801D2
 845 */
 846 static unsigned int dell_922x_d81_pin_configs[10] = {
 847         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
 848         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
 849         0x01813122, 0x400001f2,
 850 };
 851
 852 /*
 853     STAC 922X pin configs for
 854     102801AC
 855     102801D0
 856 */
 857 static unsigned int dell_922x_d82_pin_configs[10] = {
 858         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
 859         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
 860         0x01813122, 0x400001f1,
 861 };
 862
 863 /*
 864     STAC 922X pin configs for
 865     102801BF
 866 */
 867 static unsigned int dell_922x_m81_pin_configs[10] = {
 868         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
 869         0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
 870         0x40C003f1, 0x405003f0,
 871 };
 872
 873 /*
 874     STAC 9221 A1 pin configs for
 875     102801D7 (Dell XPS M1210)
 876 */
 877 static unsigned int dell_922x_m82_pin_configs[10] = {
 878         0x0221121f, 0x408103ff, 0x02111212, 0x90100310,
 879         0x408003f1, 0x02111211, 0x03451340, 0x40c003f2,
 880         0x508003f3, 0x405003f4,
 881 };
 882
 883 static unsigned int d945gtp3_pin_configs[10] = {
 884         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
 885         0x40000100, 0x40000100, 0x40000100, 0x40000100,
 886         0x02a19120, 0x40000100,
 887 };
 888
 889 static unsigned int d945gtp5_pin_configs[10] = {
 890         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
 891         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
 892         0x02a19320, 0x40000100,
 893 };
 894
 895 static unsigned int intel_mac_v1_pin_configs[10] = {
 896         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
 897         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
 898         0x400000fc, 0x400000fb,
 899 };
 900
 901 static unsigned int intel_mac_v2_pin_configs[10] = {
 902         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
 903         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
 904         0x400000fc, 0x400000fb,
 905 };
 906
 907 static unsigned int intel_mac_v3_pin_configs[10] = {
 908         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
 909         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
 910         0x400000fc, 0x400000fb,
 911 };
 912
 913 static unsigned int intel_mac_v4_pin_configs[10] = {
 914         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
 915         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
 916         0x400000fc, 0x400000fb,
 917 };
 918
 919 static unsigned int intel_mac_v5_pin_configs[10] = {
 920         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
 921         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
 922         0x400000fc, 0x400000fb,
 923 };
 924
 925
 926 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
 927         [STAC_D945_REF] = ref922x_pin_configs,
 928         [STAC_D945GTP3] = d945gtp3_pin_configs,
 929         [STAC_D945GTP5] = d945gtp5_pin_configs,
 930         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
 931         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
 932         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
 933         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
 934         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
 935         /* for backward compatibility */
 936         [STAC_MACMINI] = intel_mac_v3_pin_configs,
 937         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
 938         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
 939         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
 940         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
 941         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
 942         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
 943         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
 944         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
 945         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
 946 };
 947
 948 static const char *stac922x_models[STAC_922X_MODELS] = {
 949         [STAC_D945_REF] = "ref",
 950         [STAC_D945GTP5] = "5stack",
 951         [STAC_D945GTP3] = "3stack",
 952         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
 953         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
 954         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
 955         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
 956         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
 957         /* for backward compatibility */
 958         [STAC_MACMINI]  = "macmini",
 959         [STAC_MACBOOK]  = "macbook",
 960         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
 961         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
 962         [STAC_IMAC_INTEL] = "imac-intel",
 963         [STAC_IMAC_INTEL_20] = "imac-intel-20",
 964         [STAC_922X_DELL_D81] = "dell-d81",
 965         [STAC_922X_DELL_D82] = "dell-d82",
 966         [STAC_922X_DELL_M81] = "dell-m81",
 967         [STAC_922X_DELL_M82] = "dell-m82",
 968 };
 969
 970 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
 971         /* SigmaTel reference board */
 972         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 973                       "DFI LanParty", STAC_D945_REF),
 974         /* Intel 945G based systems */
 975         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
 976                       "Intel D945G", STAC_D945GTP3),
 977         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
 978                       "Intel D945G", STAC_D945GTP3),
 979         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
 980                       "Intel D945G", STAC_D945GTP3),
 981         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
 982                       "Intel D945G", STAC_D945GTP3),
 983         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
 984                       "Intel D945G", STAC_D945GTP3),
 985         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
 986                       "Intel D945G", STAC_D945GTP3),
 987         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
 988                       "Intel D945G", STAC_D945GTP3),
 989         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
 990                       "Intel D945G", STAC_D945GTP3),
 991         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
 992                       "Intel D945G", STAC_D945GTP3),
 993         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
 994                       "Intel D945G", STAC_D945GTP3),
 995         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
 996                       "Intel D945G", STAC_D945GTP3),
 997         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
 998                       "Intel D945G", STAC_D945GTP3),
 999         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1000                       "Intel D945G", STAC_D945GTP3),
1001         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1002                       "Intel D945G", STAC_D945GTP3),
1003         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1004                       "Intel D945G", STAC_D945GTP3),
1005         /* Intel D945G 5-stack systems */
1006         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1007                       "Intel D945G", STAC_D945GTP5),
1008         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1009                       "Intel D945G", STAC_D945GTP5),
1010         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1011                       "Intel D945G", STAC_D945GTP5),
1012         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1013                       "Intel D945G", STAC_D945GTP5),
1014         /* Intel 945P based systems */
1015         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1016                       "Intel D945P", STAC_D945GTP3),
1017         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1018                       "Intel D945P", STAC_D945GTP3),
1019         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1020                       "Intel D945P", STAC_D945GTP3),
1021         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1022                       "Intel D945P", STAC_D945GTP3),
1023         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1024                       "Intel D945P", STAC_D945GTP3),
1025         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1026                       "Intel D945P", STAC_D945GTP5),
1027         /* other systems  */
1028         /* Apple Mac Mini (early 2006) */
1029         SND_PCI_QUIRK(0x8384, 0x7680,
1030                       "Mac Mini", STAC_INTEL_MAC_V3),
1031         /* Dell systems  */
1032         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1033                       "unknown Dell", STAC_922X_DELL_D81),
1034         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1035                       "unknown Dell", STAC_922X_DELL_D81),
1036         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1037                       "unknown Dell", STAC_922X_DELL_D81),
1038         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1039                       "unknown Dell", STAC_922X_DELL_D82),
1040         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1041                       "unknown Dell", STAC_922X_DELL_M81),
1042         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1043                       "unknown Dell", STAC_922X_DELL_D82),
1044         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1045                       "unknown Dell", STAC_922X_DELL_D81),
1046         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1047                       "unknown Dell", STAC_922X_DELL_D81),
1048         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1049                       "Dell XPS M1210", STAC_922X_DELL_M82),
1050         {} /* terminator */
1051 };
1052
1053 static unsigned int ref927x_pin_configs[14] = {
1054         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1055         0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1056         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1057         0x01c42190, 0x40000100,
1058 };
1059
1060 static unsigned int d965_3st_pin_configs[14] = {
1061         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1062         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1063         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1064         0x40000100, 0x40000100
1065 };
1066
1067 static unsigned int d965_5st_pin_configs[14] = {
1068         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1069         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1070         0x40000100, 0x40000100, 0x40000100, 0x01442070,
1071         0x40000100, 0x40000100
1072 };
1073
1074 static unsigned int dell_3st_pin_configs[14] = {
1075         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1076         0x01111212, 0x01116211, 0x01813050, 0x01112214,
1077         0x403003fa, 0x40000100, 0x40000100, 0x404003fb,
1078         0x40c003fc, 0x40000100
1079 };
1080
1081 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1082         [STAC_D965_REF] = ref927x_pin_configs,
1083         [STAC_D965_3ST] = d965_3st_pin_configs,
1084         [STAC_D965_5ST] = d965_5st_pin_configs,
1085         [STAC_DELL_3ST] = dell_3st_pin_configs,
1086 };
1087
1088 static const char *stac927x_models[STAC_927X_MODELS] = {
1089         [STAC_D965_REF] = "ref",
1090         [STAC_D965_3ST] = "3stack",
1091         [STAC_D965_5ST] = "5stack",
1092         [STAC_DELL_3ST] = "dell-3stack",
1093 };
1094
1095 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1096         /* SigmaTel reference board */
1097         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1098                       "DFI LanParty", STAC_D965_REF),
1099          /* Intel 946 based systems */
1100         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1101         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1102         /* 965 based 3 stack systems */
1103         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1104         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1105         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1106         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1107         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1108         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1109         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1110         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1111         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1112         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1113         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1114         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1115         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1116         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1117         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1118         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1119         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_D965_3ST),
1120         /* Dell 3 stack systems */
1121         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1122         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
1123         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
1124         /* 965 based 5 stack systems */
1125         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_D965_5ST),
1126         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1127         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1128         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1129         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1130         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1131         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1132         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1133         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1134         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1135         {} /* terminator */
1136 };
1137
1138 static unsigned int ref9205_pin_configs[12] = {
1139         0x40000100, 0x40000100, 0x01016011, 0x01014010,
1140         0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1141         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1142 };
1143
1144 /*
1145     STAC 9205 pin configs for
1146     102801F1
1147     102801F2
1148     102801FC
1149     102801FD
1150     10280204
1151     1028021F
1152 */
1153 static unsigned int dell_9205_m42_pin_configs[12] = {
1154         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1155         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1156         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1157 };
1158
1159 /*
1160     STAC 9205 pin configs for
1161     102801F9
1162     102801FA
1163     102801FE
1164     102801FF (Dell Precision M4300)
1165     10280206
1166     10280200
1167     10280201
1168 */
1169 static unsigned int dell_9205_m43_pin_configs[12] = {
1170         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1171         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1172         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1173 };
1174
1175 static unsigned int dell_9205_m44_pin_configs[12] = {
1176         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1177         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1178         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1179 };
1180
1181 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1182         [STAC_9205_REF] = ref9205_pin_configs,
1183         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1184         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1185         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1186 };
1187
1188 static const char *stac9205_models[STAC_9205_MODELS] = {
1189         [STAC_9205_REF] = "ref",
1190         [STAC_9205_DELL_M42] = "dell-m42",
1191         [STAC_9205_DELL_M43] = "dell-m43",
1192         [STAC_9205_DELL_M44] = "dell-m44",
1193 };
1194
1195 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1196         /* SigmaTel reference board */
1197         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1198                       "DFI LanParty", STAC_9205_REF),
1199         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1200                       "unknown Dell", STAC_9205_DELL_M42),
1201         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1202                       "unknown Dell", STAC_9205_DELL_M42),
1203         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1204                       "Dell Precision", STAC_9205_DELL_M43),
1205         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1206                           "Dell Precision", STAC_9205_DELL_M43),
1207         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1208                       "Dell Precision", STAC_9205_DELL_M43),
1209         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1210                       "Dell Precision", STAC_9205_DELL_M43),
1211         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1212                       "Dell Precision", STAC_9205_DELL_M43),
1213         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1214                       "unknown Dell", STAC_9205_DELL_M42),
1215         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1216                       "unknown Dell", STAC_9205_DELL_M42),
1217         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1218                       "Dell Precision", STAC_9205_DELL_M43),
1219         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1220                       "Dell Precision M4300", STAC_9205_DELL_M43),
1221         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1222                       "Dell Precision", STAC_9205_DELL_M43),
1223         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1224                       "Dell Inspiron", STAC_9205_DELL_M44),
1225         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1226                       "Dell Inspiron", STAC_9205_DELL_M44),
1227         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1228                       "Dell Inspiron", STAC_9205_DELL_M44),
1229         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1230                       "Dell Inspiron", STAC_9205_DELL_M44),
1231         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1232                       "unknown Dell", STAC_9205_DELL_M42),
1233         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1234                       "Dell Inspiron", STAC_9205_DELL_M44),
1235         {} /* terminator */
1236 };
1237
1238 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1239 {
1240         int i;
1241         struct sigmatel_spec *spec = codec->spec;
1242
1243         if (! spec->bios_pin_configs) {
1244                 spec->bios_pin_configs = kcalloc(spec->num_pins,
1245                                                  sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1246                 if (! spec->bios_pin_configs)
1247                         return -ENOMEM;
1248         }
1249
1250         for (i = 0; i < spec->num_pins; i++) {
1251                 hda_nid_t nid = spec->pin_nids[i];
1252                 unsigned int pin_cfg;
1253
1254                 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1255                         AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1256                 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1257                                         nid, pin_cfg);
1258                 spec->bios_pin_configs[i] = pin_cfg;
1259         }
1260
1261         return 0;
1262 }
1263
1264 static void stac92xx_set_config_reg(struct hda_codec *codec,
1265                                     hda_nid_t pin_nid, unsigned int pin_config)
1266 {
1267         int i;
1268         snd_hda_codec_write(codec, pin_nid, 0,
1269                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1270                             pin_config & 0x000000ff);
1271         snd_hda_codec_write(codec, pin_nid, 0,
1272                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1273                             (pin_config & 0x0000ff00) >> 8);
1274         snd_hda_codec_write(codec, pin_nid, 0,
1275                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1276                             (pin_config & 0x00ff0000) >> 16);
1277         snd_hda_codec_write(codec, pin_nid, 0,
1278                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1279                             pin_config >> 24);
1280         i = snd_hda_codec_read(codec, pin_nid, 0,
1281                                AC_VERB_GET_CONFIG_DEFAULT,
1282                                0x00);
1283         snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1284                     pin_nid, i);
1285 }
1286
1287 static void stac92xx_set_config_regs(struct hda_codec *codec)
1288 {
1289         int i;
1290         struct sigmatel_spec *spec = codec->spec;
1291
1292         if (!spec->pin_configs)
1293                 return;
1294
1295         for (i = 0; i < spec->num_pins; i++)
1296                 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1297                                         spec->pin_configs[i]);
1298 }
1299
1300 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1301 {
1302         struct sigmatel_spec *spec = codec->spec;
1303         /* Configure GPIOx as output */
1304         snd_hda_codec_write_cache(codec, codec->afg, 0,
1305                                   AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1306         /* Configure GPIOx as CMOS */
1307         snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1308         /* Assert GPIOx */
1309         snd_hda_codec_write_cache(codec, codec->afg, 0,
1310                                   AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1311         /* Enable GPIOx */
1312         snd_hda_codec_write_cache(codec, codec->afg, 0,
1313                                   AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1314 }
1315
1316 /*
1317  * Analog playback callbacks
1318  */
1319 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1320                                       struct hda_codec *codec,
1321                                       struct snd_pcm_substream *substream)
1322 {
1323         struct sigmatel_spec *spec = codec->spec;
1324         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1325 }
1326
1327 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1328                                          struct hda_codec *codec,
1329                                          unsigned int stream_tag,
1330                                          unsigned int format,
1331                                          struct snd_pcm_substream *substream)
1332 {
1333         struct sigmatel_spec *spec = codec->spec;
1334         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1335 }
1336
1337 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1338                                         struct hda_codec *codec,
1339                                         struct snd_pcm_substream *substream)
1340 {
1341         struct sigmatel_spec *spec = codec->spec;
1342         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1343 }
1344
1345 /*
1346  * Digital playback callbacks
1347  */
1348 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1349                                           struct hda_codec *codec,
1350                                           struct snd_pcm_substream *substream)
1351 {
1352         struct sigmatel_spec *spec = codec->spec;
1353         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1354 }
1355
1356 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1357                                            struct hda_codec *codec,
1358                                            struct snd_pcm_substream *substream)
1359 {
1360         struct sigmatel_spec *spec = codec->spec;
1361         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1362 }
1363
1364 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1365                                          struct hda_codec *codec,
1366                                          unsigned int stream_tag,
1367                                          unsigned int format,
1368                                          struct snd_pcm_substream *substream)
1369 {
1370         struct sigmatel_spec *spec = codec->spec;
1371         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1372                                              stream_tag, format, substream);
1373 }
1374
1375
1376 /*
1377  * Analog capture callbacks
1378  */
1379 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1380                                         struct hda_codec *codec,
1381                                         unsigned int stream_tag,
1382                                         unsigned int format,
1383                                         struct snd_pcm_substream *substream)
1384 {
1385         struct sigmatel_spec *spec = codec->spec;
1386
1387         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1388                                    stream_tag, 0, format);
1389         return 0;
1390 }
1391
1392 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1393                                         struct hda_codec *codec,
1394                                         struct snd_pcm_substream *substream)
1395 {
1396         struct sigmatel_spec *spec = codec->spec;
1397
1398         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1399         return 0;
1400 }
1401
1402 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1403         .substreams = 1,
1404         .channels_min = 2,
1405         .channels_max = 2,
1406         /* NID is set in stac92xx_build_pcms */
1407         .ops = {
1408                 .open = stac92xx_dig_playback_pcm_open,
1409                 .close = stac92xx_dig_playback_pcm_close,
1410                 .prepare = stac92xx_dig_playback_pcm_prepare
1411         },
1412 };
1413
1414 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1415         .substreams = 1,
1416         .channels_min = 2,
1417         .channels_max = 2,
1418         /* NID is set in stac92xx_build_pcms */
1419 };
1420
1421 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1422         .substreams = 1,
1423         .channels_min = 2,
1424         .channels_max = 8,
1425         .nid = 0x02, /* NID to query formats and rates */
1426         .ops = {
1427                 .open = stac92xx_playback_pcm_open,
1428                 .prepare = stac92xx_playback_pcm_prepare,
1429                 .cleanup = stac92xx_playback_pcm_cleanup
1430         },
1431 };
1432
1433 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1434         .substreams = 1,
1435         .channels_min = 2,
1436         .channels_max = 2,
1437         .nid = 0x06, /* NID to query formats and rates */
1438         .ops = {
1439                 .open = stac92xx_playback_pcm_open,
1440                 .prepare = stac92xx_playback_pcm_prepare,
1441                 .cleanup = stac92xx_playback_pcm_cleanup
1442         },
1443 };
1444
1445 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1446         .channels_min = 2,
1447         .channels_max = 2,
1448         /* NID + .substreams is set in stac92xx_build_pcms */
1449         .ops = {
1450                 .prepare = stac92xx_capture_pcm_prepare,
1451                 .cleanup = stac92xx_capture_pcm_cleanup
1452         },
1453 };
1454
1455 static int stac92xx_build_pcms(struct hda_codec *codec)
1456 {
1457         struct sigmatel_spec *spec = codec->spec;
1458         struct hda_pcm *info = spec->pcm_rec;
1459
1460         codec->num_pcms = 1;
1461         codec->pcm_info = info;
1462
1463         info->name = "STAC92xx Analog";
1464         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1465         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1466         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1467         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1468
1469         if (spec->alt_switch) {
1470                 codec->num_pcms++;
1471                 info++;
1472                 info->name = "STAC92xx Analog Alt";
1473                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1474         }
1475
1476         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1477                 codec->num_pcms++;
1478                 info++;
1479                 info->name = "STAC92xx Digital";
1480                 if (spec->multiout.dig_out_nid) {
1481                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1482                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1483                 }
1484                 if (spec->dig_in_nid) {
1485                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1486                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1487                 }
1488         }
1489
1490         return 0;
1491 }
1492
1493 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1494 {
1495         unsigned int pincap = snd_hda_param_read(codec, nid,
1496                                                  AC_PAR_PIN_CAP);
1497         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1498         if (pincap & AC_PINCAP_VREF_100)
1499                 return AC_PINCTL_VREF_100;
1500         if (pincap & AC_PINCAP_VREF_80)
1501                 return AC_PINCTL_VREF_80;
1502         if (pincap & AC_PINCAP_VREF_50)
1503                 return AC_PINCTL_VREF_50;
1504         if (pincap & AC_PINCAP_VREF_GRD)
1505                 return AC_PINCTL_VREF_GRD;
1506         return 0;
1507 }
1508
1509 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1510
1511 {
1512         snd_hda_codec_write_cache(codec, nid, 0,
1513                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1514 }
1515
1516 #define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
1517
1518 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1519 {
1520         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521         struct sigmatel_spec *spec = codec->spec;
1522         int io_idx = kcontrol-> private_value & 0xff;
1523
1524         ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1525         return 0;
1526 }
1527
1528 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1529 {
1530         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1531         struct sigmatel_spec *spec = codec->spec;
1532         hda_nid_t nid = kcontrol->private_value >> 8;
1533         int io_idx = kcontrol-> private_value & 0xff;
1534         unsigned short val = ucontrol->value.integer.value[0];
1535
1536         spec->io_switch[io_idx] = val;
1537
1538         if (val)
1539                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1540         else {
1541                 unsigned int pinctl = AC_PINCTL_IN_EN;
1542                 if (io_idx) /* set VREF for mic */
1543                         pinctl |= stac92xx_get_vref(codec, nid);
1544                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1545         }
1546         return 1;
1547 }
1548
1549 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1550
1551 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1552                 struct snd_ctl_elem_value *ucontrol)
1553 {
1554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1555         struct sigmatel_spec *spec = codec->spec;
1556
1557         ucontrol->value.integer.value[0] = spec->clfe_swap;
1558         return 0;
1559 }
1560
1561 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1562                 struct snd_ctl_elem_value *ucontrol)
1563 {
1564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1565         struct sigmatel_spec *spec = codec->spec;
1566         hda_nid_t nid = kcontrol->private_value & 0xff;
1567
1568         if (spec->clfe_swap == ucontrol->value.integer.value[0])
1569                 return 0;
1570
1571         spec->clfe_swap = ucontrol->value.integer.value[0];
1572
1573         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1574                 spec->clfe_swap ? 0x4 : 0x0);
1575
1576         return 1;
1577 }
1578
1579 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1580         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1581           .name = xname, \
1582           .index = 0, \
1583           .info = stac92xx_io_switch_info, \
1584           .get = stac92xx_io_switch_get, \
1585           .put = stac92xx_io_switch_put, \
1586           .private_value = xpval, \
1587         }
1588
1589 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1590         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1591           .name = xname, \
1592           .index = 0, \
1593           .info = stac92xx_clfe_switch_info, \
1594           .get = stac92xx_clfe_switch_get, \
1595           .put = stac92xx_clfe_switch_put, \
1596           .private_value = xpval, \
1597         }
1598
1599 enum {
1600         STAC_CTL_WIDGET_VOL,
1601         STAC_CTL_WIDGET_MUTE,
1602         STAC_CTL_WIDGET_IO_SWITCH,
1603         STAC_CTL_WIDGET_CLFE_SWITCH
1604 };
1605
1606 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1607         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1608         HDA_CODEC_MUTE(NULL, 0, 0, 0),
1609         STAC_CODEC_IO_SWITCH(NULL, 0),
1610         STAC_CODEC_CLFE_SWITCH(NULL, 0),
1611 };
1612
1613 /* add dynamic controls */
1614 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1615 {
1616         struct snd_kcontrol_new *knew;
1617
1618         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1619                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1620
1621                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1622                 if (! knew)
1623                         return -ENOMEM;
1624                 if (spec->kctl_alloc) {
1625                         memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1626                         kfree(spec->kctl_alloc);
1627                 }
1628                 spec->kctl_alloc = knew;
1629                 spec->num_kctl_alloc = num;
1630         }
1631
1632         knew = &spec->kctl_alloc[spec->num_kctl_used];
1633         *knew = stac92xx_control_templates[type];
1634         knew->name = kstrdup(name, GFP_KERNEL);
1635         if (! knew->name)
1636                 return -ENOMEM;
1637         knew->private_value = val;
1638         spec->num_kctl_used++;
1639         return 0;
1640 }
1641
1642 /* flag inputs as additional dynamic lineouts */
1643 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1644 {
1645         struct sigmatel_spec *spec = codec->spec;
1646         unsigned int wcaps, wtype;
1647         int i, num_dacs = 0;
1648
1649         /* use the wcaps cache to count all DACs available for line-outs */
1650         for (i = 0; i < codec->num_nodes; i++) {
1651                 wcaps = codec->wcaps[i];
1652                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1653                 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1654                         num_dacs++;
1655         }
1656
1657         snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
1658
1659         switch (cfg->line_outs) {
1660         case 3:
1661                 /* add line-in as side */
1662                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
1663                         cfg->line_out_pins[cfg->line_outs] =
1664                                 cfg->input_pins[AUTO_PIN_LINE];
1665                         spec->line_switch = 1;
1666                         cfg->line_outs++;
1667                 }
1668                 break;
1669         case 2:
1670                 /* add line-in as clfe and mic as side */
1671                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
1672                         cfg->line_out_pins[cfg->line_outs] =
1673                                 cfg->input_pins[AUTO_PIN_LINE];
1674                         spec->line_switch = 1;
1675                         cfg->line_outs++;
1676                 }
1677                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
1678                         cfg->line_out_pins[cfg->line_outs] =
1679                                 cfg->input_pins[AUTO_PIN_MIC];
1680                         spec->mic_switch = 1;
1681                         cfg->line_outs++;
1682                 }
1683                 break;
1684         case 1:
1685                 /* add line-in as surr and mic as clfe */
1686                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
1687                         cfg->line_out_pins[cfg->line_outs] =
1688                                 cfg->input_pins[AUTO_PIN_LINE];
1689                         spec->line_switch = 1;
1690                         cfg->line_outs++;
1691                 }
1692                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
1693                         cfg->line_out_pins[cfg->line_outs] =
1694                                 cfg->input_pins[AUTO_PIN_MIC];
1695                         spec->mic_switch = 1;
1696                         cfg->line_outs++;
1697                 }
1698                 break;
1699         }
1700
1701         return 0;
1702 }
1703
1704
1705 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1706 {
1707         int i;
1708
1709         for (i = 0; i < spec->multiout.num_dacs; i++) {
1710                 if (spec->multiout.dac_nids[i] == nid)
1711                         return 1;
1712         }
1713
1714         return 0;
1715 }
1716
1717 /*
1718  * Fill in the dac_nids table from the parsed pin configuration
1719  * This function only works when every pin in line_out_pins[]
1720  * contains atleast one DAC in its connection list. Some 92xx
1721  * codecs are not connected directly to a DAC, such as the 9200
1722  * and 9202/925x. For those, dac_nids[] must be hard-coded.
1723  */
1724 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
1725                                        struct auto_pin_cfg *cfg)
1726 {
1727         struct sigmatel_spec *spec = codec->spec;
1728         int i, j, conn_len = 0;
1729         hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
1730         unsigned int wcaps, wtype;
1731
1732         for (i = 0; i < cfg->line_outs; i++) {
1733                 nid = cfg->line_out_pins[i];
1734                 conn_len = snd_hda_get_connections(codec, nid, conn,
1735                                                    HDA_MAX_CONNECTIONS);
1736                 for (j = 0; j < conn_len; j++) {
1737                         wcaps = snd_hda_param_read(codec, conn[j],
1738                                                    AC_PAR_AUDIO_WIDGET_CAP);
1739                         wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1740
1741                         if (wtype != AC_WID_AUD_OUT ||
1742                             (wcaps & AC_WCAP_DIGITAL))
1743                                 continue;
1744                         /* conn[j] is a DAC routed to this line-out */
1745                         if (!is_in_dac_nids(spec, conn[j]))
1746                                 break;
1747                 }
1748
1749                 if (j == conn_len) {
1750                         if (spec->multiout.num_dacs > 0) {
1751                                 /* we have already working output pins,
1752                                  * so let's drop the broken ones again
1753                                  */
1754                                 cfg->line_outs = spec->multiout.num_dacs;
1755                                 break;
1756                         }
1757                         /* error out, no available DAC found */
1758                         snd_printk(KERN_ERR
1759                                    "%s: No available DAC for pin 0x%x\n",
1760                                    __func__, nid);
1761                         return -ENODEV;
1762                 }
1763
1764                 spec->multiout.dac_nids[i] = conn[j];
1765                 spec->multiout.num_dacs++;
1766                 if (conn_len > 1) {
1767                         /* select this DAC in the pin's input mux */
1768                         snd_hda_codec_write_cache(codec, nid, 0,
1769                                                   AC_VERB_SET_CONNECT_SEL, j);
1770
1771                 }
1772         }
1773
1774         snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
1775                    spec->multiout.num_dacs,
1776                    spec->multiout.dac_nids[0],
1777                    spec->multiout.dac_nids[1],
1778                    spec->multiout.dac_nids[2],
1779                    spec->multiout.dac_nids[3],
1780                    spec->multiout.dac_nids[4]);
1781         return 0;
1782 }
1783
1784 /* create volume control/switch for the given prefx type */
1785 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
1786 {
1787         char name[32];
1788         int err;
1789
1790         sprintf(name, "%s Playback Volume", pfx);
1791         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
1792                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1793         if (err < 0)
1794                 return err;
1795         sprintf(name, "%s Playback Switch", pfx);
1796         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
1797                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1798         if (err < 0)
1799                 return err;
1800         return 0;
1801 }
1802
1803 /* add playback controls from the parsed DAC table */
1804 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
1805                                                const struct auto_pin_cfg *cfg)
1806 {
1807         static const char *chname[4] = {
1808                 "Front", "Surround", NULL /*CLFE*/, "Side"
1809         };
1810         hda_nid_t nid;
1811         int i, err;
1812
1813         struct sigmatel_spec *spec = codec->spec;
1814         unsigned int wid_caps;
1815
1816
1817         for (i = 0; i < cfg->line_outs; i++) {
1818                 if (!spec->multiout.dac_nids[i])
1819                         continue;
1820
1821                 nid = spec->multiout.dac_nids[i];
1822
1823                 if (i == 2) {
1824                         /* Center/LFE */
1825                         err = create_controls(spec, "Center", nid, 1);
1826                         if (err < 0)
1827                                 return err;
1828                         err = create_controls(spec, "LFE", nid, 2);
1829                         if (err < 0)
1830                                 return err;
1831
1832                         wid_caps = get_wcaps(codec, nid);
1833
1834                         if (wid_caps & AC_WCAP_LR_SWAP) {
1835                                 err = stac92xx_add_control(spec,
1836                                         STAC_CTL_WIDGET_CLFE_SWITCH,
1837                                         "Swap Center/LFE Playback Switch", nid);
1838
1839                                 if (err < 0)
1840                                         return err;
1841                         }
1842
1843                 } else {
1844                         err = create_controls(spec, chname[i], nid, 3);
1845                         if (err < 0)
1846                                 return err;
1847                 }
1848         }
1849
1850         if (spec->line_switch)
1851                 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
1852                         return err;
1853
1854         if (spec->mic_switch)
1855                 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
1856                         return err;
1857
1858         return 0;
1859 }
1860
1861 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1862 {
1863         if (is_in_dac_nids(spec, nid))
1864                 return 1;
1865         if (spec->multiout.hp_nid == nid)
1866                 return 1;
1867         return 0;
1868 }
1869
1870 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
1871 {
1872         if (!spec->multiout.hp_nid)
1873                 spec->multiout.hp_nid = nid;
1874         else if (spec->multiout.num_dacs > 4) {
1875                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
1876                 return 1;
1877         } else {
1878                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
1879                 spec->multiout.num_dacs++;
1880         }
1881         return 0;
1882 }
1883
1884 /* add playback controls for Speaker and HP outputs */
1885 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
1886                                         struct auto_pin_cfg *cfg)
1887 {
1888         struct sigmatel_spec *spec = codec->spec;
1889         hda_nid_t nid;
1890         int i, old_num_dacs, err;
1891
1892         old_num_dacs = spec->multiout.num_dacs;
1893         for (i = 0; i < cfg->hp_outs; i++) {
1894                 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
1895                 if (wid_caps & AC_WCAP_UNSOL_CAP)
1896                         spec->hp_detect = 1;
1897                 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
1898                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1899                 if (check_in_dac_nids(spec, nid))
1900                         nid = 0;
1901                 if (! nid)
1902                         continue;
1903                 add_spec_dacs(spec, nid);
1904         }
1905         for (i = 0; i < cfg->speaker_outs; i++) {
1906                 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
1907                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1908                 if (check_in_dac_nids(spec, nid))
1909                         nid = 0;
1910                 if (! nid)
1911                         continue;
1912                 add_spec_dacs(spec, nid);
1913         }
1914         for (i = 0; i < cfg->line_outs; i++) {
1915                 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
1916                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1917                 if (check_in_dac_nids(spec, nid))
1918                         nid = 0;
1919                 if (! nid)
1920                         continue;
1921                 add_spec_dacs(spec, nid);
1922         }
1923         for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
1924                 static const char *pfxs[] = {
1925                         "Speaker", "External Speaker", "Speaker2",
1926                 };
1927                 err = create_controls(spec, pfxs[i - old_num_dacs],
1928                                       spec->multiout.dac_nids[i], 3);
1929                 if (err < 0)
1930                         return err;
1931         }
1932         if (spec->multiout.hp_nid) {
1933                 const char *pfx;
1934                 if (old_num_dacs == spec->multiout.num_dacs &&
1935                     spec->no_vol_knob)
1936                         pfx = "Master";
1937                 else
1938                         pfx = "Headphone";
1939                 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
1940                 if (err < 0)
1941                         return err;
1942         }
1943
1944         return 0;
1945 }
1946
1947 /* labels for dmic mux inputs */
1948 static const char *stac92xx_dmic_labels[5] = {
1949         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
1950         "Digital Mic 3", "Digital Mic 4"
1951 };
1952
1953 /* create playback/capture controls for input pins on dmic capable codecs */
1954 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
1955                                                 const struct auto_pin_cfg *cfg)
1956 {
1957         struct sigmatel_spec *spec = codec->spec;
1958         struct hda_input_mux *dimux = &spec->private_dimux;
1959         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1960         int i, j;
1961
1962         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
1963         dimux->items[dimux->num_items].index = 0;
1964         dimux->num_items++;
1965
1966         for (i = 0; i < spec->num_dmics; i++) {
1967                 int index;
1968                 int num_cons;
1969                 unsigned int def_conf;
1970
1971                 def_conf = snd_hda_codec_read(codec,
1972                                               spec->dmic_nids[i],
1973                                               0,
1974                                               AC_VERB_GET_CONFIG_DEFAULT,
1975                                               0);
1976                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
1977                         continue;
1978
1979                 num_cons = snd_hda_get_connections(codec,
1980                                 spec->dmux_nid,
1981                                 con_lst,
1982                                 HDA_MAX_NUM_INPUTS);
1983                 for (j = 0; j < num_cons; j++)
1984                         if (con_lst[j] == spec->dmic_nids[i]) {
1985                                 index = j;
1986                                 goto found;
1987                         }
1988                 continue;
1989 found:
1990                 dimux->items[dimux->num_items].label =
1991                         stac92xx_dmic_labels[dimux->num_items];
1992                 dimux->items[dimux->num_items].index = index;
1993                 dimux->num_items++;
1994         }
1995
1996         return 0;
1997 }
1998
1999 /* create playback/capture controls for input pins */
2000 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2001 {
2002         struct sigmatel_spec *spec = codec->spec;
2003         struct hda_input_mux *imux = &spec->private_imux;
2004         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2005         int i, j, k;
2006
2007         for (i = 0; i < AUTO_PIN_LAST; i++) {
2008                 int index;
2009
2010                 if (!cfg->input_pins[i])
2011                         continue;
2012                 index = -1;
2013                 for (j = 0; j < spec->num_muxes; j++) {
2014                         int num_cons;
2015                         num_cons = snd_hda_get_connections(codec,
2016                                                            spec->mux_nids[j],
2017                                                            con_lst,
2018                                                            HDA_MAX_NUM_INPUTS);
2019                         for (k = 0; k < num_cons; k++)
2020                                 if (con_lst[k] == cfg->input_pins[i]) {
2021                                         index = k;
2022                                         goto found;
2023                                 }
2024                 }
2025                 continue;
2026         found:
2027                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2028                 imux->items[imux->num_items].index = index;
2029                 imux->num_items++;
2030         }
2031
2032         if (imux->num_items) {
2033                 /*
2034                  * Set the current input for the muxes.
2035                  * The STAC9221 has two input muxes with identical source
2036                  * NID lists.  Hopefully this won't get confused.
2037                  */
2038                 for (i = 0; i < spec->num_muxes; i++) {
2039                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2040                                                   AC_VERB_SET_CONNECT_SEL,
2041                                                   imux->items[0].index);
2042                 }
2043         }
2044
2045         return 0;
2046 }
2047
2048 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2049 {
2050         struct sigmatel_spec *spec = codec->spec;
2051         int i;
2052
2053         for (i = 0; i < spec->autocfg.line_outs; i++) {
2054                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2055                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2056         }
2057 }
2058
2059 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2060 {
2061         struct sigmatel_spec *spec = codec->spec;
2062         int i;
2063
2064         for (i = 0; i < spec->autocfg.hp_outs; i++) {
2065                 hda_nid_t pin;
2066                 pin = spec->autocfg.hp_pins[i];
2067                 if (pin) /* connect to front */
2068                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2069         }
2070         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2071                 hda_nid_t pin;
2072                 pin = spec->autocfg.speaker_pins[i];
2073                 if (pin) /* connect to front */
2074                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2075         }
2076 }
2077
2078 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2079 {
2080         struct sigmatel_spec *spec = codec->spec;
2081         int err;
2082
2083         if ((err = snd_hda_parse_pin_def_config(codec,
2084                                                 &spec->autocfg,
2085                                                 spec->dmic_nids)) < 0)
2086                 return err;
2087         if (! spec->autocfg.line_outs)
2088                 return 0; /* can't find valid pin config */
2089
2090         if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2091                 return err;
2092         if (spec->multiout.num_dacs == 0)
2093                 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2094                         return err;
2095
2096         err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2097
2098         if (err < 0)
2099                 return err;
2100
2101         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2102
2103         if (err < 0)
2104                 return err;
2105
2106         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2107
2108         if (err < 0)
2109                 return err;
2110
2111         if (spec->num_dmics > 0)
2112                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2113                                                 &spec->autocfg)) < 0)
2114                         return err;
2115
2116         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2117         if (spec->multiout.max_channels > 2)
2118                 spec->surr_switch = 1;
2119
2120         if (spec->autocfg.dig_out_pin)
2121                 spec->multiout.dig_out_nid = dig_out;
2122         if (spec->autocfg.dig_in_pin)
2123                 spec->dig_in_nid = dig_in;
2124
2125         if (spec->kctl_alloc)
2126                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2127
2128         spec->input_mux = &spec->private_imux;
2129         spec->dinput_mux = &spec->private_dimux;
2130
2131         return 1;
2132 }
2133
2134 /* add playback controls for HP output */
2135 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2136                                         struct auto_pin_cfg *cfg)
2137 {
2138         struct sigmatel_spec *spec = codec->spec;
2139         hda_nid_t pin = cfg->hp_pins[0];
2140         unsigned int wid_caps;
2141
2142         if (! pin)
2143                 return 0;
2144
2145         wid_caps = get_wcaps(codec, pin);
2146         if (wid_caps & AC_WCAP_UNSOL_CAP)
2147                 spec->hp_detect = 1;
2148
2149         return 0;
2150 }
2151
2152 /* add playback controls for LFE output */
2153 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2154                                         struct auto_pin_cfg *cfg)
2155 {
2156         struct sigmatel_spec *spec = codec->spec;
2157         int err;
2158         hda_nid_t lfe_pin = 0x0;
2159         int i;
2160
2161         /*
2162          * search speaker outs and line outs for a mono speaker pin
2163          * with an amp.  If one is found, add LFE controls
2164          * for it.
2165          */
2166         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2167                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2168                 unsigned long wcaps = get_wcaps(codec, pin);
2169                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2170                 if (wcaps == AC_WCAP_OUT_AMP)
2171                         /* found a mono speaker with an amp, must be lfe */
2172                         lfe_pin = pin;
2173         }
2174
2175         /* if speaker_outs is 0, then speakers may be in line_outs */
2176         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2177                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2178                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
2179                         unsigned long cfg;
2180                         cfg = snd_hda_codec_read(codec, pin, 0,
2181                                                  AC_VERB_GET_CONFIG_DEFAULT,
2182                                                  0x00);
2183                         if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2184                                 unsigned long wcaps = get_wcaps(codec, pin);
2185                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2186                                 if (wcaps == AC_WCAP_OUT_AMP)
2187                                         /* found a mono speaker with an amp,
2188                                            must be lfe */
2189                                         lfe_pin = pin;
2190                         }
2191                 }
2192         }
2193
2194         if (lfe_pin) {
2195                 err = create_controls(spec, "LFE", lfe_pin, 1);
2196                 if (err < 0)
2197                         return err;
2198         }
2199
2200         return 0;
2201 }
2202
2203 static int stac9200_parse_auto_config(struct hda_codec *codec)
2204 {
2205         struct sigmatel_spec *spec = codec->spec;
2206         int err;
2207
2208         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2209                 return err;
2210
2211         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2212                 return err;
2213
2214         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2215                 return err;
2216
2217         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2218                 return err;
2219
2220         if (spec->autocfg.dig_out_pin)
2221                 spec->multiout.dig_out_nid = 0x05;
2222         if (spec->autocfg.dig_in_pin)
2223                 spec->dig_in_nid = 0x04;
2224
2225         if (spec->kctl_alloc)
2226                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2227
2228         spec->input_mux = &spec->private_imux;
2229         spec->dinput_mux = &spec->private_dimux;
2230
2231         return 1;
2232 }
2233
2234 /*
2235  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2236  * funky external mute control using GPIO pins.
2237  */
2238
2239 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2240 {
2241         unsigned int gpiostate, gpiomask, gpiodir;
2242
2243         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2244                                        AC_VERB_GET_GPIO_DATA, 0);
2245
2246         if (!muted)
2247                 gpiostate |= (1 << pin);
2248         else
2249                 gpiostate &= ~(1 << pin);
2250
2251         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2252                                       AC_VERB_GET_GPIO_MASK, 0);
2253         gpiomask |= (1 << pin);
2254
2255         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2256                                      AC_VERB_GET_GPIO_DIRECTION, 0);
2257         gpiodir |= (1 << pin);
2258
2259         /* AppleHDA seems to do this -- WTF is this verb?? */
2260         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2261
2262         snd_hda_codec_write(codec, codec->afg, 0,
2263                             AC_VERB_SET_GPIO_MASK, gpiomask);
2264         snd_hda_codec_write(codec, codec->afg, 0,
2265                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2266
2267         msleep(1);
2268
2269         snd_hda_codec_write(codec, codec->afg, 0,
2270                             AC_VERB_SET_GPIO_DATA, gpiostate);
2271 }
2272
2273 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2274                               unsigned int event)
2275 {
2276         if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2277                 snd_hda_codec_write_cache(codec, nid, 0,
2278                                           AC_VERB_SET_UNSOLICITED_ENABLE,
2279                                           (AC_USRSP_EN | event));
2280 }
2281
2282 static int stac92xx_init(struct hda_codec *codec)
2283 {
2284         struct sigmatel_spec *spec = codec->spec;
2285         struct auto_pin_cfg *cfg = &spec->autocfg;
2286         int i;
2287
2288         snd_hda_sequence_write(codec, spec->init);
2289
2290         /* set up pins */
2291         if (spec->hp_detect) {
2292                 /* Enable unsolicited responses on the HP widget */
2293                 for (i = 0; i < cfg->hp_outs; i++)
2294                         enable_pin_detect(codec, cfg->hp_pins[i],
2295                                           STAC_HP_EVENT);
2296                 /* force to enable the first line-out; the others are set up
2297                  * in unsol_event
2298                  */
2299                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2300                                          AC_PINCTL_OUT_EN);
2301                 stac92xx_auto_init_hp_out(codec);
2302                 /* fake event to set up pins */
2303                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2304         } else {
2305                 stac92xx_auto_init_multi_out(codec);
2306                 stac92xx_auto_init_hp_out(codec);
2307         }
2308         for (i = 0; i < AUTO_PIN_LAST; i++) {
2309                 hda_nid_t nid = cfg->input_pins[i];
2310                 if (nid) {
2311                         unsigned int pinctl = AC_PINCTL_IN_EN;
2312                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2313                                 pinctl |= stac92xx_get_vref(codec, nid);
2314                         stac92xx_auto_set_pinctl(codec, nid, pinctl);
2315                 }
2316         }
2317         if (spec->num_dmics > 0)
2318                 for (i = 0; i < spec->num_dmics; i++)
2319                         stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2320                                                  AC_PINCTL_IN_EN);
2321
2322         if (cfg->dig_out_pin)
2323                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2324                                          AC_PINCTL_OUT_EN);
2325         if (cfg->dig_in_pin)
2326                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2327                                          AC_PINCTL_IN_EN);
2328
2329         if (spec->gpio_mute) {
2330                 stac922x_gpio_mute(codec, 0, 0);
2331                 stac922x_gpio_mute(codec, 1, 0);
2332         }
2333
2334         return 0;
2335 }
2336
2337 static void stac92xx_free(struct hda_codec *codec)
2338 {
2339         struct sigmatel_spec *spec = codec->spec;
2340         int i;
2341
2342         if (! spec)
2343                 return;
2344
2345         if (spec->kctl_alloc) {
2346                 for (i = 0; i < spec->num_kctl_used; i++)
2347                         kfree(spec->kctl_alloc[i].name);
2348                 kfree(spec->kctl_alloc);
2349         }
2350
2351         if (spec->bios_pin_configs)
2352                 kfree(spec->bios_pin_configs);
2353
2354         kfree(spec);
2355 }
2356
2357 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2358                                 unsigned int flag)
2359 {
2360         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2361                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2362
2363         if (pin_ctl & AC_PINCTL_IN_EN) {
2364                 /*
2365                  * we need to check the current set-up direction of
2366                  * shared input pins since they can be switched via
2367                  * "xxx as Output" mixer switch
2368                  */
2369                 struct sigmatel_spec *spec = codec->spec;
2370                 struct auto_pin_cfg *cfg = &spec->autocfg;
2371                 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2372                      spec->line_switch) ||
2373                     (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2374                      spec->mic_switch))
2375                         return;
2376         }
2377
2378         /* if setting pin direction bits, clear the current
2379            direction bits first */
2380         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2381                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2382
2383         snd_hda_codec_write_cache(codec, nid, 0,
2384                         AC_VERB_SET_PIN_WIDGET_CONTROL,
2385                         pin_ctl | flag);
2386 }
2387
2388 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2389                                   unsigned int flag)
2390 {
2391         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2392                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2393         snd_hda_codec_write_cache(codec, nid, 0,
2394                         AC_VERB_SET_PIN_WIDGET_CONTROL,
2395                         pin_ctl & ~flag);
2396 }
2397
2398 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2399 {
2400         if (!nid)
2401                 return 0;
2402         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2403             & (1 << 31))
2404                 return 1;
2405         return 0;
2406 }
2407
2408 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2409 {
2410         struct sigmatel_spec *spec = codec->spec;
2411         struct auto_pin_cfg *cfg = &spec->autocfg;
2412         int i, presence;
2413
2414         presence = 0;
2415         for (i = 0; i < cfg->hp_outs; i++) {
2416                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
2417                 if (presence)
2418                         break;
2419         }
2420
2421         if (presence) {
2422                 /* disable lineouts, enable hp */
2423                 for (i = 0; i < cfg->line_outs; i++)
2424                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2425                                                 AC_PINCTL_OUT_EN);
2426                 for (i = 0; i < cfg->speaker_outs; i++)
2427                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2428                                                 AC_PINCTL_OUT_EN);
2429         } else {
2430                 /* enable lineouts, disable hp */
2431                 for (i = 0; i < cfg->line_outs; i++)
2432                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2433                                                 AC_PINCTL_OUT_EN);
2434                 for (i = 0; i < cfg->speaker_outs; i++)
2435                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2436                                                 AC_PINCTL_OUT_EN);
2437         }
2438 }
2439
2440 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2441 {
2442         switch (res >> 26) {
2443         case STAC_HP_EVENT:
2444                 stac92xx_hp_detect(codec, res);
2445                 break;
2446         }
2447 }
2448
2449 #ifdef SND_HDA_NEEDS_RESUME
2450 static int stac92xx_resume(struct hda_codec *codec)
2451 {
2452         struct sigmatel_spec *spec = codec->spec;
2453
2454         stac92xx_set_config_regs(codec);
2455         snd_hda_sequence_write(codec, spec->init);
2456         if (spec->gpio_mute) {
2457                 stac922x_gpio_mute(codec, 0, 0);
2458                 stac922x_gpio_mute(codec, 1, 0);
2459         }
2460         snd_hda_codec_resume_amp(codec);
2461         snd_hda_codec_resume_cache(codec);
2462         /* invoke unsolicited event to reset the HP state */
2463         if (spec->hp_detect)
2464                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2465         return 0;
2466 }
2467 #endif
2468
2469 static struct hda_codec_ops stac92xx_patch_ops = {
2470         .build_controls = stac92xx_build_controls,
2471         .build_pcms = stac92xx_build_pcms,
2472         .init = stac92xx_init,
2473         .free = stac92xx_free,
2474         .unsol_event = stac92xx_unsol_event,
2475 #ifdef SND_HDA_NEEDS_RESUME
2476         .resume = stac92xx_resume,
2477 #endif
2478 };
2479
2480 static int patch_stac9200(struct hda_codec *codec)
2481 {
2482         struct sigmatel_spec *spec;
2483         int err;
2484
2485         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
2486         if (spec == NULL)
2487                 return -ENOMEM;
2488
2489         codec->spec = spec;
2490         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2491         spec->pin_nids = stac9200_pin_nids;
2492         spec->no_vol_knob = 1;
2493         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2494                                                         stac9200_models,
2495                                                         stac9200_cfg_tbl);
2496         if (spec->board_config < 0) {
2497                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2498                 err = stac92xx_save_bios_config_regs(codec);
2499                 if (err < 0) {
2500                         stac92xx_free(codec);
2501                         return err;
2502                 }
2503                 spec->pin_configs = spec->bios_pin_configs;
2504         } else {
2505                 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2506                 stac92xx_set_config_regs(codec);
2507         }
2508
2509         spec->multiout.max_channels = 2;
2510         spec->multiout.num_dacs = 1;
2511         spec->multiout.dac_nids = stac9200_dac_nids;
2512         spec->adc_nids = stac9200_adc_nids;
2513         spec->mux_nids = stac9200_mux_nids;
2514         spec->num_muxes = 1;
2515         spec->num_dmics = 0;
2516         spec->num_adcs = 1;
2517
2518         if (spec->board_config == STAC_9200_GATEWAY)
2519                 spec->init = stac9200_eapd_init;
2520         else
2521                 spec->init = stac9200_core_init;
2522         spec->mixer = stac9200_mixer;
2523
2524         err = stac9200_parse_auto_config(codec);
2525         if (err < 0) {
2526                 stac92xx_free(codec);
2527                 return err;
2528         }
2529
2530         codec->patch_ops = stac92xx_patch_ops;
2531
2532         return 0;
2533 }
2534
2535 static int patch_stac925x(struct hda_codec *codec)
2536 {
2537         struct sigmatel_spec *spec;
2538         int err;
2539
2540         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
2541         if (spec == NULL)
2542                 return -ENOMEM;
2543
2544         codec->spec = spec;
2545         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2546         spec->pin_nids = stac925x_pin_nids;
2547         spec->no_vol_knob = 1;
2548         spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2549                                                         stac925x_models,
2550                                                         stac925x_cfg_tbl);
2551  again:
2552         if (spec->board_config < 0) {
2553                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2554                                       "using BIOS defaults\n");
2555                 err = stac92xx_save_bios_config_regs(codec);
2556                 if (err < 0) {
2557                         stac92xx_free(codec);
2558                         return err;
2559                 }
2560                 spec->pin_configs = spec->bios_pin_configs;
2561         } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2562                 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2563                 stac92xx_set_config_regs(codec);
2564         }
2565
2566         spec->multiout.max_channels = 2;
2567         spec->multiout.num_dacs = 1;
2568         spec->multiout.dac_nids = stac925x_dac_nids;
2569         spec->adc_nids = stac925x_adc_nids;
2570         spec->mux_nids = stac925x_mux_nids;
2571         spec->num_muxes = 1;
2572         spec->num_adcs = 1;
2573         switch (codec->vendor_id) {
2574         case 0x83847632: /* STAC9202  */
2575         case 0x83847633: /* STAC9202D */
2576         case 0x83847636: /* STAC9251  */
2577         case 0x83847637: /* STAC9251D */
2578                 spec->num_dmics = STAC925X_NUM_DMICS;
2579                 spec->dmic_nids = stac925x_dmic_nids;
2580                 break;
2581         default:
2582                 spec->num_dmics = 0;
2583                 break;
2584         }
2585
2586         spec->init = stac925x_core_init;
2587         spec->mixer = stac925x_mixer;
2588
2589         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2590         if (!err) {
2591                 if (spec->board_config < 0) {
2592                         printk(KERN_WARNING "hda_codec: No auto-config is "
2593                                "available, default to model=ref\n");
2594                         spec->board_config = STAC_925x_REF;
2595                         goto again;
2596                 }
2597                 err = -EINVAL;
2598         }
2599         if (err < 0) {
2600                 stac92xx_free(codec);
2601                 return err;
2602         }
2603
2604         codec->patch_ops = stac92xx_patch_ops;
2605
2606         return 0;
2607 }
2608
2609 static int patch_stac922x(struct hda_codec *codec)
2610 {
2611         struct sigmatel_spec *spec;
2612         int err;
2613
2614         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
2615         if (spec == NULL)
2616                 return -ENOMEM;
2617
2618         codec->spec = spec;
2619         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
2620         spec->pin_nids = stac922x_pin_nids;
2621         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
2622                                                         stac922x_models,
2623                                                         stac922x_cfg_tbl);
2624         if (spec->board_config == STAC_INTEL_MAC_V3) {
2625                 spec->gpio_mute = 1;
2626                 /* Intel Macs have all same PCI SSID, so we need to check
2627                  * codec SSID to distinguish the exact models
2628                  */
2629                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
2630                 switch (codec->subsystem_id) {
2631
2632                 case 0x106b0800:
2633                         spec->board_config = STAC_INTEL_MAC_V1;
2634                         break;
2635                 case 0x106b0600:
2636                 case 0x106b0700:
2637                         spec->board_config = STAC_INTEL_MAC_V2;
2638                         break;
2639                 case 0x106b0e00:
2640                 case 0x106b0f00:
2641                 case 0x106b1600:
2642                 case 0x106b1700:
2643                 case 0x106b0200:
2644                 case 0x106b1e00:
2645                         spec->board_config = STAC_INTEL_MAC_V3;
2646                         break;
2647                 case 0x106b1a00:
2648                 case 0x00000100:
2649                         spec->board_config = STAC_INTEL_MAC_V4;
2650                         break;
2651                 case 0x106b0a00:
2652                 case 0x106b2200:
2653                         spec->board_config = STAC_INTEL_MAC_V5;
2654                         break;
2655                 }
2656         }
2657
2658  again:
2659         if (spec->board_config < 0) {
2660                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
2661                         "using BIOS defaults\n");
2662                 err = stac92xx_save_bios_config_regs(codec);
2663                 if (err < 0) {
2664                         stac92xx_free(codec);
2665                         return err;
2666                 }
2667                 spec->pin_configs = spec->bios_pin_configs;
2668         } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
2669                 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
2670                 stac92xx_set_config_regs(codec);
2671         }
2672
2673         spec->adc_nids = stac922x_adc_nids;
2674         spec->mux_nids = stac922x_mux_nids;
2675         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
2676         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
2677         spec->num_dmics = 0;
2678
2679         spec->init = stac922x_core_init;
2680         spec->mixer = stac922x_mixer;
2681
2682         spec->multiout.dac_nids = spec->dac_nids;
2683
2684         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
2685         if (!err) {
2686                 if (spec->board_config < 0) {
2687                         printk(KERN_WARNING "hda_codec: No auto-config is "
2688                                "available, default to model=ref\n");
2689                         spec->board_config = STAC_D945_REF;
2690                         goto again;
2691                 }
2692                 err = -EINVAL;
2693         }
2694         if (err < 0) {
2695                 stac92xx_free(codec);
2696                 return err;
2697         }
2698
2699         codec->patch_ops = stac92xx_patch_ops;
2700
2701         /* Fix Mux capture level; max to 2 */
2702         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
2703                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
2704                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2705                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2706                                   (0 << AC_AMPCAP_MUTE_SHIFT));
2707
2708         return 0;
2709 }
2710
2711 static int patch_stac927x(struct hda_codec *codec)
2712 {
2713         struct sigmatel_spec *spec;
2714         int err;
2715
2716         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
2717         if (spec == NULL)
2718                 return -ENOMEM;
2719
2720         codec->spec = spec;
2721         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
2722         spec->pin_nids = stac927x_pin_nids;
2723         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
2724                                                         stac927x_models,
2725                                                         stac927x_cfg_tbl);
2726  again:
2727         if (spec->board_config < 0) {
2728                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
2729                 err = stac92xx_save_bios_config_regs(codec);
2730                 if (err < 0) {
2731                         stac92xx_free(codec);
2732                         return err;
2733                 }
2734                 spec->pin_configs = spec->bios_pin_configs;
2735         } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
2736                 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
2737                 stac92xx_set_config_regs(codec);
2738         }
2739
2740         switch (spec->board_config) {
2741         case STAC_D965_3ST:
2742                 spec->adc_nids = stac927x_adc_nids;
2743                 spec->mux_nids = stac927x_mux_nids;
2744                 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2745                 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2746                 spec->num_dmics = 0;
2747                 spec->init = d965_core_init;
2748                 spec->mixer = stac927x_mixer;
2749                 break;
2750         case STAC_D965_5ST:
2751                 spec->adc_nids = stac927x_adc_nids;
2752                 spec->mux_nids = stac927x_mux_nids;
2753                 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2754                 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2755                 spec->num_dmics = 0;
2756                 spec->init = d965_core_init;
2757                 spec->mixer = stac927x_mixer;
2758                 break;
2759         default:
2760                 spec->adc_nids = stac927x_adc_nids;
2761                 spec->mux_nids = stac927x_mux_nids;
2762                 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2763                 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2764                 spec->num_dmics = 0;
2765                 spec->init = stac927x_core_init;
2766                 spec->mixer = stac927x_mixer;
2767         }
2768
2769         spec->multiout.dac_nids = spec->dac_nids;
2770         /* GPIO0 High = Enable EAPD */
2771         spec->gpio_mask = spec->gpio_data = 0x00000001;
2772         stac92xx_enable_gpio_mask(codec);
2773
2774         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
2775         if (!err) {
2776                 if (spec->board_config < 0) {
2777                         printk(KERN_WARNING "hda_codec: No auto-config is "
2778                                "available, default to model=ref\n");
2779                         spec->board_config = STAC_D965_REF;
2780                         goto again;
2781                 }
2782                 err = -EINVAL;
2783         }
2784         if (err < 0) {
2785                 stac92xx_free(codec);
2786                 return err;
2787         }
2788
2789         codec->patch_ops = stac92xx_patch_ops;
2790
2791         return 0;
2792 }
2793
2794 static int patch_stac9205(struct hda_codec *codec)
2795 {
2796         struct sigmatel_spec *spec;
2797         int err;
2798
2799         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
2800         if (spec == NULL)
2801                 return -ENOMEM;
2802
2803         codec->spec = spec;
2804         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
2805         spec->pin_nids = stac9205_pin_nids;
2806         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
2807                                                         stac9205_models,
2808                                                         stac9205_cfg_tbl);
2809  again:
2810         if (spec->board_config < 0) {
2811                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
2812                 err = stac92xx_save_bios_config_regs(codec);
2813                 if (err < 0) {
2814                         stac92xx_free(codec);
2815                         return err;
2816                 }
2817                 spec->pin_configs = spec->bios_pin_configs;
2818         } else {
2819                 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
2820                 stac92xx_set_config_regs(codec);
2821         }
2822
2823         spec->adc_nids = stac9205_adc_nids;
2824         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
2825         spec->mux_nids = stac9205_mux_nids;
2826         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
2827         spec->dmic_nids = stac9205_dmic_nids;
2828         spec->num_dmics = STAC9205_NUM_DMICS;
2829         spec->dmux_nid = 0x1d;
2830
2831         spec->init = stac9205_core_init;
2832         spec->mixer = stac9205_mixer;
2833
2834         spec->multiout.dac_nids = spec->dac_nids;
2835
2836         switch (spec->board_config){
2837         case STAC_9205_DELL_M43:
2838                 /* Enable SPDIF in/out */
2839                 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
2840                 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
2841
2842                 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
2843                 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
2844                  * GPIO2 High = Headphone Mute
2845                  */
2846                 spec->gpio_data = 0x00000005;
2847                 break;
2848         default:
2849                 /* GPIO0 High = EAPD */
2850                 spec->gpio_mask = spec->gpio_data = 0x00000001;
2851                 break;
2852         }
2853
2854         stac92xx_enable_gpio_mask(codec);
2855         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
2856         if (!err) {
2857                 if (spec->board_config < 0) {
2858                         printk(KERN_WARNING "hda_codec: No auto-config is "
2859                                "available, default to model=ref\n");
2860                         spec->board_config = STAC_9205_REF;
2861                         goto again;
2862                 }
2863                 err = -EINVAL;
2864         }
2865         if (err < 0) {
2866                 stac92xx_free(codec);
2867                 return err;
2868         }
2869
2870         codec->patch_ops = stac92xx_patch_ops;
2871
2872         return 0;
2873 }
2874
2875 /*
2876  * STAC9872 hack
2877  */
2878
2879 /* static config for Sony VAIO FE550G and Sony VAIO AR */
2880 static hda_nid_t vaio_dacs[] = { 0x2 };
2881 #define VAIO_HP_DAC     0x5
2882 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
2883 static hda_nid_t vaio_mux_nids[] = { 0x15 };
2884
2885 static struct hda_input_mux vaio_mux = {
2886         .num_items = 3,
2887         .items = {
2888                 /* { "HP", 0x0 }, */
2889                 { "Mic Jack", 0x1 },
2890                 { "Internal Mic", 0x2 },
2891                 { "PCM", 0x3 },
2892         }
2893 };
2894
2895 static struct hda_verb vaio_init[] = {
2896         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2897         {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
2898         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2899         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2900         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
2901         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
2902         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
2903         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
2904         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
2905         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2906         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2907         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2908         {}
2909 };
2910
2911 static struct hda_verb vaio_ar_init[] = {
2912         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2913         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2914         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2915         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
2916 /*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
2917         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
2918         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
2919         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
2920         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
2921 /*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
2922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2923         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2924         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2925         {}
2926 };
2927
2928 /* bind volumes of both NID 0x02 and 0x05 */
2929 static struct hda_bind_ctls vaio_bind_master_vol = {
2930         .ops = &snd_hda_bind_vol,
2931         .values = {
2932                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2933                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2934                 0
2935         },
2936 };
2937
2938 /* bind volumes of both NID 0x02 and 0x05 */
2939 static struct hda_bind_ctls vaio_bind_master_sw = {
2940         .ops = &snd_hda_bind_sw,
2941         .values = {
2942                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2943                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2944                 0,
2945         },
2946 };
2947
2948 static struct snd_kcontrol_new vaio_mixer[] = {
2949         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2950         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2951         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2952         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2953         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2954         {
2955                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2956                 .name = "Capture Source",
2957                 .count = 1,
2958                 .info = stac92xx_mux_enum_info,
2959                 .get = stac92xx_mux_enum_get,
2960                 .put = stac92xx_mux_enum_put,
2961         },
2962         {}
2963 };
2964
2965 static struct snd_kcontrol_new vaio_ar_mixer[] = {
2966         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2967         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2968         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2969         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2970         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2971         /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
2972         HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
2973         {
2974                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2975                 .name = "Capture Source",
2976                 .count = 1,
2977                 .info = stac92xx_mux_enum_info,
2978                 .get = stac92xx_mux_enum_get,
2979                 .put = stac92xx_mux_enum_put,
2980         },
2981         {}
2982 };
2983
2984 static struct hda_codec_ops stac9872_patch_ops = {
2985         .build_controls = stac92xx_build_controls,
2986         .build_pcms = stac92xx_build_pcms,
2987         .init = stac92xx_init,
2988         .free = stac92xx_free,
2989 #ifdef SND_HDA_NEEDS_RESUME
2990         .resume = stac92xx_resume,
2991 #endif
2992 };
2993
2994 static int stac9872_vaio_init(struct hda_codec *codec)
2995 {
2996         int err;
2997
2998         err = stac92xx_init(codec);
2999         if (err < 0)
3000                 return err;
3001         if (codec->patch_ops.unsol_event)
3002                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3003         return 0;
3004 }
3005
3006 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3007 {
3008         if (get_pin_presence(codec, 0x0a)) {
3009                 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3010                 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3011         } else {
3012                 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3013                 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3014         }
3015 }
3016
3017 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3018 {
3019         switch (res >> 26) {
3020         case STAC_HP_EVENT:
3021                 stac9872_vaio_hp_detect(codec, res);
3022                 break;
3023         }
3024 }
3025
3026 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3027         .build_controls = stac92xx_build_controls,
3028         .build_pcms = stac92xx_build_pcms,
3029         .init = stac9872_vaio_init,
3030         .free = stac92xx_free,
3031         .unsol_event = stac9872_vaio_unsol_event,
3032 #ifdef CONFIG_PM
3033         .resume = stac92xx_resume,
3034 #endif
3035 };
3036
3037 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3038        CXD9872RD_VAIO,
3039        /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3040        STAC9872AK_VAIO,
3041        /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3042        STAC9872K_VAIO,
3043        /* AR Series. id=0x83847664 and subsys=104D1300 */
3044        CXD9872AKD_VAIO,
3045        STAC_9872_MODELS,
3046 };
3047
3048 static const char *stac9872_models[STAC_9872_MODELS] = {
3049         [CXD9872RD_VAIO]        = "vaio",
3050         [CXD9872AKD_VAIO]       = "vaio-ar",
3051 };
3052
3053 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3054         SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3055         SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3056         SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3057         SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3058         {}
3059 };
3060
3061 static int patch_stac9872(struct hda_codec *codec)
3062 {
3063         struct sigmatel_spec *spec;
3064         int board_config;
3065
3066         board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3067                                                   stac9872_models,
3068                                                   stac9872_cfg_tbl);
3069         if (board_config < 0)
3070                 /* unknown config, let generic-parser do its job... */
3071                 return snd_hda_parse_generic_codec(codec);
3072
3073         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3074         if (spec == NULL)
3075                 return -ENOMEM;
3076
3077         codec->spec = spec;
3078         switch (board_config) {
3079         case CXD9872RD_VAIO:
3080         case STAC9872AK_VAIO:
3081         case STAC9872K_VAIO:
3082                 spec->mixer = vaio_mixer;
3083                 spec->init = vaio_init;
3084                 spec->multiout.max_channels = 2;
3085                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3086                 spec->multiout.dac_nids = vaio_dacs;
3087                 spec->multiout.hp_nid = VAIO_HP_DAC;
3088                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3089                 spec->adc_nids = vaio_adcs;
3090                 spec->input_mux = &vaio_mux;
3091                 spec->mux_nids = vaio_mux_nids;
3092                 codec->patch_ops = stac9872_vaio_patch_ops;
3093                 break;
3094
3095         case CXD9872AKD_VAIO:
3096                 spec->mixer = vaio_ar_mixer;
3097                 spec->init = vaio_ar_init;
3098                 spec->multiout.max_channels = 2;
3099                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3100                 spec->multiout.dac_nids = vaio_dacs;
3101                 spec->multiout.hp_nid = VAIO_HP_DAC;
3102                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3103                 spec->adc_nids = vaio_adcs;
3104                 spec->input_mux = &vaio_mux;
3105                 spec->mux_nids = vaio_mux_nids;
3106                 codec->patch_ops = stac9872_patch_ops;
3107                 break;
3108         }
3109
3110         return 0;
3111 }
3112
3113
3114 /*
3115  * patch entries
3116  */
3117 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3118         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3119         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3120         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3121         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3122         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3123         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3124         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3125         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3126         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3127         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3128         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3129         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3130         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3131         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3132         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3133         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3134         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3135         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3136         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3137         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3138         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3139         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3140         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3141         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
3142         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3143         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3144         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3145         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3146         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3147         /* The following does not take into account .id=0x83847661 when subsys =
3148          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3149          * currently not fully supported.
3150          */
3151         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3152         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3153         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3154         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3155         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3156         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3157         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3158         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3159         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3160         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3161         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3162         {} /* terminator */
3163 };