git.oblomov.eu Git - linux-2.6/blob - 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 <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/slab.h>
  30 #include <linux/pci.h>
  31 #include <sound/core.h>
  32 #include <sound/asoundef.h>
  33 #include "hda_codec.h"
  34 #include "hda_local.h"
  35
  36 #define NUM_CONTROL_ALLOC       32
  37 #define STAC_PWR_EVENT          0x20
  38 #define STAC_HP_EVENT           0x30
  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_92HD73XX_REF,
  66         STAC_92HD73XX_MODELS
  67 };
  68
  69 enum {
  70         STAC_92HD71BXX_REF,
  71         STAC_92HD71BXX_MODELS
  72 };
  73
  74 enum {
  75         STAC_925x_REF,
  76         STAC_M2_2,
  77         STAC_MA6,
  78         STAC_PA6,
  79         STAC_925x_MODELS
  80 };
  81
  82 enum {
  83         STAC_D945_REF,
  84         STAC_D945GTP3,
  85         STAC_D945GTP5,
  86         STAC_INTEL_MAC_V1,
  87         STAC_INTEL_MAC_V2,
  88         STAC_INTEL_MAC_V3,
  89         STAC_INTEL_MAC_V4,
  90         STAC_INTEL_MAC_V5,
  91         /* for backward compatibility */
  92         STAC_MACMINI,
  93         STAC_MACBOOK,
  94         STAC_MACBOOK_PRO_V1,
  95         STAC_MACBOOK_PRO_V2,
  96         STAC_IMAC_INTEL,
  97         STAC_IMAC_INTEL_20,
  98         STAC_922X_DELL_D81,
  99         STAC_922X_DELL_D82,
 100         STAC_922X_DELL_M81,
 101         STAC_922X_DELL_M82,
 102         STAC_922X_MODELS
 103 };
 104
 105 enum {
 106         STAC_D965_REF,
 107         STAC_D965_3ST,
 108         STAC_D965_5ST,
 109         STAC_DELL_3ST,
 110         STAC_DELL_BIOS,
 111         STAC_927X_MODELS
 112 };
 113
 114 struct sigmatel_spec {
 115         struct snd_kcontrol_new *mixers[4];
 116         unsigned int num_mixers;
 117
 118         int board_config;
 119         unsigned int surr_switch: 1;
 120         unsigned int line_switch: 1;
 121         unsigned int mic_switch: 1;
 122         unsigned int alt_switch: 1;
 123         unsigned int hp_detect: 1;
 124
 125         /* gpio lines */
 126         unsigned int gpio_mask;
 127         unsigned int gpio_dir;
 128         unsigned int gpio_data;
 129         unsigned int gpio_mute;
 130
 131         /* analog loopback */
 132         unsigned char aloopback_mask;
 133         unsigned char aloopback_shift;
 134
 135         /* power management */
 136         unsigned int num_pwrs;
 137         hda_nid_t *pwr_nids;
 138
 139         /* playback */
 140         struct hda_input_mux *mono_mux;
 141         unsigned int cur_mmux;
 142         struct hda_multi_out multiout;
 143         hda_nid_t dac_nids[5];
 144
 145         /* capture */
 146         hda_nid_t *adc_nids;
 147         unsigned int num_adcs;
 148         hda_nid_t *mux_nids;
 149         unsigned int num_muxes;
 150         hda_nid_t *dmic_nids;
 151         unsigned int num_dmics;
 152         hda_nid_t *dmux_nids;
 153         unsigned int num_dmuxes;
 154         hda_nid_t dig_in_nid;
 155         hda_nid_t mono_nid;
 156
 157         /* pin widgets */
 158         hda_nid_t *pin_nids;
 159         unsigned int num_pins;
 160         unsigned int *pin_configs;
 161         unsigned int *bios_pin_configs;
 162
 163         /* codec specific stuff */
 164         struct hda_verb *init;
 165         struct snd_kcontrol_new *mixer;
 166
 167         /* capture source */
 168         struct hda_input_mux *dinput_mux;
 169         unsigned int cur_dmux[2];
 170         struct hda_input_mux *input_mux;
 171         unsigned int cur_mux[3];
 172
 173         /* i/o switches */
 174         unsigned int io_switch[2];
 175         unsigned int clfe_swap;
 176         unsigned int aloopback;
 177
 178         struct hda_pcm pcm_rec[2];      /* PCM information */
 179
 180         /* dynamic controls and input_mux */
 181         struct auto_pin_cfg autocfg;
 182         unsigned int num_kctl_alloc, num_kctl_used;
 183         struct snd_kcontrol_new *kctl_alloc;
 184         struct hda_input_mux private_dimux;
 185         struct hda_input_mux private_imux;
 186         struct hda_input_mux private_mono_mux;
 187
 188         /* virtual master */
 189         unsigned int vmaster_tlv[4];
 190 };
 191
 192 static hda_nid_t stac9200_adc_nids[1] = {
 193         0x03,
 194 };
 195
 196 static hda_nid_t stac9200_mux_nids[1] = {
 197         0x0c,
 198 };
 199
 200 static hda_nid_t stac9200_dac_nids[1] = {
 201         0x02,
 202 };
 203
 204 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
 205         0x0a, 0x0b, 0x0c, 0xd, 0x0e,
 206         0x0f, 0x10, 0x11
 207 };
 208
 209 static hda_nid_t stac92hd73xx_adc_nids[2] = {
 210         0x1a, 0x1b
 211 };
 212
 213 #define STAC92HD73XX_NUM_DMICS  2
 214 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
 215         0x13, 0x14, 0
 216 };
 217
 218 #define STAC92HD73_DAC_COUNT 5
 219 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
 220         0x15, 0x16, 0x17, 0x18, 0x19,
 221 };
 222
 223 static hda_nid_t stac92hd73xx_mux_nids[4] = {
 224         0x28, 0x29, 0x2a, 0x2b,
 225 };
 226
 227 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
 228         0x20, 0x21,
 229 };
 230
 231 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
 232         0x0a, 0x0d, 0x0f
 233 };
 234
 235 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
 236         0x12, 0x13,
 237 };
 238
 239 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
 240         0x1a, 0x1b
 241 };
 242
 243 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
 244         0x1c,
 245 };
 246
 247 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
 248         0x10, /*0x11, */
 249 };
 250
 251 #define STAC92HD71BXX_NUM_DMICS 2
 252 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
 253         0x18, 0x19, 0
 254 };
 255
 256 static hda_nid_t stac925x_adc_nids[1] = {
 257         0x03,
 258 };
 259
 260 static hda_nid_t stac925x_mux_nids[1] = {
 261         0x0f,
 262 };
 263
 264 static hda_nid_t stac925x_dac_nids[1] = {
 265         0x02,
 266 };
 267
 268 #define STAC925X_NUM_DMICS      1
 269 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
 270         0x15, 0
 271 };
 272
 273 static hda_nid_t stac925x_dmux_nids[1] = {
 274         0x14,
 275 };
 276
 277 static hda_nid_t stac922x_adc_nids[2] = {
 278         0x06, 0x07,
 279 };
 280
 281 static hda_nid_t stac922x_mux_nids[2] = {
 282         0x12, 0x13,
 283 };
 284
 285 static hda_nid_t stac927x_adc_nids[3] = {
 286         0x07, 0x08, 0x09
 287 };
 288
 289 static hda_nid_t stac927x_mux_nids[3] = {
 290         0x15, 0x16, 0x17
 291 };
 292
 293 static hda_nid_t stac927x_dmux_nids[1] = {
 294         0x1b,
 295 };
 296
 297 #define STAC927X_NUM_DMICS 2
 298 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
 299         0x13, 0x14, 0
 300 };
 301
 302 static hda_nid_t stac9205_adc_nids[2] = {
 303         0x12, 0x13
 304 };
 305
 306 static hda_nid_t stac9205_mux_nids[2] = {
 307         0x19, 0x1a
 308 };
 309
 310 static hda_nid_t stac9205_dmux_nids[1] = {
 311         0x1d,
 312 };
 313
 314 #define STAC9205_NUM_DMICS      2
 315 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
 316         0x17, 0x18, 0
 317 };
 318
 319 static hda_nid_t stac9200_pin_nids[8] = {
 320         0x08, 0x09, 0x0d, 0x0e,
 321         0x0f, 0x10, 0x11, 0x12,
 322 };
 323
 324 static hda_nid_t stac925x_pin_nids[8] = {
 325         0x07, 0x08, 0x0a, 0x0b,
 326         0x0c, 0x0d, 0x10, 0x11,
 327 };
 328
 329 static hda_nid_t stac922x_pin_nids[10] = {
 330         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 331         0x0f, 0x10, 0x11, 0x15, 0x1b,
 332 };
 333
 334 static hda_nid_t stac92hd73xx_pin_nids[12] = {
 335         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 336         0x0f, 0x10, 0x11, 0x12, 0x13,
 337         0x14, 0x22
 338 };
 339
 340 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
 341         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 342         0x0f, 0x14, 0x18, 0x19, 0x1e,
 343 };
 344
 345 static hda_nid_t stac927x_pin_nids[14] = {
 346         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 347         0x0f, 0x10, 0x11, 0x12, 0x13,
 348         0x14, 0x21, 0x22, 0x23,
 349 };
 350
 351 static hda_nid_t stac9205_pin_nids[12] = {
 352         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 353         0x0f, 0x14, 0x16, 0x17, 0x18,
 354         0x21, 0x22,
 355 };
 356
 357 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
 358                                    struct snd_ctl_elem_info *uinfo)
 359 {
 360         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 361         struct sigmatel_spec *spec = codec->spec;
 362         return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
 363 }
 364
 365 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
 366                                   struct snd_ctl_elem_value *ucontrol)
 367 {
 368         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 369         struct sigmatel_spec *spec = codec->spec;
 370         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 371
 372         ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
 373         return 0;
 374 }
 375
 376 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
 377                                   struct snd_ctl_elem_value *ucontrol)
 378 {
 379         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 380         struct sigmatel_spec *spec = codec->spec;
 381         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 382
 383         return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
 384                         spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
 385 }
 386
 387 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 388 {
 389         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 390         struct sigmatel_spec *spec = codec->spec;
 391         return snd_hda_input_mux_info(spec->input_mux, uinfo);
 392 }
 393
 394 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 395 {
 396         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 397         struct sigmatel_spec *spec = codec->spec;
 398         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 399
 400         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 401         return 0;
 402 }
 403
 404 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 405 {
 406         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 407         struct sigmatel_spec *spec = codec->spec;
 408         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 409
 410         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 411                                      spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
 412 }
 413
 414 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
 415         struct snd_ctl_elem_info *uinfo)
 416 {
 417         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 418         struct sigmatel_spec *spec = codec->spec;
 419         return snd_hda_input_mux_info(spec->mono_mux, uinfo);
 420 }
 421
 422 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
 423         struct snd_ctl_elem_value *ucontrol)
 424 {
 425         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 426         struct sigmatel_spec *spec = codec->spec;
 427
 428         ucontrol->value.enumerated.item[0] = spec->cur_mmux;
 429         return 0;
 430 }
 431
 432 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
 433         struct snd_ctl_elem_value *ucontrol)
 434 {
 435         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 436         struct sigmatel_spec *spec = codec->spec;
 437
 438         return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
 439                                      spec->mono_nid, &spec->cur_mmux);
 440 }
 441
 442 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
 443
 444 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
 445         struct snd_ctl_elem_value *ucontrol)
 446 {
 447         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 448         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 449         struct sigmatel_spec *spec = codec->spec;
 450
 451         ucontrol->value.integer.value[0] = !!(spec->aloopback &
 452                                               (spec->aloopback_mask << idx));
 453         return 0;
 454 }
 455
 456 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
 457                 struct snd_ctl_elem_value *ucontrol)
 458 {
 459         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 460         struct sigmatel_spec *spec = codec->spec;
 461         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 462         unsigned int dac_mode;
 463         unsigned int val, idx_val;
 464
 465         idx_val = spec->aloopback_mask << idx;
 466         if (ucontrol->value.integer.value[0])
 467                 val = spec->aloopback | idx_val;
 468         else
 469                 val = spec->aloopback & ~idx_val;
 470         if (spec->aloopback == val)
 471                 return 0;
 472
 473         spec->aloopback = val;
 474
 475         /* Only return the bits defined by the shift value of the
 476          * first two bytes of the mask
 477          */
 478         dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
 479                                       kcontrol->private_value & 0xFFFF, 0x0);
 480         dac_mode >>= spec->aloopback_shift;
 481
 482         if (spec->aloopback & idx_val) {
 483                 snd_hda_power_up(codec);
 484                 dac_mode |= idx_val;
 485         } else {
 486                 snd_hda_power_down(codec);
 487                 dac_mode &= ~idx_val;
 488         }
 489
 490         snd_hda_codec_write_cache(codec, codec->afg, 0,
 491                 kcontrol->private_value >> 16, dac_mode);
 492
 493         return 1;
 494 }
 495
 496 static struct hda_verb stac9200_core_init[] = {
 497         /* set dac0mux for dac converter */
 498         { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 499         {}
 500 };
 501
 502 static struct hda_verb stac9200_eapd_init[] = {
 503         /* set dac0mux for dac converter */
 504         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 505         {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 506         {}
 507 };
 508
 509 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
 510         /* set master volume and direct control */
 511         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 512         /* setup audio connections */
 513         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
 514         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
 515         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
 516         /* setup adcs to point to mixer */
 517         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 518         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 519         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 520         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 521         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 522         /* setup import muxs */
 523         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 524         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 525         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 526         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
 527         {}
 528 };
 529
 530 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
 531         /* set master volume and direct control */
 532         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 533         /* setup audio connections */
 534         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
 535         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
 536         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
 537         /* connect hp ports to dac3 */
 538         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
 539         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
 540         /* setup adcs to point to mixer */
 541         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 542         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 543         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 544         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 545         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 546         /* setup import muxs */
 547         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 548         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 549         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 550         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
 551         {}
 552 };
 553
 554 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
 555         /* set master volume and direct control */
 556         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 557         /* setup audio connections */
 558         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
 559         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
 560         { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
 561         /* dac3 is connected to import3 mux */
 562         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
 563         /* connect hp ports to dac4 */
 564         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
 565         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
 566         /* setup adcs to point to mixer */
 567         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 568         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 569         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 570         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 571         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 572         /* setup import muxs */
 573         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 574         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 575         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 576         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
 577         {}
 578 };
 579
 580 static struct hda_verb stac92hd71bxx_core_init[] = {
 581         /* set master volume and direct control */
 582         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 583         /* connect headphone jack to dac1 */
 584         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
 585         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
 586         /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
 587         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 588         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 589         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 590 };
 591
 592 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
 593         /* set master volume and direct control */
 594         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 595         /* connect headphone jack to dac1 */
 596         { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
 597         /* connect ports 0d and 0f to audio mixer */
 598         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
 599         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
 600         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
 601         /* unmute dac0 input in audio mixer */
 602         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
 603         /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
 604         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 605         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 606         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 607         {}
 608 };
 609
 610 static struct hda_verb stac925x_core_init[] = {
 611         /* set dac0mux for dac converter */
 612         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
 613         {}
 614 };
 615
 616 static struct hda_verb stac922x_core_init[] = {
 617         /* set master volume and direct control */
 618         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 619         {}
 620 };
 621
 622 static struct hda_verb d965_core_init[] = {
 623         /* set master volume and direct control */
 624         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 625         /* unmute node 0x1b */
 626         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 627         /* select node 0x03 as DAC */
 628         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 629         {}
 630 };
 631
 632 static struct hda_verb stac927x_core_init[] = {
 633         /* set master volume and direct control */
 634         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 635         {}
 636 };
 637
 638 static struct hda_verb stac9205_core_init[] = {
 639         /* set master volume and direct control */
 640         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 641         {}
 642 };
 643
 644 #define STAC_MONO_MUX \
 645         { \
 646                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 647                 .name = "Mono Mux", \
 648                 .count = 1, \
 649                 .info = stac92xx_mono_mux_enum_info, \
 650                 .get = stac92xx_mono_mux_enum_get, \
 651                 .put = stac92xx_mono_mux_enum_put, \
 652         }
 653
 654 #define STAC_INPUT_SOURCE(cnt) \
 655         { \
 656                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 657                 .name = "Input Source", \
 658                 .count = cnt, \
 659                 .info = stac92xx_mux_enum_info, \
 660                 .get = stac92xx_mux_enum_get, \
 661                 .put = stac92xx_mux_enum_put, \
 662         }
 663
 664 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
 665         { \
 666                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 667                 .name  = "Analog Loopback", \
 668                 .count = cnt, \
 669                 .info  = stac92xx_aloopback_info, \
 670                 .get   = stac92xx_aloopback_get, \
 671                 .put   = stac92xx_aloopback_put, \
 672                 .private_value = verb_read | (verb_write << 16), \
 673         }
 674
 675 static struct snd_kcontrol_new stac9200_mixer[] = {
 676         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
 677         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
 678         STAC_INPUT_SOURCE(1),
 679         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
 680         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
 681         HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
 682         { } /* end */
 683 };
 684
 685 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
 686         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
 687
 688         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
 689         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 690
 691         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
 692         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
 693
 694         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
 695         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
 696
 697         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
 698         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
 699
 700         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
 701         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
 702
 703         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
 704         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
 705
 706         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
 707         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
 708         { } /* end */
 709 };
 710
 711 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
 712         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
 713
 714         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
 715         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 716
 717         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
 718         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
 719
 720         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
 721         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
 722
 723         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
 724         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
 725
 726         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
 727         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
 728
 729         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
 730         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
 731
 732         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
 733         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
 734         { } /* end */
 735 };
 736
 737 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
 738         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
 739
 740         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
 741         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 742
 743         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
 744         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
 745
 746         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
 747         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
 748
 749         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
 750         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
 751
 752         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
 753         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
 754
 755         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
 756         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
 757
 758         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
 759         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
 760         { } /* end */
 761 };
 762
 763 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
 764         STAC_INPUT_SOURCE(2),
 765
 766         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 767         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 768         HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
 769
 770         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
 771         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
 772         HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
 773
 774         HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
 775         HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
 776         { } /* end */
 777 };
 778
 779 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
 780         STAC_INPUT_SOURCE(2),
 781         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
 782
 783         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 784         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 785         HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
 786
 787         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
 788         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
 789         HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
 790         { } /* end */
 791 };
 792
 793 static struct snd_kcontrol_new stac925x_mixer[] = {
 794         STAC_INPUT_SOURCE(1),
 795         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
 796         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
 797         HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
 798         { } /* end */
 799 };
 800
 801 static struct snd_kcontrol_new stac9205_mixer[] = {
 802         STAC_INPUT_SOURCE(2),
 803         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
 804
 805         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
 806         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
 807         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
 808
 809         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
 810         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
 811         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
 812
 813         { } /* end */
 814 };
 815
 816 /* This needs to be generated dynamically based on sequence */
 817 static struct snd_kcontrol_new stac922x_mixer[] = {
 818         STAC_INPUT_SOURCE(2),
 819         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
 820         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
 821         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
 822
 823         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
 824         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
 825         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
 826         { } /* end */
 827 };
 828
 829
 830 static struct snd_kcontrol_new stac927x_mixer[] = {
 831         STAC_INPUT_SOURCE(3),
 832         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
 833
 834         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
 835         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
 836         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
 837
 838         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
 839         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
 840         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
 841
 842         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
 843         HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
 844         HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
 845         { } /* end */
 846 };
 847
 848 static struct snd_kcontrol_new stac_dmux_mixer = {
 849         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 850         .name = "Digital Input Source",
 851         /* count set later */
 852         .info = stac92xx_dmux_enum_info,
 853         .get = stac92xx_dmux_enum_get,
 854         .put = stac92xx_dmux_enum_put,
 855 };
 856
 857 static const char *slave_vols[] = {
 858         "Front Playback Volume",
 859         "Surround Playback Volume",
 860         "Center Playback Volume",
 861         "LFE Playback Volume",
 862         "Side Playback Volume",
 863         "Headphone Playback Volume",
 864         "Headphone Playback Volume",
 865         "Speaker Playback Volume",
 866         "External Speaker Playback Volume",
 867         "Speaker2 Playback Volume",
 868         NULL
 869 };
 870
 871 static const char *slave_sws[] = {
 872         "Front Playback Switch",
 873         "Surround Playback Switch",
 874         "Center Playback Switch",
 875         "LFE Playback Switch",
 876         "Side Playback Switch",
 877         "Headphone Playback Switch",
 878         "Headphone Playback Switch",
 879         "Speaker Playback Switch",
 880         "External Speaker Playback Switch",
 881         "Speaker2 Playback Switch",
 882         "IEC958 Playback Switch",
 883         NULL
 884 };
 885
 886 static int stac92xx_build_controls(struct hda_codec *codec)
 887 {
 888         struct sigmatel_spec *spec = codec->spec;
 889         int err;
 890         int i;
 891
 892         err = snd_hda_add_new_ctls(codec, spec->mixer);
 893         if (err < 0)
 894                 return err;
 895
 896         for (i = 0; i < spec->num_mixers; i++) {
 897                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 898                 if (err < 0)
 899                         return err;
 900         }
 901         if (spec->num_dmuxes > 0) {
 902                 stac_dmux_mixer.count = spec->num_dmuxes;
 903                 err = snd_ctl_add(codec->bus->card,
 904                                   snd_ctl_new1(&stac_dmux_mixer, codec));
 905                 if (err < 0)
 906                         return err;
 907         }
 908
 909         if (spec->multiout.dig_out_nid) {
 910                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 911                 if (err < 0)
 912                         return err;
 913         }
 914         if (spec->dig_in_nid) {
 915                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 916                 if (err < 0)
 917                         return err;
 918         }
 919
 920         /* if we have no master control, let's create it */
 921         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
 922                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
 923                                         HDA_OUTPUT, spec->vmaster_tlv);
 924                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
 925                                           spec->vmaster_tlv, slave_vols);
 926                 if (err < 0)
 927                         return err;
 928         }
 929         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
 930                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
 931                                           NULL, slave_sws);
 932                 if (err < 0)
 933                         return err;
 934         }
 935
 936         return 0;
 937 }
 938
 939 static unsigned int ref9200_pin_configs[8] = {
 940         0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
 941         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
 942 };
 943
 944 /*
 945     STAC 9200 pin configs for
 946     102801A8
 947     102801DE
 948     102801E8
 949 */
 950 static unsigned int dell9200_d21_pin_configs[8] = {
 951         0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
 952         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
 953 };
 954
 955 /*
 956     STAC 9200 pin configs for
 957     102801C0
 958     102801C1
 959 */
 960 static unsigned int dell9200_d22_pin_configs[8] = {
 961         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
 962         0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
 963 };
 964
 965 /*
 966     STAC 9200 pin configs for
 967     102801C4 (Dell Dimension E310)
 968     102801C5
 969     102801C7
 970     102801D9
 971     102801DA
 972     102801E3
 973 */
 974 static unsigned int dell9200_d23_pin_configs[8] = {
 975         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
 976         0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
 977 };
 978
 979
 980 /*
 981     STAC 9200-32 pin configs for
 982     102801B5 (Dell Inspiron 630m)
 983     102801D8 (Dell Inspiron 640m)
 984 */
 985 static unsigned int dell9200_m21_pin_configs[8] = {
 986         0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
 987         0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
 988 };
 989
 990 /*
 991     STAC 9200-32 pin configs for
 992     102801C2 (Dell Latitude D620)
 993     102801C8
 994     102801CC (Dell Latitude D820)
 995     102801D4
 996     102801D6
 997 */
 998 static unsigned int dell9200_m22_pin_configs[8] = {
 999         0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1000         0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1001 };
1002
1003 /*
1004     STAC 9200-32 pin configs for
1005     102801CE (Dell XPS M1710)
1006     102801CF (Dell Precision M90)
1007 */
1008 static unsigned int dell9200_m23_pin_configs[8] = {
1009         0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1010         0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1011 };
1012
1013 /*
1014     STAC 9200-32 pin configs for
1015     102801C9
1016     102801CA
1017     102801CB (Dell Latitude 120L)
1018     102801D3
1019 */
1020 static unsigned int dell9200_m24_pin_configs[8] = {
1021         0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1022         0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1023 };
1024
1025 /*
1026     STAC 9200-32 pin configs for
1027     102801BD (Dell Inspiron E1505n)
1028     102801EE
1029     102801EF
1030 */
1031 static unsigned int dell9200_m25_pin_configs[8] = {
1032         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1033         0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1034 };
1035
1036 /*
1037     STAC 9200-32 pin configs for
1038     102801F5 (Dell Inspiron 1501)
1039     102801F6
1040 */
1041 static unsigned int dell9200_m26_pin_configs[8] = {
1042         0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1043         0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1044 };
1045
1046 /*
1047     STAC 9200-32
1048     102801CD (Dell Inspiron E1705/9400)
1049 */
1050 static unsigned int dell9200_m27_pin_configs[8] = {
1051         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1052         0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1053 };
1054
1055
1056 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1057         [STAC_REF] = ref9200_pin_configs,
1058         [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1059         [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1060         [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1061         [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1062         [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1063         [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1064         [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1065         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1066         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1067         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1068 };
1069
1070 static const char *stac9200_models[STAC_9200_MODELS] = {
1071         [STAC_REF] = "ref",
1072         [STAC_9200_DELL_D21] = "dell-d21",
1073         [STAC_9200_DELL_D22] = "dell-d22",
1074         [STAC_9200_DELL_D23] = "dell-d23",
1075         [STAC_9200_DELL_M21] = "dell-m21",
1076         [STAC_9200_DELL_M22] = "dell-m22",
1077         [STAC_9200_DELL_M23] = "dell-m23",
1078         [STAC_9200_DELL_M24] = "dell-m24",
1079         [STAC_9200_DELL_M25] = "dell-m25",
1080         [STAC_9200_DELL_M26] = "dell-m26",
1081         [STAC_9200_DELL_M27] = "dell-m27",
1082         [STAC_9200_GATEWAY] = "gateway",
1083 };
1084
1085 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1086         /* SigmaTel reference board */
1087         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1088                       "DFI LanParty", STAC_REF),
1089         /* Dell laptops have BIOS problem */
1090         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1091                       "unknown Dell", STAC_9200_DELL_D21),
1092         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1093                       "Dell Inspiron 630m", STAC_9200_DELL_M21),
1094         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1095                       "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1096         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1097                       "unknown Dell", STAC_9200_DELL_D22),
1098         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1099                       "unknown Dell", STAC_9200_DELL_D22),
1100         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1101                       "Dell Latitude D620", STAC_9200_DELL_M22),
1102         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1103                       "unknown Dell", STAC_9200_DELL_D23),
1104         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1105                       "unknown Dell", STAC_9200_DELL_D23),
1106         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1107                       "unknown Dell", STAC_9200_DELL_M22),
1108         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1109                       "unknown Dell", STAC_9200_DELL_M24),
1110         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1111                       "unknown Dell", STAC_9200_DELL_M24),
1112         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1113                       "Dell Latitude 120L", STAC_9200_DELL_M24),
1114         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1115                       "Dell Latitude D820", STAC_9200_DELL_M22),
1116         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1117                       "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1118         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1119                       "Dell XPS M1710", STAC_9200_DELL_M23),
1120         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1121                       "Dell Precision M90", STAC_9200_DELL_M23),
1122         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1123                       "unknown Dell", STAC_9200_DELL_M22),
1124         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1125                       "unknown Dell", STAC_9200_DELL_M22),
1126         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1127                       "unknown Dell", STAC_9200_DELL_M22),
1128         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1129                       "Dell Inspiron 640m", STAC_9200_DELL_M21),
1130         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1131                       "unknown Dell", STAC_9200_DELL_D23),
1132         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1133                       "unknown Dell", STAC_9200_DELL_D23),
1134         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1135                       "unknown Dell", STAC_9200_DELL_D21),
1136         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1137                       "unknown Dell", STAC_9200_DELL_D23),
1138         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1139                       "unknown Dell", STAC_9200_DELL_D21),
1140         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1141                       "unknown Dell", STAC_9200_DELL_M25),
1142         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1143                       "unknown Dell", STAC_9200_DELL_M25),
1144         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1145                       "Dell Inspiron 1501", STAC_9200_DELL_M26),
1146         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1147                       "unknown Dell", STAC_9200_DELL_M26),
1148         /* Panasonic */
1149         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1150         /* Gateway machines needs EAPD to be set on resume */
1151         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1152         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1153                       STAC_9200_GATEWAY),
1154         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1155                       STAC_9200_GATEWAY),
1156         {} /* terminator */
1157 };
1158
1159 static unsigned int ref925x_pin_configs[8] = {
1160         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1161         0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1162 };
1163
1164 static unsigned int stac925x_MA6_pin_configs[8] = {
1165         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1166         0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1167 };
1168
1169 static unsigned int stac925x_PA6_pin_configs[8] = {
1170         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1171         0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1172 };
1173
1174 static unsigned int stac925xM2_2_pin_configs[8] = {
1175         0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1176         0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1177 };
1178
1179 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1180         [STAC_REF] = ref925x_pin_configs,
1181         [STAC_M2_2] = stac925xM2_2_pin_configs,
1182         [STAC_MA6] = stac925x_MA6_pin_configs,
1183         [STAC_PA6] = stac925x_PA6_pin_configs,
1184 };
1185
1186 static const char *stac925x_models[STAC_925x_MODELS] = {
1187         [STAC_REF] = "ref",
1188         [STAC_M2_2] = "m2-2",
1189         [STAC_MA6] = "m6",
1190         [STAC_PA6] = "pa6",
1191 };
1192
1193 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1194         /* SigmaTel reference board */
1195         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1196         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1197         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1198         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1199         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1200         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1201         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1202         {} /* terminator */
1203 };
1204
1205 static unsigned int ref92hd73xx_pin_configs[12] = {
1206         0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1207         0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1208         0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1209 };
1210
1211 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1212         [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1213 };
1214
1215 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1216         [STAC_92HD73XX_REF] = "ref",
1217 };
1218
1219 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1220         /* SigmaTel reference board */
1221         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1222                       "DFI LanParty", STAC_92HD73XX_REF),
1223         {} /* terminator */
1224 };
1225
1226 static unsigned int ref92hd71bxx_pin_configs[10] = {
1227         0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1228         0x0181302e, 0x01114010, 0x01019020, 0x90a000f0,
1229         0x90a000f0, 0x01452050,
1230 };
1231
1232 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1233         [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1234 };
1235
1236 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1237         [STAC_92HD71BXX_REF] = "ref",
1238 };
1239
1240 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1241         /* SigmaTel reference board */
1242         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1243                       "DFI LanParty", STAC_92HD71BXX_REF),
1244         {} /* terminator */
1245 };
1246
1247 static unsigned int ref922x_pin_configs[10] = {
1248         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1249         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1250         0x40000100, 0x40000100,
1251 };
1252
1253 /*
1254     STAC 922X pin configs for
1255     102801A7
1256     102801AB
1257     102801A9
1258     102801D1
1259     102801D2
1260 */
1261 static unsigned int dell_922x_d81_pin_configs[10] = {
1262         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1263         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1264         0x01813122, 0x400001f2,
1265 };
1266
1267 /*
1268     STAC 922X pin configs for
1269     102801AC
1270     102801D0
1271 */
1272 static unsigned int dell_922x_d82_pin_configs[10] = {
1273         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1274         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1275         0x01813122, 0x400001f1,
1276 };
1277
1278 /*
1279     STAC 922X pin configs for
1280     102801BF
1281 */
1282 static unsigned int dell_922x_m81_pin_configs[10] = {
1283         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1284         0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1285         0x40C003f1, 0x405003f0,
1286 };
1287
1288 /*
1289     STAC 9221 A1 pin configs for
1290     102801D7 (Dell XPS M1210)
1291 */
1292 static unsigned int dell_922x_m82_pin_configs[10] = {
1293         0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1294         0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1295         0x508003f3, 0x405003f4,
1296 };
1297
1298 static unsigned int d945gtp3_pin_configs[10] = {
1299         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1300         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1301         0x02a19120, 0x40000100,
1302 };
1303
1304 static unsigned int d945gtp5_pin_configs[10] = {
1305         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1306         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1307         0x02a19320, 0x40000100,
1308 };
1309
1310 static unsigned int intel_mac_v1_pin_configs[10] = {
1311         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1312         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1313         0x400000fc, 0x400000fb,
1314 };
1315
1316 static unsigned int intel_mac_v2_pin_configs[10] = {
1317         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1318         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1319         0x400000fc, 0x400000fb,
1320 };
1321
1322 static unsigned int intel_mac_v3_pin_configs[10] = {
1323         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1324         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1325         0x400000fc, 0x400000fb,
1326 };
1327
1328 static unsigned int intel_mac_v4_pin_configs[10] = {
1329         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1330         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1331         0x400000fc, 0x400000fb,
1332 };
1333
1334 static unsigned int intel_mac_v5_pin_configs[10] = {
1335         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1336         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1337         0x400000fc, 0x400000fb,
1338 };
1339
1340
1341 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1342         [STAC_D945_REF] = ref922x_pin_configs,
1343         [STAC_D945GTP3] = d945gtp3_pin_configs,
1344         [STAC_D945GTP5] = d945gtp5_pin_configs,
1345         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1346         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1347         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1348         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1349         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1350         /* for backward compatibility */
1351         [STAC_MACMINI] = intel_mac_v3_pin_configs,
1352         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1353         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1354         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1355         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1356         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1357         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1358         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1359         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1360         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1361 };
1362
1363 static const char *stac922x_models[STAC_922X_MODELS] = {
1364         [STAC_D945_REF] = "ref",
1365         [STAC_D945GTP5] = "5stack",
1366         [STAC_D945GTP3] = "3stack",
1367         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1368         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1369         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1370         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1371         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1372         /* for backward compatibility */
1373         [STAC_MACMINI]  = "macmini",
1374         [STAC_MACBOOK]  = "macbook",
1375         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1376         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1377         [STAC_IMAC_INTEL] = "imac-intel",
1378         [STAC_IMAC_INTEL_20] = "imac-intel-20",
1379         [STAC_922X_DELL_D81] = "dell-d81",
1380         [STAC_922X_DELL_D82] = "dell-d82",
1381         [STAC_922X_DELL_M81] = "dell-m81",
1382         [STAC_922X_DELL_M82] = "dell-m82",
1383 };
1384
1385 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1386         /* SigmaTel reference board */
1387         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1388                       "DFI LanParty", STAC_D945_REF),
1389         /* Intel 945G based systems */
1390         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1391                       "Intel D945G", STAC_D945GTP3),
1392         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1393                       "Intel D945G", STAC_D945GTP3),
1394         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1395                       "Intel D945G", STAC_D945GTP3),
1396         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1397                       "Intel D945G", STAC_D945GTP3),
1398         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1399                       "Intel D945G", STAC_D945GTP3),
1400         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1401                       "Intel D945G", STAC_D945GTP3),
1402         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1403                       "Intel D945G", STAC_D945GTP3),
1404         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1405                       "Intel D945G", STAC_D945GTP3),
1406         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1407                       "Intel D945G", STAC_D945GTP3),
1408         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1409                       "Intel D945G", STAC_D945GTP3),
1410         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1411                       "Intel D945G", STAC_D945GTP3),
1412         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1413                       "Intel D945G", STAC_D945GTP3),
1414         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1415                       "Intel D945G", STAC_D945GTP3),
1416         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1417                       "Intel D945G", STAC_D945GTP3),
1418         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1419                       "Intel D945G", STAC_D945GTP3),
1420         /* Intel D945G 5-stack systems */
1421         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1422                       "Intel D945G", STAC_D945GTP5),
1423         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1424                       "Intel D945G", STAC_D945GTP5),
1425         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1426                       "Intel D945G", STAC_D945GTP5),
1427         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1428                       "Intel D945G", STAC_D945GTP5),
1429         /* Intel 945P based systems */
1430         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1431                       "Intel D945P", STAC_D945GTP3),
1432         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1433                       "Intel D945P", STAC_D945GTP3),
1434         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1435                       "Intel D945P", STAC_D945GTP3),
1436         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1437                       "Intel D945P", STAC_D945GTP3),
1438         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1439                       "Intel D945P", STAC_D945GTP3),
1440         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1441                       "Intel D945P", STAC_D945GTP5),
1442         /* other systems  */
1443         /* Apple Mac Mini (early 2006) */
1444         SND_PCI_QUIRK(0x8384, 0x7680,
1445                       "Mac Mini", STAC_INTEL_MAC_V3),
1446         /* Dell systems  */
1447         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1448                       "unknown Dell", STAC_922X_DELL_D81),
1449         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1450                       "unknown Dell", STAC_922X_DELL_D81),
1451         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1452                       "unknown Dell", STAC_922X_DELL_D81),
1453         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1454                       "unknown Dell", STAC_922X_DELL_D82),
1455         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1456                       "unknown Dell", STAC_922X_DELL_M81),
1457         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1458                       "unknown Dell", STAC_922X_DELL_D82),
1459         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1460                       "unknown Dell", STAC_922X_DELL_D81),
1461         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1462                       "unknown Dell", STAC_922X_DELL_D81),
1463         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1464                       "Dell XPS M1210", STAC_922X_DELL_M82),
1465         {} /* terminator */
1466 };
1467
1468 static unsigned int ref927x_pin_configs[14] = {
1469         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1470         0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1471         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1472         0x01c42190, 0x40000100,
1473 };
1474
1475 static unsigned int d965_3st_pin_configs[14] = {
1476         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1477         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1478         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1479         0x40000100, 0x40000100
1480 };
1481
1482 static unsigned int d965_5st_pin_configs[14] = {
1483         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1484         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1485         0x40000100, 0x40000100, 0x40000100, 0x01442070,
1486         0x40000100, 0x40000100
1487 };
1488
1489 static unsigned int dell_3st_pin_configs[14] = {
1490         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1491         0x01111212, 0x01116211, 0x01813050, 0x01112214,
1492         0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1493         0x40c003fc, 0x40000100
1494 };
1495
1496 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1497         [STAC_D965_REF]  = ref927x_pin_configs,
1498         [STAC_D965_3ST]  = d965_3st_pin_configs,
1499         [STAC_D965_5ST]  = d965_5st_pin_configs,
1500         [STAC_DELL_3ST]  = dell_3st_pin_configs,
1501         [STAC_DELL_BIOS] = NULL,
1502 };
1503
1504 static const char *stac927x_models[STAC_927X_MODELS] = {
1505         [STAC_D965_REF]         = "ref",
1506         [STAC_D965_3ST]         = "3stack",
1507         [STAC_D965_5ST]         = "5stack",
1508         [STAC_DELL_3ST]         = "dell-3stack",
1509         [STAC_DELL_BIOS]        = "dell-bios",
1510 };
1511
1512 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1513         /* SigmaTel reference board */
1514         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1515                       "DFI LanParty", STAC_D965_REF),
1516          /* Intel 946 based systems */
1517         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1518         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1519         /* 965 based 3 stack systems */
1520         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1521         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1522         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1523         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1524         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1525         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1526         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1527         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1528         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1529         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1530         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1531         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1532         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1533         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1534         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1535         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1536         /* Dell 3 stack systems */
1537         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1538         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1539         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
1540         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
1541         /* Dell 3 stack systems with verb table in BIOS */
1542         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
1543         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
1544         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell     ", STAC_DELL_BIOS),
1545         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
1546         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
1547         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
1548         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
1549         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1550         /* 965 based 5 stack systems */
1551         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1552         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1553         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1554         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1555         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1556         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1557         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1558         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1559         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1560         {} /* terminator */
1561 };
1562
1563 static unsigned int ref9205_pin_configs[12] = {
1564         0x40000100, 0x40000100, 0x01016011, 0x01014010,
1565         0x01813122, 0x01a19021, 0x01019020, 0x40000100,
1566         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1567 };
1568
1569 /*
1570     STAC 9205 pin configs for
1571     102801F1
1572     102801F2
1573     102801FC
1574     102801FD
1575     10280204
1576     1028021F
1577     10280228 (Dell Vostro 1500)
1578 */
1579 static unsigned int dell_9205_m42_pin_configs[12] = {
1580         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1581         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1582         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1583 };
1584
1585 /*
1586     STAC 9205 pin configs for
1587     102801F9
1588     102801FA
1589     102801FE
1590     102801FF (Dell Precision M4300)
1591     10280206
1592     10280200
1593     10280201
1594 */
1595 static unsigned int dell_9205_m43_pin_configs[12] = {
1596         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1597         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1598         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1599 };
1600
1601 static unsigned int dell_9205_m44_pin_configs[12] = {
1602         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1603         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1604         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1605 };
1606
1607 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1608         [STAC_9205_REF] = ref9205_pin_configs,
1609         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1610         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1611         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1612 };
1613
1614 static const char *stac9205_models[STAC_9205_MODELS] = {
1615         [STAC_9205_REF] = "ref",
1616         [STAC_9205_DELL_M42] = "dell-m42",
1617         [STAC_9205_DELL_M43] = "dell-m43",
1618         [STAC_9205_DELL_M44] = "dell-m44",
1619 };
1620
1621 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1622         /* SigmaTel reference board */
1623         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1624                       "DFI LanParty", STAC_9205_REF),
1625         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1626                       "unknown Dell", STAC_9205_DELL_M42),
1627         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1628                       "unknown Dell", STAC_9205_DELL_M42),
1629         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1630                       "Dell Precision", STAC_9205_DELL_M43),
1631         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1632                           "Dell Precision", STAC_9205_DELL_M43),
1633         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1634                       "Dell Precision", STAC_9205_DELL_M43),
1635         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1636                       "Dell Precision", STAC_9205_DELL_M43),
1637         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1638                       "Dell Precision", STAC_9205_DELL_M43),
1639         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1640                       "unknown Dell", STAC_9205_DELL_M42),
1641         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1642                       "unknown Dell", STAC_9205_DELL_M42),
1643         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1644                       "Dell Precision", STAC_9205_DELL_M43),
1645         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1646                       "Dell Precision M4300", STAC_9205_DELL_M43),
1647         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1648                       "Dell Precision", STAC_9205_DELL_M43),
1649         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1650                       "Dell Inspiron", STAC_9205_DELL_M44),
1651         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1652                       "Dell Inspiron", STAC_9205_DELL_M44),
1653         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1654                       "Dell Inspiron", STAC_9205_DELL_M44),
1655         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1656                       "Dell Inspiron", STAC_9205_DELL_M44),
1657         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1658                       "unknown Dell", STAC_9205_DELL_M42),
1659         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1660                       "Dell Inspiron", STAC_9205_DELL_M44),
1661         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
1662                       "Dell Vostro 1500", STAC_9205_DELL_M42),
1663         {} /* terminator */
1664 };
1665
1666 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1667 {
1668         int i;
1669         struct sigmatel_spec *spec = codec->spec;
1670
1671         if (! spec->bios_pin_configs) {
1672                 spec->bios_pin_configs = kcalloc(spec->num_pins,
1673                                                  sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1674                 if (! spec->bios_pin_configs)
1675                         return -ENOMEM;
1676         }
1677
1678         for (i = 0; i < spec->num_pins; i++) {
1679                 hda_nid_t nid = spec->pin_nids[i];
1680                 unsigned int pin_cfg;
1681
1682                 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1683                         AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1684                 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1685                                         nid, pin_cfg);
1686                 spec->bios_pin_configs[i] = pin_cfg;
1687         }
1688
1689         return 0;
1690 }
1691
1692 static void stac92xx_set_config_reg(struct hda_codec *codec,
1693                                     hda_nid_t pin_nid, unsigned int pin_config)
1694 {
1695         int i;
1696         snd_hda_codec_write(codec, pin_nid, 0,
1697                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1698                             pin_config & 0x000000ff);
1699         snd_hda_codec_write(codec, pin_nid, 0,
1700                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1701                             (pin_config & 0x0000ff00) >> 8);
1702         snd_hda_codec_write(codec, pin_nid, 0,
1703                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1704                             (pin_config & 0x00ff0000) >> 16);
1705         snd_hda_codec_write(codec, pin_nid, 0,
1706                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1707                             pin_config >> 24);
1708         i = snd_hda_codec_read(codec, pin_nid, 0,
1709                                AC_VERB_GET_CONFIG_DEFAULT,
1710                                0x00);
1711         snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1712                     pin_nid, i);
1713 }
1714
1715 static void stac92xx_set_config_regs(struct hda_codec *codec)
1716 {
1717         int i;
1718         struct sigmatel_spec *spec = codec->spec;
1719
1720         if (!spec->pin_configs)
1721                 return;
1722
1723         for (i = 0; i < spec->num_pins; i++)
1724                 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1725                                         spec->pin_configs[i]);
1726 }
1727
1728 /*
1729  * Analog playback callbacks
1730  */
1731 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1732                                       struct hda_codec *codec,
1733                                       struct snd_pcm_substream *substream)
1734 {
1735         struct sigmatel_spec *spec = codec->spec;
1736         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1737 }
1738
1739 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1740                                          struct hda_codec *codec,
1741                                          unsigned int stream_tag,
1742                                          unsigned int format,
1743                                          struct snd_pcm_substream *substream)
1744 {
1745         struct sigmatel_spec *spec = codec->spec;
1746         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1747 }
1748
1749 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1750                                         struct hda_codec *codec,
1751                                         struct snd_pcm_substream *substream)
1752 {
1753         struct sigmatel_spec *spec = codec->spec;
1754         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1755 }
1756
1757 /*
1758  * Digital playback callbacks
1759  */
1760 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1761                                           struct hda_codec *codec,
1762                                           struct snd_pcm_substream *substream)
1763 {
1764         struct sigmatel_spec *spec = codec->spec;
1765         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1766 }
1767
1768 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1769                                            struct hda_codec *codec,
1770                                            struct snd_pcm_substream *substream)
1771 {
1772         struct sigmatel_spec *spec = codec->spec;
1773         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1774 }
1775
1776 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1777                                          struct hda_codec *codec,
1778                                          unsigned int stream_tag,
1779                                          unsigned int format,
1780                                          struct snd_pcm_substream *substream)
1781 {
1782         struct sigmatel_spec *spec = codec->spec;
1783         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1784                                              stream_tag, format, substream);
1785 }
1786
1787
1788 /*
1789  * Analog capture callbacks
1790  */
1791 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1792                                         struct hda_codec *codec,
1793                                         unsigned int stream_tag,
1794                                         unsigned int format,
1795                                         struct snd_pcm_substream *substream)
1796 {
1797         struct sigmatel_spec *spec = codec->spec;
1798
1799         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1800                                    stream_tag, 0, format);
1801         return 0;
1802 }
1803
1804 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1805                                         struct hda_codec *codec,
1806                                         struct snd_pcm_substream *substream)
1807 {
1808         struct sigmatel_spec *spec = codec->spec;
1809
1810         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1811         return 0;
1812 }
1813
1814 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1815         .substreams = 1,
1816         .channels_min = 2,
1817         .channels_max = 2,
1818         /* NID is set in stac92xx_build_pcms */
1819         .ops = {
1820                 .open = stac92xx_dig_playback_pcm_open,
1821                 .close = stac92xx_dig_playback_pcm_close,
1822                 .prepare = stac92xx_dig_playback_pcm_prepare
1823         },
1824 };
1825
1826 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1827         .substreams = 1,
1828         .channels_min = 2,
1829         .channels_max = 2,
1830         /* NID is set in stac92xx_build_pcms */
1831 };
1832
1833 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1834         .substreams = 1,
1835         .channels_min = 2,
1836         .channels_max = 8,
1837         .nid = 0x02, /* NID to query formats and rates */
1838         .ops = {
1839                 .open = stac92xx_playback_pcm_open,
1840                 .prepare = stac92xx_playback_pcm_prepare,
1841                 .cleanup = stac92xx_playback_pcm_cleanup
1842         },
1843 };
1844
1845 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1846         .substreams = 1,
1847         .channels_min = 2,
1848         .channels_max = 2,
1849         .nid = 0x06, /* NID to query formats and rates */
1850         .ops = {
1851                 .open = stac92xx_playback_pcm_open,
1852                 .prepare = stac92xx_playback_pcm_prepare,
1853                 .cleanup = stac92xx_playback_pcm_cleanup
1854         },
1855 };
1856
1857 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1858         .channels_min = 2,
1859         .channels_max = 2,
1860         /* NID + .substreams is set in stac92xx_build_pcms */
1861         .ops = {
1862                 .prepare = stac92xx_capture_pcm_prepare,
1863                 .cleanup = stac92xx_capture_pcm_cleanup
1864         },
1865 };
1866
1867 static int stac92xx_build_pcms(struct hda_codec *codec)
1868 {
1869         struct sigmatel_spec *spec = codec->spec;
1870         struct hda_pcm *info = spec->pcm_rec;
1871
1872         codec->num_pcms = 1;
1873         codec->pcm_info = info;
1874
1875         info->name = "STAC92xx Analog";
1876         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1877         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1878         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1879         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1880
1881         if (spec->alt_switch) {
1882                 codec->num_pcms++;
1883                 info++;
1884                 info->name = "STAC92xx Analog Alt";
1885                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1886         }
1887
1888         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1889                 codec->num_pcms++;
1890                 info++;
1891                 info->name = "STAC92xx Digital";
1892                 if (spec->multiout.dig_out_nid) {
1893                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1894                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1895                 }
1896                 if (spec->dig_in_nid) {
1897                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1898                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1899                 }
1900         }
1901
1902         return 0;
1903 }
1904
1905 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1906 {
1907         unsigned int pincap = snd_hda_param_read(codec, nid,
1908                                                  AC_PAR_PIN_CAP);
1909         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1910         if (pincap & AC_PINCAP_VREF_100)
1911                 return AC_PINCTL_VREF_100;
1912         if (pincap & AC_PINCAP_VREF_80)
1913                 return AC_PINCTL_VREF_80;
1914         if (pincap & AC_PINCAP_VREF_50)
1915                 return AC_PINCTL_VREF_50;
1916         if (pincap & AC_PINCAP_VREF_GRD)
1917                 return AC_PINCTL_VREF_GRD;
1918         return 0;
1919 }
1920
1921 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1922
1923 {
1924         snd_hda_codec_write_cache(codec, nid, 0,
1925                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1926 }
1927
1928 #define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
1929
1930 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1931 {
1932         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1933         struct sigmatel_spec *spec = codec->spec;
1934         int io_idx = kcontrol-> private_value & 0xff;
1935
1936         ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1937         return 0;
1938 }
1939
1940 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1941 {
1942         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1943         struct sigmatel_spec *spec = codec->spec;
1944         hda_nid_t nid = kcontrol->private_value >> 8;
1945         int io_idx = kcontrol-> private_value & 0xff;
1946         unsigned short val = !!ucontrol->value.integer.value[0];
1947
1948         spec->io_switch[io_idx] = val;
1949
1950         if (val)
1951                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1952         else {
1953                 unsigned int pinctl = AC_PINCTL_IN_EN;
1954                 if (io_idx) /* set VREF for mic */
1955                         pinctl |= stac92xx_get_vref(codec, nid);
1956                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1957         }
1958
1959         /* check the auto-mute again: we need to mute/unmute the speaker
1960          * appropriately according to the pin direction
1961          */
1962         if (spec->hp_detect)
1963                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1964
1965         return 1;
1966 }
1967
1968 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1969
1970 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1971                 struct snd_ctl_elem_value *ucontrol)
1972 {
1973         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1974         struct sigmatel_spec *spec = codec->spec;
1975
1976         ucontrol->value.integer.value[0] = spec->clfe_swap;
1977         return 0;
1978 }
1979
1980 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1981                 struct snd_ctl_elem_value *ucontrol)
1982 {
1983         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1984         struct sigmatel_spec *spec = codec->spec;
1985         hda_nid_t nid = kcontrol->private_value & 0xff;
1986         unsigned int val = !!ucontrol->value.integer.value[0];
1987
1988         if (spec->clfe_swap == val)
1989                 return 0;
1990
1991         spec->clfe_swap = val;
1992
1993         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1994                 spec->clfe_swap ? 0x4 : 0x0);
1995
1996         return 1;
1997 }
1998
1999 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2000         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2001           .name = xname, \
2002           .index = 0, \
2003           .info = stac92xx_io_switch_info, \
2004           .get = stac92xx_io_switch_get, \
2005           .put = stac92xx_io_switch_put, \
2006           .private_value = xpval, \
2007         }
2008
2009 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2010         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2011           .name = xname, \
2012           .index = 0, \
2013           .info = stac92xx_clfe_switch_info, \
2014           .get = stac92xx_clfe_switch_get, \
2015           .put = stac92xx_clfe_switch_put, \
2016           .private_value = xpval, \
2017         }
2018
2019 enum {
2020         STAC_CTL_WIDGET_VOL,
2021         STAC_CTL_WIDGET_MUTE,
2022         STAC_CTL_WIDGET_MONO_MUX,
2023         STAC_CTL_WIDGET_IO_SWITCH,
2024         STAC_CTL_WIDGET_CLFE_SWITCH
2025 };
2026
2027 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2028         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2029         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2030         STAC_MONO_MUX,
2031         STAC_CODEC_IO_SWITCH(NULL, 0),
2032         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2033 };
2034
2035 /* add dynamic controls */
2036 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
2037 {
2038         struct snd_kcontrol_new *knew;
2039
2040         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2041                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2042
2043                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2044                 if (! knew)
2045                         return -ENOMEM;
2046                 if (spec->kctl_alloc) {
2047                         memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2048                         kfree(spec->kctl_alloc);
2049                 }
2050                 spec->kctl_alloc = knew;
2051                 spec->num_kctl_alloc = num;
2052         }
2053
2054         knew = &spec->kctl_alloc[spec->num_kctl_used];
2055         *knew = stac92xx_control_templates[type];
2056         knew->name = kstrdup(name, GFP_KERNEL);
2057         if (! knew->name)
2058                 return -ENOMEM;
2059         knew->private_value = val;
2060         spec->num_kctl_used++;
2061         return 0;
2062 }
2063
2064 /* flag inputs as additional dynamic lineouts */
2065 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2066 {
2067         struct sigmatel_spec *spec = codec->spec;
2068         unsigned int wcaps, wtype;
2069         int i, num_dacs = 0;
2070
2071         /* use the wcaps cache to count all DACs available for line-outs */
2072         for (i = 0; i < codec->num_nodes; i++) {
2073                 wcaps = codec->wcaps[i];
2074                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2075
2076                 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2077                         num_dacs++;
2078         }
2079
2080         snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2081
2082         switch (cfg->line_outs) {
2083         case 3:
2084                 /* add line-in as side */
2085                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2086                         cfg->line_out_pins[cfg->line_outs] =
2087                                 cfg->input_pins[AUTO_PIN_LINE];
2088                         spec->line_switch = 1;
2089                         cfg->line_outs++;
2090                 }
2091                 break;
2092         case 2:
2093                 /* add line-in as clfe and mic as side */
2094                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2095                         cfg->line_out_pins[cfg->line_outs] =
2096                                 cfg->input_pins[AUTO_PIN_LINE];
2097                         spec->line_switch = 1;
2098                         cfg->line_outs++;
2099                 }
2100                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2101                         cfg->line_out_pins[cfg->line_outs] =
2102                                 cfg->input_pins[AUTO_PIN_MIC];
2103                         spec->mic_switch = 1;
2104                         cfg->line_outs++;
2105                 }
2106                 break;
2107         case 1:
2108                 /* add line-in as surr and mic as clfe */
2109                 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2110                         cfg->line_out_pins[cfg->line_outs] =
2111                                 cfg->input_pins[AUTO_PIN_LINE];
2112                         spec->line_switch = 1;
2113                         cfg->line_outs++;
2114                 }
2115                 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2116                         cfg->line_out_pins[cfg->line_outs] =
2117                                 cfg->input_pins[AUTO_PIN_MIC];
2118                         spec->mic_switch = 1;
2119                         cfg->line_outs++;
2120                 }
2121                 break;
2122         }
2123
2124         return 0;
2125 }
2126
2127
2128 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2129 {
2130         int i;
2131
2132         for (i = 0; i < spec->multiout.num_dacs; i++) {
2133                 if (spec->multiout.dac_nids[i] == nid)
2134                         return 1;
2135         }
2136
2137         return 0;
2138 }
2139
2140 /*
2141  * Fill in the dac_nids table from the parsed pin configuration
2142  * This function only works when every pin in line_out_pins[]
2143  * contains atleast one DAC in its connection list. Some 92xx
2144  * codecs are not connected directly to a DAC, such as the 9200
2145  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2146  */
2147 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2148                                        struct auto_pin_cfg *cfg)
2149 {
2150         struct sigmatel_spec *spec = codec->spec;
2151         int i, j, conn_len = 0;
2152         hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2153         unsigned int wcaps, wtype;
2154
2155         for (i = 0; i < cfg->line_outs; i++) {
2156                 nid = cfg->line_out_pins[i];
2157                 conn_len = snd_hda_get_connections(codec, nid, conn,
2158                                                    HDA_MAX_CONNECTIONS);
2159                 for (j = 0; j < conn_len; j++) {
2160                         wcaps = snd_hda_param_read(codec, conn[j],
2161                                                    AC_PAR_AUDIO_WIDGET_CAP);
2162                         wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2163                         if (wtype != AC_WID_AUD_OUT ||
2164                             (wcaps & AC_WCAP_DIGITAL))
2165                                 continue;
2166                         /* conn[j] is a DAC routed to this line-out */
2167                         if (!is_in_dac_nids(spec, conn[j]))
2168                                 break;
2169                 }
2170
2171                 if (j == conn_len) {
2172                         if (spec->multiout.num_dacs > 0) {
2173                                 /* we have already working output pins,
2174                                  * so let's drop the broken ones again
2175                                  */
2176                                 cfg->line_outs = spec->multiout.num_dacs;
2177                                 break;
2178                         }
2179                         /* error out, no available DAC found */
2180                         snd_printk(KERN_ERR
2181                                    "%s: No available DAC for pin 0x%x\n",
2182                                    __func__, nid);
2183                         return -ENODEV;
2184                 }
2185
2186                 spec->multiout.dac_nids[i] = conn[j];
2187                 spec->multiout.num_dacs++;
2188                 if (conn_len > 1) {
2189                         /* select this DAC in the pin's input mux */
2190                         snd_hda_codec_write_cache(codec, nid, 0,
2191                                                   AC_VERB_SET_CONNECT_SEL, j);
2192
2193                 }
2194         }
2195
2196         snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2197                    spec->multiout.num_dacs,
2198                    spec->multiout.dac_nids[0],
2199                    spec->multiout.dac_nids[1],
2200                    spec->multiout.dac_nids[2],
2201                    spec->multiout.dac_nids[3],
2202                    spec->multiout.dac_nids[4]);
2203         return 0;
2204 }
2205
2206 /* create volume control/switch for the given prefx type */
2207 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2208 {
2209         char name[32];
2210         int err;
2211
2212         sprintf(name, "%s Playback Volume", pfx);
2213         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2214                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2215         if (err < 0)
2216                 return err;
2217         sprintf(name, "%s Playback Switch", pfx);
2218         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2219                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2220         if (err < 0)
2221                 return err;
2222         return 0;
2223 }
2224
2225 /* add playback controls from the parsed DAC table */
2226 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2227                                                const struct auto_pin_cfg *cfg)
2228 {
2229         static const char *chname[4] = {
2230                 "Front", "Surround", NULL /*CLFE*/, "Side"
2231         };
2232         hda_nid_t nid;
2233         int i, err;
2234
2235         struct sigmatel_spec *spec = codec->spec;
2236         unsigned int wid_caps, pincap;
2237
2238
2239         for (i = 0; i < cfg->line_outs; i++) {
2240                 if (!spec->multiout.dac_nids[i])
2241                         continue;
2242
2243                 nid = spec->multiout.dac_nids[i];
2244
2245                 if (i == 2) {
2246                         /* Center/LFE */
2247                         err = create_controls(spec, "Center", nid, 1);
2248                         if (err < 0)
2249                                 return err;
2250                         err = create_controls(spec, "LFE", nid, 2);
2251                         if (err < 0)
2252                                 return err;
2253
2254                         wid_caps = get_wcaps(codec, nid);
2255
2256                         if (wid_caps & AC_WCAP_LR_SWAP) {
2257                                 err = stac92xx_add_control(spec,
2258                                         STAC_CTL_WIDGET_CLFE_SWITCH,
2259                                         "Swap Center/LFE Playback Switch", nid);
2260
2261                                 if (err < 0)
2262                                         return err;
2263                         }
2264
2265                 } else {
2266                         err = create_controls(spec, chname[i], nid, 3);
2267                         if (err < 0)
2268                                 return err;
2269                 }
2270         }
2271
2272         if (spec->line_switch) {
2273                 nid = cfg->input_pins[AUTO_PIN_LINE];
2274                 pincap = snd_hda_param_read(codec, nid,
2275                                                 AC_PAR_PIN_CAP);
2276                 if (pincap & AC_PINCAP_OUT) {
2277                         err = stac92xx_add_control(spec,
2278                                 STAC_CTL_WIDGET_IO_SWITCH,
2279                                 "Line In as Output Switch", nid << 8);
2280                         if (err < 0)
2281                                 return err;
2282                 }
2283         }
2284
2285         if (spec->mic_switch) {
2286                 unsigned int def_conf;
2287                 nid = cfg->input_pins[AUTO_PIN_MIC];
2288                 def_conf = snd_hda_codec_read(codec, nid, 0,
2289                                                 AC_VERB_GET_CONFIG_DEFAULT, 0);
2290
2291                 /* some laptops have an internal analog microphone
2292                  * which can't be used as a output */
2293                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2294                         pincap = snd_hda_param_read(codec, nid,
2295                                                         AC_PAR_PIN_CAP);
2296                         if (pincap & AC_PINCAP_OUT) {
2297                                 err = stac92xx_add_control(spec,
2298                                         STAC_CTL_WIDGET_IO_SWITCH,
2299                                         "Mic as Output Switch", (nid << 8) | 1);
2300                                 if (err < 0)
2301                                         return err;
2302                         }
2303                 }
2304         }
2305
2306         return 0;
2307 }
2308
2309 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2310 {
2311         if (is_in_dac_nids(spec, nid))
2312                 return 1;
2313         if (spec->multiout.hp_nid == nid)
2314                 return 1;
2315         return 0;
2316 }
2317
2318 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2319 {
2320         if (!spec->multiout.hp_nid)
2321                 spec->multiout.hp_nid = nid;
2322         else if (spec->multiout.num_dacs > 4) {
2323                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2324                 return 1;
2325         } else {
2326                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2327                 spec->multiout.num_dacs++;
2328         }
2329         return 0;
2330 }
2331
2332 /* add playback controls for Speaker and HP outputs */
2333 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2334                                         struct auto_pin_cfg *cfg)
2335 {
2336         struct sigmatel_spec *spec = codec->spec;
2337         hda_nid_t nid;
2338         int i, old_num_dacs, err;
2339
2340         old_num_dacs = spec->multiout.num_dacs;
2341         for (i = 0; i < cfg->hp_outs; i++) {
2342                 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2343                 if (wid_caps & AC_WCAP_UNSOL_CAP)
2344                         spec->hp_detect = 1;
2345                 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2346                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2347                 if (check_in_dac_nids(spec, nid))
2348                         nid = 0;
2349                 if (! nid)
2350                         continue;
2351                 add_spec_dacs(spec, nid);
2352         }
2353         for (i = 0; i < cfg->speaker_outs; i++) {
2354                 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2355                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2356                 if (check_in_dac_nids(spec, nid))
2357                         nid = 0;
2358                 if (! nid)
2359                         continue;
2360                 add_spec_dacs(spec, nid);
2361         }
2362         for (i = 0; i < cfg->line_outs; i++) {
2363                 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2364                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2365                 if (check_in_dac_nids(spec, nid))
2366                         nid = 0;
2367                 if (! nid)
2368                         continue;
2369                 add_spec_dacs(spec, nid);
2370         }
2371         for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2372                 static const char *pfxs[] = {
2373                         "Speaker", "External Speaker", "Speaker2",
2374                 };
2375                 err = create_controls(spec, pfxs[i - old_num_dacs],
2376                                       spec->multiout.dac_nids[i], 3);
2377                 if (err < 0)
2378                         return err;
2379         }
2380         if (spec->multiout.hp_nid) {
2381                 const char *pfx;
2382                 if (old_num_dacs == spec->multiout.num_dacs)
2383                         pfx = "Master";
2384                 else
2385                         pfx = "Headphone";
2386                 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2387                 if (err < 0)
2388                         return err;
2389         }
2390
2391         return 0;
2392 }
2393
2394 /* labels for mono mux outputs */
2395 static const char *stac92xx_mono_labels[3] = {
2396         "DAC0", "DAC1", "Mixer"
2397 };
2398
2399 /* create mono mux for mono out on capable codecs */
2400 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
2401 {
2402         struct sigmatel_spec *spec = codec->spec;
2403         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
2404         int i, num_cons;
2405         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
2406
2407         num_cons = snd_hda_get_connections(codec,
2408                                 spec->mono_nid,
2409                                 con_lst,
2410                                 HDA_MAX_NUM_INPUTS);
2411         if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
2412                 return -EINVAL;
2413
2414         for (i = 0; i < num_cons; i++) {
2415                 mono_mux->items[mono_mux->num_items].label =
2416                                         stac92xx_mono_labels[i];
2417                 mono_mux->items[mono_mux->num_items].index = i;
2418                 mono_mux->num_items++;
2419         }
2420
2421         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
2422                                 "Mono Mux", spec->mono_nid);
2423 }
2424
2425 /* labels for dmic mux inputs */
2426 static const char *stac92xx_dmic_labels[5] = {
2427         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2428         "Digital Mic 3", "Digital Mic 4"
2429 };
2430
2431 /* create playback/capture controls for input pins on dmic capable codecs */
2432 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2433                                                 const struct auto_pin_cfg *cfg)
2434 {
2435         struct sigmatel_spec *spec = codec->spec;
2436         struct hda_input_mux *dimux = &spec->private_dimux;
2437         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2438         int err, i, j;
2439         char name[32];
2440
2441         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2442         dimux->items[dimux->num_items].index = 0;
2443         dimux->num_items++;
2444
2445         for (i = 0; i < spec->num_dmics; i++) {
2446                 hda_nid_t nid;
2447                 int index;
2448                 int num_cons;
2449                 unsigned int wcaps;
2450                 unsigned int def_conf;
2451
2452                 def_conf = snd_hda_codec_read(codec,
2453                                               spec->dmic_nids[i],
2454                                               0,
2455                                               AC_VERB_GET_CONFIG_DEFAULT,
2456                                               0);
2457                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2458                         continue;
2459
2460                 nid = spec->dmic_nids[i];
2461                 num_cons = snd_hda_get_connections(codec,
2462                                 spec->dmux_nids[0],
2463                                 con_lst,
2464                                 HDA_MAX_NUM_INPUTS);
2465                 for (j = 0; j < num_cons; j++)
2466                         if (con_lst[j] == nid) {
2467                                 index = j;
2468                                 goto found;
2469                         }
2470                 continue;
2471 found:
2472                 wcaps = get_wcaps(codec, nid);
2473
2474                 if (wcaps & AC_WCAP_OUT_AMP) {
2475                         sprintf(name, "%s Capture Volume",
2476                                 stac92xx_dmic_labels[dimux->num_items]);
2477
2478                         err = stac92xx_add_control(spec,
2479                                 STAC_CTL_WIDGET_VOL,
2480                                 name,
2481                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2482                         if (err < 0)
2483                                 return err;
2484                 }
2485
2486                 dimux->items[dimux->num_items].label =
2487                         stac92xx_dmic_labels[dimux->num_items];
2488                 dimux->items[dimux->num_items].index = index;
2489                 dimux->num_items++;
2490         }
2491
2492         return 0;
2493 }
2494
2495 /* create playback/capture controls for input pins */
2496 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2497 {
2498         struct sigmatel_spec *spec = codec->spec;
2499         struct hda_input_mux *imux = &spec->private_imux;
2500         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2501         int i, j, k;
2502
2503         for (i = 0; i < AUTO_PIN_LAST; i++) {
2504                 int index;
2505
2506                 if (!cfg->input_pins[i])
2507                         continue;
2508                 index = -1;
2509                 for (j = 0; j < spec->num_muxes; j++) {
2510                         int num_cons;
2511                         num_cons = snd_hda_get_connections(codec,
2512                                                            spec->mux_nids[j],
2513                                                            con_lst,
2514                                                            HDA_MAX_NUM_INPUTS);
2515                         for (k = 0; k < num_cons; k++)
2516                                 if (con_lst[k] == cfg->input_pins[i]) {
2517                                         index = k;
2518                                         goto found;
2519                                 }
2520                 }
2521                 continue;
2522         found:
2523                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2524                 imux->items[imux->num_items].index = index;
2525                 imux->num_items++;
2526         }
2527
2528         if (imux->num_items) {
2529                 /*
2530                  * Set the current input for the muxes.
2531                  * The STAC9221 has two input muxes with identical source
2532                  * NID lists.  Hopefully this won't get confused.
2533                  */
2534                 for (i = 0; i < spec->num_muxes; i++) {
2535                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2536                                                   AC_VERB_SET_CONNECT_SEL,
2537                                                   imux->items[0].index);
2538                 }
2539         }
2540
2541         return 0;
2542 }
2543
2544 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2545 {
2546         struct sigmatel_spec *spec = codec->spec;
2547         int i;
2548
2549         for (i = 0; i < spec->autocfg.line_outs; i++) {
2550                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2551                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2552         }
2553 }
2554
2555 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2556 {
2557         struct sigmatel_spec *spec = codec->spec;
2558         int i;
2559
2560         for (i = 0; i < spec->autocfg.hp_outs; i++) {
2561                 hda_nid_t pin;
2562                 pin = spec->autocfg.hp_pins[i];
2563                 if (pin) /* connect to front */
2564                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2565         }
2566         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2567                 hda_nid_t pin;
2568                 pin = spec->autocfg.speaker_pins[i];
2569                 if (pin) /* connect to front */
2570                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2571         }
2572 }
2573
2574 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2575 {
2576         struct sigmatel_spec *spec = codec->spec;
2577         int err;
2578         int hp_speaker_swap = 0;
2579
2580         if ((err = snd_hda_parse_pin_def_config(codec,
2581                                                 &spec->autocfg,
2582                                                 spec->dmic_nids)) < 0)
2583                 return err;
2584         if (! spec->autocfg.line_outs)
2585                 return 0; /* can't find valid pin config */
2586
2587         /* If we have no real line-out pin and multiple hp-outs, HPs should
2588          * be set up as multi-channel outputs.
2589          */
2590         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2591             spec->autocfg.hp_outs > 1) {
2592                 /* Copy hp_outs to line_outs, backup line_outs in
2593                  * speaker_outs so that the following routines can handle
2594                  * HP pins as primary outputs.
2595                  */
2596                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2597                        sizeof(spec->autocfg.line_out_pins));
2598                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2599                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2600                        sizeof(spec->autocfg.hp_pins));
2601                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2602                 hp_speaker_swap = 1;
2603         }
2604         if (spec->autocfg.mono_out_pin) {
2605                 int dir = (get_wcaps(codec, spec->autocfg.mono_out_pin)
2606                                 & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
2607                 u32 caps = query_amp_caps(codec,
2608                                 spec->autocfg.mono_out_pin, dir);
2609                 hda_nid_t conn_list[1];
2610
2611                 /* get the mixer node and then the mono mux if it exists */
2612                 if (snd_hda_get_connections(codec,
2613                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
2614                                 snd_hda_get_connections(codec, conn_list[0],
2615                                 conn_list, 1)) {
2616
2617                                 int wcaps = get_wcaps(codec, conn_list[0]);
2618                                 int wid_type = (wcaps & AC_WCAP_TYPE)
2619                                         >> AC_WCAP_TYPE_SHIFT;
2620                                 /* LR swap check, some stac925x have a mux that
2621                                  * changes the DACs output path instead of the
2622                                  * mono-mux path.
2623                                  */
2624                                 if (wid_type == AC_WID_AUD_SEL &&
2625                                                 !(wcaps & AC_WCAP_LR_SWAP))
2626                                         spec->mono_nid = conn_list[0];
2627                 }
2628                 /* all mono outs have a least a mute/unmute switch */
2629                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
2630                         "Mono Playback Switch",
2631                         HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
2632                                         1, 0, dir));
2633                 if (err < 0)
2634                         return err;
2635                 /* check to see if there is volume support for the amp */
2636                 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
2637                         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
2638                                 "Mono Playback Volume",
2639                                 HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
2640                                         1, 0, dir));
2641                         if (err < 0)
2642                                 return err;
2643                 }
2644
2645                 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
2646                                          AC_PINCTL_OUT_EN);
2647         }
2648
2649         if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2650                 return err;
2651         if (spec->multiout.num_dacs == 0)
2652                 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2653                         return err;
2654
2655         err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2656
2657         if (err < 0)
2658                 return err;
2659
2660         if (hp_speaker_swap == 1) {
2661                 /* Restore the hp_outs and line_outs */
2662                 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2663                        sizeof(spec->autocfg.line_out_pins));
2664                 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2665                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2666                        sizeof(spec->autocfg.speaker_pins));
2667                 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2668                 memset(spec->autocfg.speaker_pins, 0,
2669                        sizeof(spec->autocfg.speaker_pins));
2670                 spec->autocfg.speaker_outs = 0;
2671         }
2672
2673         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2674
2675         if (err < 0)
2676                 return err;
2677
2678         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2679
2680         if (err < 0)
2681                 return err;
2682
2683         if (spec->mono_nid > 0) {
2684                 err = stac92xx_auto_create_mono_output_ctls(codec);
2685                 if (err < 0)
2686                         return err;
2687         }
2688
2689         if (spec->num_dmics > 0)
2690                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2691                                                 &spec->autocfg)) < 0)
2692                         return err;
2693
2694         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2695         if (spec->multiout.max_channels > 2)
2696                 spec->surr_switch = 1;
2697
2698         if (spec->autocfg.dig_out_pin)
2699                 spec->multiout.dig_out_nid = dig_out;
2700         if (spec->autocfg.dig_in_pin)
2701                 spec->dig_in_nid = dig_in;
2702
2703         if (spec->kctl_alloc)
2704                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2705
2706         spec->input_mux = &spec->private_imux;
2707         if (!spec->dinput_mux)
2708                 spec->dinput_mux = &spec->private_dimux;
2709         spec->mono_mux = &spec->private_mono_mux;
2710
2711         return 1;
2712 }
2713
2714 /* add playback controls for HP output */
2715 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2716                                         struct auto_pin_cfg *cfg)
2717 {
2718         struct sigmatel_spec *spec = codec->spec;
2719         hda_nid_t pin = cfg->hp_pins[0];
2720         unsigned int wid_caps;
2721
2722         if (! pin)
2723                 return 0;
2724
2725         wid_caps = get_wcaps(codec, pin);
2726         if (wid_caps & AC_WCAP_UNSOL_CAP)
2727                 spec->hp_detect = 1;
2728
2729         return 0;
2730 }
2731
2732 /* add playback controls for LFE output */
2733 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2734                                         struct auto_pin_cfg *cfg)
2735 {
2736         struct sigmatel_spec *spec = codec->spec;
2737         int err;
2738         hda_nid_t lfe_pin = 0x0;
2739         int i;
2740
2741         /*
2742          * search speaker outs and line outs for a mono speaker pin
2743          * with an amp.  If one is found, add LFE controls
2744          * for it.
2745          */
2746         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2747                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2748                 unsigned long wcaps = get_wcaps(codec, pin);
2749                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2750                 if (wcaps == AC_WCAP_OUT_AMP)
2751                         /* found a mono speaker with an amp, must be lfe */
2752                         lfe_pin = pin;
2753         }
2754
2755         /* if speaker_outs is 0, then speakers may be in line_outs */
2756         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2757                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2758                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
2759                         unsigned long cfg;
2760                         cfg = snd_hda_codec_read(codec, pin, 0,
2761                                                  AC_VERB_GET_CONFIG_DEFAULT,
2762                                                  0x00);
2763                         if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2764                                 unsigned long wcaps = get_wcaps(codec, pin);
2765                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2766                                 if (wcaps == AC_WCAP_OUT_AMP)
2767                                         /* found a mono speaker with an amp,
2768                                            must be lfe */
2769                                         lfe_pin = pin;
2770                         }
2771                 }
2772         }
2773
2774         if (lfe_pin) {
2775                 err = create_controls(spec, "LFE", lfe_pin, 1);
2776                 if (err < 0)
2777                         return err;
2778         }
2779
2780         return 0;
2781 }
2782
2783 static int stac9200_parse_auto_config(struct hda_codec *codec)
2784 {
2785         struct sigmatel_spec *spec = codec->spec;
2786         int err;
2787
2788         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2789                 return err;
2790
2791         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2792                 return err;
2793
2794         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2795                 return err;
2796
2797         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2798                 return err;
2799
2800         if (spec->autocfg.dig_out_pin)
2801                 spec->multiout.dig_out_nid = 0x05;
2802         if (spec->autocfg.dig_in_pin)
2803                 spec->dig_in_nid = 0x04;
2804
2805         if (spec->kctl_alloc)
2806                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2807
2808         spec->input_mux = &spec->private_imux;
2809         spec->dinput_mux = &spec->private_dimux;
2810
2811         return 1;
2812 }
2813
2814 /*
2815  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2816  * funky external mute control using GPIO pins.
2817  */
2818
2819 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
2820                           unsigned int dir_mask, unsigned int data)
2821 {
2822         unsigned int gpiostate, gpiomask, gpiodir;
2823
2824         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2825                                        AC_VERB_GET_GPIO_DATA, 0);
2826         gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
2827
2828         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2829                                       AC_VERB_GET_GPIO_MASK, 0);
2830         gpiomask |= mask;
2831
2832         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2833                                      AC_VERB_GET_GPIO_DIRECTION, 0);
2834         gpiodir |= dir_mask;
2835
2836         /* Configure GPIOx as CMOS */
2837         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2838
2839         snd_hda_codec_write(codec, codec->afg, 0,
2840                             AC_VERB_SET_GPIO_MASK, gpiomask);
2841         snd_hda_codec_read(codec, codec->afg, 0,
2842                            AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
2843
2844         msleep(1);
2845
2846         snd_hda_codec_read(codec, codec->afg, 0,
2847                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
2848 }
2849
2850 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2851                               unsigned int event)
2852 {
2853         if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2854                 snd_hda_codec_write_cache(codec, nid, 0,
2855                                           AC_VERB_SET_UNSOLICITED_ENABLE,
2856                                           (AC_USRSP_EN | event));
2857 }
2858
2859 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
2860 {
2861         int i;
2862         for (i = 0; i < cfg->hp_outs; i++)
2863                 if (cfg->hp_pins[i] == nid)
2864                         return 1; /* nid is a HP-Out */
2865
2866         return 0; /* nid is not a HP-Out */
2867 };
2868
2869 static int stac92xx_init(struct hda_codec *codec)
2870 {
2871         struct sigmatel_spec *spec = codec->spec;
2872         struct auto_pin_cfg *cfg = &spec->autocfg;
2873         int i;
2874
2875         snd_hda_sequence_write(codec, spec->init);
2876
2877         /* set up pins */
2878         if (spec->hp_detect) {
2879                 /* Enable unsolicited responses on the HP widget */
2880                 for (i = 0; i < cfg->hp_outs; i++)
2881                         enable_pin_detect(codec, cfg->hp_pins[i],
2882                                           STAC_HP_EVENT);
2883                 /* force to enable the first line-out; the others are set up
2884                  * in unsol_event
2885                  */
2886                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2887                                          AC_PINCTL_OUT_EN);
2888                 stac92xx_auto_init_hp_out(codec);
2889                 /* fake event to set up pins */
2890                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2891         } else {
2892                 stac92xx_auto_init_multi_out(codec);
2893                 stac92xx_auto_init_hp_out(codec);
2894         }
2895         for (i = 0; i < AUTO_PIN_LAST; i++) {
2896                 hda_nid_t nid = cfg->input_pins[i];
2897                 if (nid) {
2898                         unsigned int pinctl = AC_PINCTL_IN_EN;
2899                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2900                                 pinctl |= stac92xx_get_vref(codec, nid);
2901                         stac92xx_auto_set_pinctl(codec, nid, pinctl);
2902                 }
2903         }
2904         for (i = 0; i < spec->num_dmics; i++)
2905                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2906                                         AC_PINCTL_IN_EN);
2907         for (i = 0; i < spec->num_pwrs; i++)  {
2908                 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
2909                                         ? STAC_HP_EVENT : STAC_PWR_EVENT;
2910                 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
2911                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2912                 /* outputs are only ports capable of power management
2913                  * any attempts on powering down a input port cause the
2914                  * referenced VREF to act quirky.
2915                  */
2916                 if (pinctl & AC_PINCTL_IN_EN)
2917                         continue;
2918                 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
2919                 codec->patch_ops.unsol_event(codec, (event | i) << 26);
2920         }
2921
2922         if (cfg->dig_out_pin)
2923                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2924                                          AC_PINCTL_OUT_EN);
2925         if (cfg->dig_in_pin)
2926                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2927                                          AC_PINCTL_IN_EN);
2928
2929         stac_gpio_set(codec, spec->gpio_mask,
2930                                         spec->gpio_dir, spec->gpio_data);
2931
2932         return 0;
2933 }
2934
2935 static void stac92xx_free(struct hda_codec *codec)
2936 {
2937         struct sigmatel_spec *spec = codec->spec;
2938         int i;
2939
2940         if (! spec)
2941                 return;
2942
2943         if (spec->kctl_alloc) {
2944                 for (i = 0; i < spec->num_kctl_used; i++)
2945                         kfree(spec->kctl_alloc[i].name);
2946                 kfree(spec->kctl_alloc);
2947         }
2948
2949         if (spec->bios_pin_configs)
2950                 kfree(spec->bios_pin_configs);
2951
2952         kfree(spec);
2953 }
2954
2955 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2956                                 unsigned int flag)
2957 {
2958         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2959                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2960
2961         if (pin_ctl & AC_PINCTL_IN_EN) {
2962                 /*
2963                  * we need to check the current set-up direction of
2964                  * shared input pins since they can be switched via
2965                  * "xxx as Output" mixer switch
2966                  */
2967                 struct sigmatel_spec *spec = codec->spec;
2968                 struct auto_pin_cfg *cfg = &spec->autocfg;
2969                 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2970                      spec->line_switch) ||
2971                     (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2972                      spec->mic_switch))
2973                         return;
2974         }
2975
2976         /* if setting pin direction bits, clear the current
2977            direction bits first */
2978         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2979                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2980
2981         snd_hda_codec_write_cache(codec, nid, 0,
2982                         AC_VERB_SET_PIN_WIDGET_CONTROL,
2983                         pin_ctl | flag);
2984 }
2985
2986 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2987                                   unsigned int flag)
2988 {
2989         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2990                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2991         snd_hda_codec_write_cache(codec, nid, 0,
2992                         AC_VERB_SET_PIN_WIDGET_CONTROL,
2993                         pin_ctl & ~flag);
2994 }
2995
2996 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2997 {
2998         if (!nid)
2999                 return 0;
3000         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
3001             & (1 << 31)) {
3002                 unsigned int pinctl;
3003                 pinctl = snd_hda_codec_read(codec, nid, 0,
3004                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3005                 if (pinctl & AC_PINCTL_IN_EN)
3006                         return 0; /* mic- or line-input */
3007                 else
3008                         return 1; /* HP-output */
3009         }
3010         return 0;
3011 }
3012
3013 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
3014 {
3015         struct sigmatel_spec *spec = codec->spec;
3016         struct auto_pin_cfg *cfg = &spec->autocfg;
3017         int i, presence;
3018
3019         presence = 0;
3020         if (spec->gpio_mute)
3021                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
3022                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
3023
3024         for (i = 0; i < cfg->hp_outs; i++) {
3025                 if (presence)
3026                         break;
3027                 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
3028         }
3029
3030         if (presence) {
3031                 /* disable lineouts, enable hp */
3032                 for (i = 0; i < cfg->line_outs; i++)
3033                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
3034                                                 AC_PINCTL_OUT_EN);
3035                 for (i = 0; i < cfg->speaker_outs; i++)
3036                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
3037                                                 AC_PINCTL_OUT_EN);
3038         } else {
3039                 /* enable lineouts, disable hp */
3040                 for (i = 0; i < cfg->line_outs; i++)
3041                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
3042                                                 AC_PINCTL_OUT_EN);
3043                 for (i = 0; i < cfg->speaker_outs; i++)
3044                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
3045                                                 AC_PINCTL_OUT_EN);
3046         }
3047 }
3048
3049 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
3050 {
3051         struct sigmatel_spec *spec = codec->spec;
3052         hda_nid_t nid = spec->pwr_nids[idx];
3053         int presence, val;
3054         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
3055                                                         & 0x000000ff;
3056         presence = get_hp_pin_presence(codec, nid);
3057         idx = 1 << idx;
3058
3059         if (presence)
3060                 val &= ~idx;
3061         else
3062                 val |= idx;
3063
3064         /* power down unused output ports */
3065         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
3066 };
3067
3068 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
3069 {
3070         struct sigmatel_spec *spec = codec->spec;
3071         int idx = res >> 26 & 0x0f;
3072
3073         switch ((res >> 26) & 0x30) {
3074         case STAC_HP_EVENT:
3075                 stac92xx_hp_detect(codec, res);
3076                 /* fallthru */
3077         case STAC_PWR_EVENT:
3078                 if (spec->num_pwrs > 0)
3079                         stac92xx_pin_sense(codec, idx);
3080         }
3081 }
3082
3083 #ifdef SND_HDA_NEEDS_RESUME
3084 static int stac92xx_resume(struct hda_codec *codec)
3085 {
3086         struct sigmatel_spec *spec = codec->spec;
3087
3088         stac92xx_set_config_regs(codec);
3089         snd_hda_sequence_write(codec, spec->init);
3090         stac_gpio_set(codec, spec->gpio_mask,
3091                 spec->gpio_dir, spec->gpio_data);
3092         snd_hda_codec_resume_amp(codec);
3093         snd_hda_codec_resume_cache(codec);
3094         /* invoke unsolicited event to reset the HP state */
3095         if (spec->hp_detect)
3096                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3097         return 0;
3098 }
3099 #endif
3100
3101 static struct hda_codec_ops stac92xx_patch_ops = {
3102         .build_controls = stac92xx_build_controls,
3103         .build_pcms = stac92xx_build_pcms,
3104         .init = stac92xx_init,
3105         .free = stac92xx_free,
3106         .unsol_event = stac92xx_unsol_event,
3107 #ifdef SND_HDA_NEEDS_RESUME
3108         .resume = stac92xx_resume,
3109 #endif
3110 };
3111
3112 static int patch_stac9200(struct hda_codec *codec)
3113 {
3114         struct sigmatel_spec *spec;
3115         int err;
3116
3117         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3118         if (spec == NULL)
3119                 return -ENOMEM;
3120
3121         codec->spec = spec;
3122         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
3123         spec->pin_nids = stac9200_pin_nids;
3124         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
3125                                                         stac9200_models,
3126                                                         stac9200_cfg_tbl);
3127         if (spec->board_config < 0) {
3128                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
3129                 err = stac92xx_save_bios_config_regs(codec);
3130                 if (err < 0) {
3131                         stac92xx_free(codec);
3132                         return err;
3133                 }
3134                 spec->pin_configs = spec->bios_pin_configs;
3135         } else {
3136                 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
3137                 stac92xx_set_config_regs(codec);
3138         }
3139
3140         spec->multiout.max_channels = 2;
3141         spec->multiout.num_dacs = 1;
3142         spec->multiout.dac_nids = stac9200_dac_nids;
3143         spec->adc_nids = stac9200_adc_nids;
3144         spec->mux_nids = stac9200_mux_nids;
3145         spec->num_muxes = 1;
3146         spec->num_dmics = 0;
3147         spec->num_adcs = 1;
3148         spec->num_pwrs = 0;
3149
3150         if (spec->board_config == STAC_9200_GATEWAY)
3151                 spec->init = stac9200_eapd_init;
3152         else
3153                 spec->init = stac9200_core_init;
3154         spec->mixer = stac9200_mixer;
3155
3156         err = stac9200_parse_auto_config(codec);
3157         if (err < 0) {
3158                 stac92xx_free(codec);
3159                 return err;
3160         }
3161
3162         codec->patch_ops = stac92xx_patch_ops;
3163
3164         return 0;
3165 }
3166
3167 static int patch_stac925x(struct hda_codec *codec)
3168 {
3169         struct sigmatel_spec *spec;
3170         int err;
3171
3172         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3173         if (spec == NULL)
3174                 return -ENOMEM;
3175
3176         codec->spec = spec;
3177         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
3178         spec->pin_nids = stac925x_pin_nids;
3179         spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
3180                                                         stac925x_models,
3181                                                         stac925x_cfg_tbl);
3182  again:
3183         if (spec->board_config < 0) {
3184                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
3185                                       "using BIOS defaults\n");
3186                 err = stac92xx_save_bios_config_regs(codec);
3187                 if (err < 0) {
3188                         stac92xx_free(codec);
3189                         return err;
3190                 }
3191                 spec->pin_configs = spec->bios_pin_configs;
3192         } else if (stac925x_brd_tbl[spec->board_config] != NULL){
3193                 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
3194                 stac92xx_set_config_regs(codec);
3195         }
3196
3197         spec->multiout.max_channels = 2;
3198         spec->multiout.num_dacs = 1;
3199         spec->multiout.dac_nids = stac925x_dac_nids;
3200         spec->adc_nids = stac925x_adc_nids;
3201         spec->mux_nids = stac925x_mux_nids;
3202         spec->num_muxes = 1;
3203         spec->num_adcs = 1;
3204         spec->num_pwrs = 0;
3205         switch (codec->vendor_id) {
3206         case 0x83847632: /* STAC9202  */
3207         case 0x83847633: /* STAC9202D */
3208         case 0x83847636: /* STAC9251  */
3209         case 0x83847637: /* STAC9251D */
3210                 spec->num_dmics = STAC925X_NUM_DMICS;
3211                 spec->dmic_nids = stac925x_dmic_nids;
3212                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
3213                 spec->dmux_nids = stac925x_dmux_nids;
3214                 break;
3215         default:
3216                 spec->num_dmics = 0;
3217                 break;
3218         }
3219
3220         spec->init = stac925x_core_init;
3221         spec->mixer = stac925x_mixer;
3222
3223         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
3224         if (!err) {
3225                 if (spec->board_config < 0) {
3226                         printk(KERN_WARNING "hda_codec: No auto-config is "
3227                                "available, default to model=ref\n");
3228                         spec->board_config = STAC_925x_REF;
3229                         goto again;
3230                 }
3231                 err = -EINVAL;
3232         }
3233         if (err < 0) {
3234                 stac92xx_free(codec);
3235                 return err;
3236         }
3237
3238         codec->patch_ops = stac92xx_patch_ops;
3239
3240         return 0;
3241 }
3242
3243 static struct hda_input_mux stac92hd73xx_dmux = {
3244         .num_items = 4,
3245         .items = {
3246                 { "Analog Inputs", 0x0b },
3247                 { "CD", 0x08 },
3248                 { "Digital Mic 1", 0x09 },
3249                 { "Digital Mic 2", 0x0a },
3250         }
3251 };
3252
3253 static int patch_stac92hd73xx(struct hda_codec *codec)
3254 {
3255         struct sigmatel_spec *spec;
3256         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3257         int err = 0;
3258
3259         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3260         if (spec == NULL)
3261                 return -ENOMEM;
3262
3263         codec->spec = spec;
3264         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3265         spec->pin_nids = stac92hd73xx_pin_nids;
3266         spec->board_config = snd_hda_check_board_config(codec,
3267                                                         STAC_92HD73XX_MODELS,
3268                                                         stac92hd73xx_models,
3269                                                         stac92hd73xx_cfg_tbl);
3270 again:
3271         if (spec->board_config < 0) {
3272                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3273                         " STAC92HD73XX, using BIOS defaults\n");
3274                 err = stac92xx_save_bios_config_regs(codec);
3275                 if (err < 0) {
3276                         stac92xx_free(codec);
3277                         return err;
3278                 }
3279                 spec->pin_configs = spec->bios_pin_configs;
3280         } else {
3281                 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3282                 stac92xx_set_config_regs(codec);
3283         }
3284
3285         spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3286                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
3287
3288         if (spec->multiout.num_dacs < 0) {
3289                 printk(KERN_WARNING "hda_codec: Could not determine "
3290                        "number of channels defaulting to DAC count\n");
3291                 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3292         }
3293
3294         switch (spec->multiout.num_dacs) {
3295         case 0x3: /* 6 Channel */
3296                 spec->mixer = stac92hd73xx_6ch_mixer;
3297                 spec->init = stac92hd73xx_6ch_core_init;
3298                 break;
3299         case 0x4: /* 8 Channel */
3300                 spec->multiout.hp_nid = 0x18;
3301                 spec->mixer = stac92hd73xx_8ch_mixer;
3302                 spec->init = stac92hd73xx_8ch_core_init;
3303                 break;
3304         case 0x5: /* 10 Channel */
3305                 spec->multiout.hp_nid = 0x19;
3306                 spec->mixer = stac92hd73xx_10ch_mixer;
3307                 spec->init = stac92hd73xx_10ch_core_init;
3308         };
3309
3310         spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3311         spec->aloopback_mask = 0x01;
3312         spec->aloopback_shift = 8;
3313
3314         spec->mux_nids = stac92hd73xx_mux_nids;
3315         spec->adc_nids = stac92hd73xx_adc_nids;
3316         spec->dmic_nids = stac92hd73xx_dmic_nids;
3317         spec->dmux_nids = stac92hd73xx_dmux_nids;
3318
3319         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3320         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3321         spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3322         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3323         spec->dinput_mux = &stac92hd73xx_dmux;
3324         /* GPIO0 High = Enable EAPD */
3325         spec->gpio_mask = spec->gpio_dir = 0x1;
3326         spec->gpio_data = 0x01;
3327
3328         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
3329         spec->pwr_nids = stac92hd73xx_pwr_nids;
3330
3331         err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3332
3333         if (!err) {
3334                 if (spec->board_config < 0) {
3335                         printk(KERN_WARNING "hda_codec: No auto-config is "
3336                                "available, default to model=ref\n");
3337                         spec->board_config = STAC_92HD73XX_REF;
3338                         goto again;
3339                 }
3340                 err = -EINVAL;
3341         }
3342
3343         if (err < 0) {
3344                 stac92xx_free(codec);
3345                 return err;
3346         }
3347
3348         codec->patch_ops = stac92xx_patch_ops;
3349
3350         return 0;
3351 }
3352
3353 static int patch_stac92hd71bxx(struct hda_codec *codec)
3354 {
3355         struct sigmatel_spec *spec;
3356         int err = 0;
3357
3358         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3359         if (spec == NULL)
3360                 return -ENOMEM;
3361
3362         codec->spec = spec;
3363         spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3364         spec->pin_nids = stac92hd71bxx_pin_nids;
3365         spec->board_config = snd_hda_check_board_config(codec,
3366                                                         STAC_92HD71BXX_MODELS,
3367                                                         stac92hd71bxx_models,
3368                                                         stac92hd71bxx_cfg_tbl);
3369 again:
3370         if (spec->board_config < 0) {
3371                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3372                         " STAC92HD71BXX, using BIOS defaults\n");
3373                 err = stac92xx_save_bios_config_regs(codec);
3374                 if (err < 0) {
3375                         stac92xx_free(codec);
3376                         return err;
3377                 }
3378                 spec->pin_configs = spec->bios_pin_configs;
3379         } else {
3380                 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3381                 stac92xx_set_config_regs(codec);
3382         }
3383
3384         switch (codec->vendor_id) {
3385         case 0x111d76b6: /* 4 Port without Analog Mixer */
3386         case 0x111d76b7:
3387         case 0x111d76b4: /* 6 Port without Analog Mixer */
3388         case 0x111d76b5:
3389                 spec->mixer = stac92hd71bxx_mixer;
3390                 spec->init = stac92hd71bxx_core_init;
3391                 break;
3392         default:
3393                 spec->mixer = stac92hd71bxx_analog_mixer;
3394                 spec->init = stac92hd71bxx_analog_core_init;
3395         }
3396
3397         spec->aloopback_mask = 0x20;
3398         spec->aloopback_shift = 0;
3399
3400         /* GPIO0 High = EAPD */
3401         spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0x1;
3402
3403         spec->mux_nids = stac92hd71bxx_mux_nids;
3404         spec->adc_nids = stac92hd71bxx_adc_nids;
3405         spec->dmic_nids = stac92hd71bxx_dmic_nids;
3406         spec->dmux_nids = stac92hd71bxx_dmux_nids;
3407
3408         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3409         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3410         spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3411         spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3412
3413         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
3414         spec->pwr_nids = stac92hd71bxx_pwr_nids;
3415
3416         spec->multiout.num_dacs = 2;
3417         spec->multiout.hp_nid = 0x11;
3418         spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3419
3420         err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3421         if (!err) {
3422                 if (spec->board_config < 0) {
3423                         printk(KERN_WARNING "hda_codec: No auto-config is "
3424                                "available, default to model=ref\n");
3425                         spec->board_config = STAC_92HD71BXX_REF;
3426                         goto again;
3427                 }
3428                 err = -EINVAL;
3429         }
3430
3431         if (err < 0) {
3432                 stac92xx_free(codec);
3433                 return err;
3434         }
3435
3436         codec->patch_ops = stac92xx_patch_ops;
3437
3438         return 0;
3439 };
3440
3441 static int patch_stac922x(struct hda_codec *codec)
3442 {
3443         struct sigmatel_spec *spec;
3444         int err;
3445
3446         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3447         if (spec == NULL)
3448                 return -ENOMEM;
3449
3450         codec->spec = spec;
3451         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3452         spec->pin_nids = stac922x_pin_nids;
3453         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3454                                                         stac922x_models,
3455                                                         stac922x_cfg_tbl);
3456         if (spec->board_config == STAC_INTEL_MAC_V3) {
3457                 spec->gpio_mask = spec->gpio_dir = 0x03;
3458                 spec->gpio_data = 0x03;
3459                 /* Intel Macs have all same PCI SSID, so we need to check
3460                  * codec SSID to distinguish the exact models
3461                  */
3462                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3463                 switch (codec->subsystem_id) {
3464
3465                 case 0x106b0800:
3466                         spec->board_config = STAC_INTEL_MAC_V1;
3467                         break;
3468                 case 0x106b0600:
3469                 case 0x106b0700:
3470                         spec->board_config = STAC_INTEL_MAC_V2;
3471                         break;
3472                 case 0x106b0e00:
3473                 case 0x106b0f00:
3474                 case 0x106b1600:
3475                 case 0x106b1700:
3476                 case 0x106b0200:
3477                 case 0x106b1e00:
3478                         spec->board_config = STAC_INTEL_MAC_V3;
3479                         break;
3480                 case 0x106b1a00:
3481                 case 0x00000100:
3482                         spec->board_config = STAC_INTEL_MAC_V4;
3483                         break;
3484                 case 0x106b0a00:
3485                 case 0x106b2200:
3486                         spec->board_config = STAC_INTEL_MAC_V5;
3487                         break;
3488                 }
3489         }
3490
3491  again:
3492         if (spec->board_config < 0) {
3493                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3494                         "using BIOS defaults\n");
3495                 err = stac92xx_save_bios_config_regs(codec);
3496                 if (err < 0) {
3497                         stac92xx_free(codec);
3498                         return err;
3499                 }
3500                 spec->pin_configs = spec->bios_pin_configs;
3501         } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3502                 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3503                 stac92xx_set_config_regs(codec);
3504         }
3505
3506         spec->adc_nids = stac922x_adc_nids;
3507         spec->mux_nids = stac922x_mux_nids;
3508         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3509         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3510         spec->num_dmics = 0;
3511         spec->num_pwrs = 0;
3512
3513         spec->init = stac922x_core_init;
3514         spec->mixer = stac922x_mixer;
3515
3516         spec->multiout.dac_nids = spec->dac_nids;
3517
3518         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3519         if (!err) {
3520                 if (spec->board_config < 0) {
3521                         printk(KERN_WARNING "hda_codec: No auto-config is "
3522                                "available, default to model=ref\n");
3523                         spec->board_config = STAC_D945_REF;
3524                         goto again;
3525                 }
3526                 err = -EINVAL;
3527         }
3528         if (err < 0) {
3529                 stac92xx_free(codec);
3530                 return err;
3531         }
3532
3533         codec->patch_ops = stac92xx_patch_ops;
3534
3535         /* Fix Mux capture level; max to 2 */
3536         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3537                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
3538                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3539                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3540                                   (0 << AC_AMPCAP_MUTE_SHIFT));
3541
3542         return 0;
3543 }
3544
3545 static int patch_stac927x(struct hda_codec *codec)
3546 {
3547         struct sigmatel_spec *spec;
3548         int err;
3549
3550         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3551         if (spec == NULL)
3552                 return -ENOMEM;
3553
3554         codec->spec = spec;
3555         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3556         spec->pin_nids = stac927x_pin_nids;
3557         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3558                                                         stac927x_models,
3559                                                         stac927x_cfg_tbl);
3560  again:
3561         if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3562                 if (spec->board_config < 0)
3563                         snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3564                                     "STAC927x, using BIOS defaults\n");
3565                 err = stac92xx_save_bios_config_regs(codec);
3566                 if (err < 0) {
3567                         stac92xx_free(codec);
3568                         return err;
3569                 }
3570                 spec->pin_configs = spec->bios_pin_configs;
3571         } else {
3572                 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3573                 stac92xx_set_config_regs(codec);
3574         }
3575
3576         spec->adc_nids = stac927x_adc_nids;
3577         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3578         spec->mux_nids = stac927x_mux_nids;
3579         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3580         spec->multiout.dac_nids = spec->dac_nids;
3581
3582         switch (spec->board_config) {
3583         case STAC_D965_3ST:
3584         case STAC_D965_5ST:
3585                 /* GPIO0 High = Enable EAPD */
3586                 spec->gpio_mask = spec->gpio_dir = 0x01;
3587                 spec->gpio_data = 0x01;
3588                 spec->num_dmics = 0;
3589
3590                 spec->init = d965_core_init;
3591                 spec->mixer = stac927x_mixer;
3592                 break;
3593         case STAC_DELL_BIOS:
3594                 /* correct the front output jack as a hp out */
3595                 stac92xx_set_config_reg(codec, 0x0f, 0x02270110);
3596                 /* correct the front input jack as a mic */
3597                 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
3598                 /* fallthru */
3599         case STAC_DELL_3ST:
3600                 /* GPIO2 High = Enable EAPD */
3601                 spec->gpio_mask = spec->gpio_dir = 0x04;
3602                 spec->gpio_data = 0x04;
3603                 spec->dmic_nids = stac927x_dmic_nids;
3604                 spec->num_dmics = STAC927X_NUM_DMICS;
3605
3606                 spec->init = d965_core_init;
3607                 spec->mixer = stac927x_mixer;
3608                 spec->dmux_nids = stac927x_dmux_nids;
3609                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3610                 break;
3611         default:
3612                 /* GPIO0 High = Enable EAPD */
3613                 spec->gpio_mask = spec->gpio_dir = 0x1;
3614                 spec->gpio_data = 0x01;
3615                 spec->num_dmics = 0;
3616
3617                 spec->init = stac927x_core_init;
3618                 spec->mixer = stac927x_mixer;
3619         }
3620
3621         spec->num_pwrs = 0;
3622         spec->aloopback_mask = 0x40;
3623         spec->aloopback_shift = 0;
3624
3625         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3626         if (!err) {
3627                 if (spec->board_config < 0) {
3628                         printk(KERN_WARNING "hda_codec: No auto-config is "
3629                                "available, default to model=ref\n");
3630                         spec->board_config = STAC_D965_REF;
3631                         goto again;
3632                 }
3633                 err = -EINVAL;
3634         }
3635         if (err < 0) {
3636                 stac92xx_free(codec);
3637                 return err;
3638         }
3639
3640         codec->patch_ops = stac92xx_patch_ops;
3641
3642         /*
3643          * !!FIXME!!
3644          * The STAC927x seem to require fairly long delays for certain
3645          * command sequences.  With too short delays (even if the answer
3646          * is set to RIRB properly), it results in the silence output
3647          * on some hardwares like Dell.
3648          *
3649          * The below flag enables the longer delay (see get_response
3650          * in hda_intel.c).
3651          */
3652         codec->bus->needs_damn_long_delay = 1;
3653
3654         return 0;
3655 }
3656
3657 static int patch_stac9205(struct hda_codec *codec)
3658 {
3659         struct sigmatel_spec *spec;
3660         int err;
3661
3662         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3663         if (spec == NULL)
3664                 return -ENOMEM;
3665
3666         codec->spec = spec;
3667         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3668         spec->pin_nids = stac9205_pin_nids;
3669         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3670                                                         stac9205_models,
3671                                                         stac9205_cfg_tbl);
3672  again:
3673         if (spec->board_config < 0) {
3674                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3675                 err = stac92xx_save_bios_config_regs(codec);
3676                 if (err < 0) {
3677                         stac92xx_free(codec);
3678                         return err;
3679                 }
3680                 spec->pin_configs = spec->bios_pin_configs;
3681         } else {
3682                 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3683                 stac92xx_set_config_regs(codec);
3684         }
3685
3686         spec->adc_nids = stac9205_adc_nids;
3687         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3688         spec->mux_nids = stac9205_mux_nids;
3689         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3690         spec->dmic_nids = stac9205_dmic_nids;
3691         spec->num_dmics = STAC9205_NUM_DMICS;
3692         spec->dmux_nids = stac9205_dmux_nids;
3693         spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3694         spec->num_pwrs = 0;
3695
3696         spec->init = stac9205_core_init;
3697         spec->mixer = stac9205_mixer;
3698
3699         spec->aloopback_mask = 0x40;
3700         spec->aloopback_shift = 0;
3701         spec->multiout.dac_nids = spec->dac_nids;
3702
3703         switch (spec->board_config){
3704         case STAC_9205_DELL_M43:
3705                 /* Enable SPDIF in/out */
3706                 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3707                 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3708
3709                 /* Enable unsol response for GPIO4/Dock HP connection */
3710                 snd_hda_codec_write(codec, codec->afg, 0,
3711                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
3712                 snd_hda_codec_write_cache(codec, codec->afg, 0,
3713                                           AC_VERB_SET_UNSOLICITED_ENABLE,
3714                                           (AC_USRSP_EN | STAC_HP_EVENT));
3715
3716                 spec->gpio_dir = 0x0b;
3717                 spec->gpio_mask = 0x1b;
3718                 spec->gpio_mute = 0x10;
3719                 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
3720                  * GPIO3 Low = DRM
3721                  */
3722                 spec->gpio_data = 0x01;
3723                 break;
3724         default:
3725                 /* GPIO0 High = EAPD */
3726                 spec->gpio_mask = spec->gpio_dir = 0x1;
3727                 spec->gpio_data = 0x01;
3728                 break;
3729         }
3730
3731         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3732         if (!err) {
3733                 if (spec->board_config < 0) {
3734                         printk(KERN_WARNING "hda_codec: No auto-config is "
3735                                "available, default to model=ref\n");
3736                         spec->board_config = STAC_9205_REF;
3737                         goto again;
3738                 }
3739                 err = -EINVAL;
3740         }
3741         if (err < 0) {
3742                 stac92xx_free(codec);
3743                 return err;
3744         }
3745
3746         codec->patch_ops = stac92xx_patch_ops;
3747
3748         return 0;
3749 }
3750
3751 /*
3752  * STAC9872 hack
3753  */
3754
3755 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3756 static hda_nid_t vaio_dacs[] = { 0x2 };
3757 #define VAIO_HP_DAC     0x5
3758 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3759 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3760
3761 static struct hda_input_mux vaio_mux = {
3762         .num_items = 3,
3763         .items = {
3764                 /* { "HP", 0x0 }, */
3765                 { "Mic Jack", 0x1 },
3766                 { "Internal Mic", 0x2 },
3767                 { "PCM", 0x3 },
3768         }
3769 };
3770
3771 static struct hda_verb vaio_init[] = {
3772         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3773         {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3774         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3775         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3776         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3777         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3778         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3779         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3780         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3781         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3782         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3783         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3784         {}
3785 };
3786
3787 static struct hda_verb vaio_ar_init[] = {
3788         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3789         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3790         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3791         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3792 /*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3793         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3794         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3795         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3796         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3797 /*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3798         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3799         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3801         {}
3802 };
3803
3804 /* bind volumes of both NID 0x02 and 0x05 */
3805 static struct hda_bind_ctls vaio_bind_master_vol = {
3806         .ops = &snd_hda_bind_vol,
3807         .values = {
3808                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3809                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3810                 0
3811         },
3812 };
3813
3814 /* bind volumes of both NID 0x02 and 0x05 */
3815 static struct hda_bind_ctls vaio_bind_master_sw = {
3816         .ops = &snd_hda_bind_sw,
3817         .values = {
3818                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3819                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3820                 0,
3821         },
3822 };
3823
3824 static struct snd_kcontrol_new vaio_mixer[] = {
3825         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3826         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3827         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3828         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3829         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3830         {
3831                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3832                 .name = "Capture Source",
3833                 .count = 1,
3834                 .info = stac92xx_mux_enum_info,
3835                 .get = stac92xx_mux_enum_get,
3836                 .put = stac92xx_mux_enum_put,
3837         },
3838         {}
3839 };
3840
3841 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3842         HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3843         HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3844         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3845         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3846         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3847         /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3848         HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3849         {
3850                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3851                 .name = "Capture Source",
3852                 .count = 1,
3853                 .info = stac92xx_mux_enum_info,
3854                 .get = stac92xx_mux_enum_get,
3855                 .put = stac92xx_mux_enum_put,
3856         },
3857         {}
3858 };
3859
3860 static struct hda_codec_ops stac9872_patch_ops = {
3861         .build_controls = stac92xx_build_controls,
3862         .build_pcms = stac92xx_build_pcms,
3863         .init = stac92xx_init,
3864         .free = stac92xx_free,
3865 #ifdef SND_HDA_NEEDS_RESUME
3866         .resume = stac92xx_resume,
3867 #endif
3868 };
3869
3870 static int stac9872_vaio_init(struct hda_codec *codec)
3871 {
3872         int err;
3873
3874         err = stac92xx_init(codec);
3875         if (err < 0)
3876                 return err;
3877         if (codec->patch_ops.unsol_event)
3878                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3879         return 0;
3880 }
3881
3882 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3883 {
3884         if (get_hp_pin_presence(codec, 0x0a)) {
3885                 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3886                 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3887         } else {
3888                 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3889                 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3890         }
3891 }
3892
3893 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3894 {
3895         switch (res >> 26) {
3896         case STAC_HP_EVENT:
3897                 stac9872_vaio_hp_detect(codec, res);
3898                 break;
3899         }
3900 }
3901
3902 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3903         .build_controls = stac92xx_build_controls,
3904         .build_pcms = stac92xx_build_pcms,
3905         .init = stac9872_vaio_init,
3906         .free = stac92xx_free,
3907         .unsol_event = stac9872_vaio_unsol_event,
3908 #ifdef CONFIG_PM
3909         .resume = stac92xx_resume,
3910 #endif
3911 };
3912
3913 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3914        CXD9872RD_VAIO,
3915        /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3916        STAC9872AK_VAIO,
3917        /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3918        STAC9872K_VAIO,
3919        /* AR Series. id=0x83847664 and subsys=104D1300 */
3920        CXD9872AKD_VAIO,
3921        STAC_9872_MODELS,
3922 };
3923
3924 static const char *stac9872_models[STAC_9872_MODELS] = {
3925         [CXD9872RD_VAIO]        = "vaio",
3926         [CXD9872AKD_VAIO]       = "vaio-ar",
3927 };
3928
3929 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3930         SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3931         SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3932         SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3933         SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3934         {}
3935 };
3936
3937 static int patch_stac9872(struct hda_codec *codec)
3938 {
3939         struct sigmatel_spec *spec;
3940         int board_config;
3941
3942         board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3943                                                   stac9872_models,
3944                                                   stac9872_cfg_tbl);
3945         if (board_config < 0)
3946                 /* unknown config, let generic-parser do its job... */
3947                 return snd_hda_parse_generic_codec(codec);
3948
3949         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
3950         if (spec == NULL)
3951                 return -ENOMEM;
3952
3953         codec->spec = spec;
3954         switch (board_config) {
3955         case CXD9872RD_VAIO:
3956         case STAC9872AK_VAIO:
3957         case STAC9872K_VAIO:
3958                 spec->mixer = vaio_mixer;
3959                 spec->init = vaio_init;
3960                 spec->multiout.max_channels = 2;
3961                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3962                 spec->multiout.dac_nids = vaio_dacs;
3963                 spec->multiout.hp_nid = VAIO_HP_DAC;
3964                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3965                 spec->adc_nids = vaio_adcs;
3966                 spec->num_pwrs = 0;
3967                 spec->input_mux = &vaio_mux;
3968                 spec->mux_nids = vaio_mux_nids;
3969                 codec->patch_ops = stac9872_vaio_patch_ops;
3970                 break;
3971
3972         case CXD9872AKD_VAIO:
3973                 spec->mixer = vaio_ar_mixer;
3974                 spec->init = vaio_ar_init;
3975                 spec->multiout.max_channels = 2;
3976                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3977                 spec->multiout.dac_nids = vaio_dacs;
3978                 spec->multiout.hp_nid = VAIO_HP_DAC;
3979                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3980                 spec->num_pwrs = 0;
3981                 spec->adc_nids = vaio_adcs;
3982                 spec->input_mux = &vaio_mux;
3983                 spec->mux_nids = vaio_mux_nids;
3984                 codec->patch_ops = stac9872_patch_ops;
3985                 break;
3986         }
3987
3988         return 0;
3989 }
3990
3991
3992 /*
3993  * patch entries
3994  */
3995 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3996         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3997         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3998         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3999         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
4000         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
4001         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
4002         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
4003         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
4004         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
4005         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
4006         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
4007         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
4008         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
4009         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
4010         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
4011         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
4012         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
4013         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
4014         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
4015         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
4016         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
4017         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
4018         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
4019         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
4020         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
4021         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
4022         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
4023         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
4024         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
4025         /* The following does not take into account .id=0x83847661 when subsys =
4026          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
4027          * currently not fully supported.
4028          */
4029         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
4030         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
4031         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
4032         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
4033         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
4034         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
4035         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
4036         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
4037         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
4038         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
4039         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
4040         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
4041         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
4042         { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
4043         { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
4044         { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
4045         { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
4046         { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
4047         { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
4048         { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
4049         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
4050         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
4051         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
4052         {} /* terminator */
4053 };