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