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 <sound/jack.h>
  34 #include "hda_codec.h"
  35 #include "hda_local.h"
  36 #include "hda_beep.h"
  37
  38 enum {
  39         STAC_VREF_EVENT = 1,
  40         STAC_INSERT_EVENT,
  41         STAC_PWR_EVENT,
  42         STAC_HP_EVENT,
  43 };
  44
  45 enum {
  46         STAC_REF,
  47         STAC_9200_OQO,
  48         STAC_9200_DELL_D21,
  49         STAC_9200_DELL_D22,
  50         STAC_9200_DELL_D23,
  51         STAC_9200_DELL_M21,
  52         STAC_9200_DELL_M22,
  53         STAC_9200_DELL_M23,
  54         STAC_9200_DELL_M24,
  55         STAC_9200_DELL_M25,
  56         STAC_9200_DELL_M26,
  57         STAC_9200_DELL_M27,
  58         STAC_9200_M4,
  59         STAC_9200_M4_2,
  60         STAC_9200_PANASONIC,
  61         STAC_9200_MODELS
  62 };
  63
  64 enum {
  65         STAC_9205_REF,
  66         STAC_9205_DELL_M42,
  67         STAC_9205_DELL_M43,
  68         STAC_9205_DELL_M44,
  69         STAC_9205_MODELS
  70 };
  71
  72 enum {
  73         STAC_92HD73XX_NO_JD, /* no jack-detection */
  74         STAC_92HD73XX_REF,
  75         STAC_DELL_M6_AMIC,
  76         STAC_DELL_M6_DMIC,
  77         STAC_DELL_M6_BOTH,
  78         STAC_DELL_EQ,
  79         STAC_92HD73XX_MODELS
  80 };
  81
  82 enum {
  83         STAC_92HD83XXX_REF,
  84         STAC_92HD83XXX_PWR_REF,
  85         STAC_92HD83XXX_MODELS
  86 };
  87
  88 enum {
  89         STAC_92HD71BXX_REF,
  90         STAC_DELL_M4_1,
  91         STAC_DELL_M4_2,
  92         STAC_DELL_M4_3,
  93         STAC_HP_M4,
  94         STAC_HP_DV5,
  95         STAC_92HD71BXX_MODELS
  96 };
  97
  98 enum {
  99         STAC_925x_REF,
 100         STAC_M1,
 101         STAC_M1_2,
 102         STAC_M2,
 103         STAC_M2_2,
 104         STAC_M3,
 105         STAC_M5,
 106         STAC_M6,
 107         STAC_925x_MODELS
 108 };
 109
 110 enum {
 111         STAC_D945_REF,
 112         STAC_D945GTP3,
 113         STAC_D945GTP5,
 114         STAC_INTEL_MAC_V1,
 115         STAC_INTEL_MAC_V2,
 116         STAC_INTEL_MAC_V3,
 117         STAC_INTEL_MAC_V4,
 118         STAC_INTEL_MAC_V5,
 119         STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
 120                               * is given, one of the above models will be
 121                               * chosen according to the subsystem id. */
 122         /* for backward compatibility */
 123         STAC_MACMINI,
 124         STAC_MACBOOK,
 125         STAC_MACBOOK_PRO_V1,
 126         STAC_MACBOOK_PRO_V2,
 127         STAC_IMAC_INTEL,
 128         STAC_IMAC_INTEL_20,
 129         STAC_ECS_202,
 130         STAC_922X_DELL_D81,
 131         STAC_922X_DELL_D82,
 132         STAC_922X_DELL_M81,
 133         STAC_922X_DELL_M82,
 134         STAC_922X_MODELS
 135 };
 136
 137 enum {
 138         STAC_D965_REF_NO_JD, /* no jack-detection */
 139         STAC_D965_REF,
 140         STAC_D965_3ST,
 141         STAC_D965_5ST,
 142         STAC_DELL_3ST,
 143         STAC_DELL_BIOS,
 144         STAC_927X_MODELS
 145 };
 146
 147 struct sigmatel_event {
 148         hda_nid_t nid;
 149         unsigned char type;
 150         unsigned char tag;
 151         int data;
 152 };
 153
 154 struct sigmatel_jack {
 155         hda_nid_t nid;
 156         int type;
 157         struct snd_jack *jack;
 158 };
 159
 160 struct sigmatel_spec {
 161         struct snd_kcontrol_new *mixers[4];
 162         unsigned int num_mixers;
 163
 164         int board_config;
 165         unsigned int eapd_switch: 1;
 166         unsigned int surr_switch: 1;
 167         unsigned int alt_switch: 1;
 168         unsigned int hp_detect: 1;
 169         unsigned int spdif_mute: 1;
 170
 171         /* gpio lines */
 172         unsigned int eapd_mask;
 173         unsigned int gpio_mask;
 174         unsigned int gpio_dir;
 175         unsigned int gpio_data;
 176         unsigned int gpio_mute;
 177
 178         /* stream */
 179         unsigned int stream_delay;
 180
 181         /* analog loopback */
 182         unsigned char aloopback_mask;
 183         unsigned char aloopback_shift;
 184
 185         /* power management */
 186         unsigned int num_pwrs;
 187         unsigned int *pwr_mapping;
 188         hda_nid_t *pwr_nids;
 189         hda_nid_t *dac_list;
 190
 191         /* jack detection */
 192         struct snd_array jacks;
 193
 194         /* events */
 195         struct snd_array events;
 196
 197         /* playback */
 198         struct hda_input_mux *mono_mux;
 199         struct hda_input_mux *amp_mux;
 200         unsigned int cur_mmux;
 201         struct hda_multi_out multiout;
 202         hda_nid_t dac_nids[5];
 203         hda_nid_t hp_dacs[5];
 204         hda_nid_t speaker_dacs[5];
 205
 206         /* capture */
 207         hda_nid_t *adc_nids;
 208         unsigned int num_adcs;
 209         hda_nid_t *mux_nids;
 210         unsigned int num_muxes;
 211         hda_nid_t *dmic_nids;
 212         unsigned int num_dmics;
 213         hda_nid_t *dmux_nids;
 214         unsigned int num_dmuxes;
 215         hda_nid_t *smux_nids;
 216         unsigned int num_smuxes;
 217         const char **spdif_labels;
 218
 219         hda_nid_t dig_in_nid;
 220         hda_nid_t mono_nid;
 221         hda_nid_t anabeep_nid;
 222         hda_nid_t digbeep_nid;
 223
 224         /* pin widgets */
 225         hda_nid_t *pin_nids;
 226         unsigned int num_pins;
 227         unsigned int *pin_configs;
 228
 229         /* codec specific stuff */
 230         struct hda_verb *init;
 231         struct snd_kcontrol_new *mixer;
 232
 233         /* capture source */
 234         struct hda_input_mux *dinput_mux;
 235         unsigned int cur_dmux[2];
 236         struct hda_input_mux *input_mux;
 237         unsigned int cur_mux[3];
 238         struct hda_input_mux *sinput_mux;
 239         unsigned int cur_smux[2];
 240         unsigned int cur_amux;
 241         hda_nid_t *amp_nids;
 242         unsigned int num_amps;
 243         unsigned int powerdown_adcs;
 244
 245         /* i/o switches */
 246         unsigned int io_switch[2];
 247         unsigned int clfe_swap;
 248         hda_nid_t line_switch;  /* shared line-in for input and output */
 249         hda_nid_t mic_switch;   /* shared mic-in for input and output */
 250         hda_nid_t hp_switch; /* NID of HP as line-out */
 251         unsigned int aloopback;
 252
 253         struct hda_pcm pcm_rec[2];      /* PCM information */
 254
 255         /* dynamic controls and input_mux */
 256         struct auto_pin_cfg autocfg;
 257         struct snd_array kctls;
 258         struct hda_input_mux private_dimux;
 259         struct hda_input_mux private_imux;
 260         struct hda_input_mux private_smux;
 261         struct hda_input_mux private_amp_mux;
 262         struct hda_input_mux private_mono_mux;
 263 };
 264
 265 static hda_nid_t stac9200_adc_nids[1] = {
 266         0x03,
 267 };
 268
 269 static hda_nid_t stac9200_mux_nids[1] = {
 270         0x0c,
 271 };
 272
 273 static hda_nid_t stac9200_dac_nids[1] = {
 274         0x02,
 275 };
 276
 277 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
 278         0x0a, 0x0b, 0x0c, 0xd, 0x0e,
 279         0x0f, 0x10, 0x11
 280 };
 281
 282 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
 283         0x26, 0,
 284 };
 285
 286 static hda_nid_t stac92hd73xx_adc_nids[2] = {
 287         0x1a, 0x1b
 288 };
 289
 290 #define DELL_M6_AMP 2
 291 static hda_nid_t stac92hd73xx_amp_nids[3] = {
 292         0x0b, 0x0c, 0x0e
 293 };
 294
 295 #define STAC92HD73XX_NUM_DMICS  2
 296 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
 297         0x13, 0x14, 0
 298 };
 299
 300 #define STAC92HD73_DAC_COUNT 5
 301
 302 static hda_nid_t stac92hd73xx_mux_nids[4] = {
 303         0x28, 0x29, 0x2a, 0x2b,
 304 };
 305
 306 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
 307         0x20, 0x21,
 308 };
 309
 310 static hda_nid_t stac92hd73xx_smux_nids[2] = {
 311         0x22, 0x23,
 312 };
 313
 314 #define STAC92HD83XXX_NUM_DMICS 2
 315 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
 316         0x11, 0x12, 0
 317 };
 318
 319 #define STAC92HD83_DAC_COUNT 3
 320
 321 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
 322         0x17, 0x18,
 323 };
 324
 325 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
 326         0x15, 0x16,
 327 };
 328
 329 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
 330         0xa, 0xb, 0xd, 0xe,
 331 };
 332
 333 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
 334         0x1e, 0,
 335 };
 336
 337 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
 338         0x03, 0x0c, 0x20, 0x40,
 339 };
 340
 341 static hda_nid_t stac92hd83xxx_amp_nids[1] = {
 342         0xc,
 343 };
 344
 345 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
 346         0x0a, 0x0d, 0x0f
 347 };
 348
 349 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
 350         0x12, 0x13,
 351 };
 352
 353 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
 354         0x1a, 0x1b
 355 };
 356
 357 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
 358         0x1c, 0x1d,
 359 };
 360
 361 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
 362         0x24, 0x25,
 363 };
 364
 365 #define STAC92HD71BXX_NUM_DMICS 2
 366 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
 367         0x18, 0x19, 0
 368 };
 369
 370 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
 371         0x22, 0
 372 };
 373
 374 static hda_nid_t stac925x_adc_nids[1] = {
 375         0x03,
 376 };
 377
 378 static hda_nid_t stac925x_mux_nids[1] = {
 379         0x0f,
 380 };
 381
 382 static hda_nid_t stac925x_dac_nids[1] = {
 383         0x02,
 384 };
 385
 386 #define STAC925X_NUM_DMICS      1
 387 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
 388         0x15, 0
 389 };
 390
 391 static hda_nid_t stac925x_dmux_nids[1] = {
 392         0x14,
 393 };
 394
 395 static hda_nid_t stac922x_adc_nids[2] = {
 396         0x06, 0x07,
 397 };
 398
 399 static hda_nid_t stac922x_mux_nids[2] = {
 400         0x12, 0x13,
 401 };
 402
 403 static hda_nid_t stac927x_adc_nids[3] = {
 404         0x07, 0x08, 0x09
 405 };
 406
 407 static hda_nid_t stac927x_mux_nids[3] = {
 408         0x15, 0x16, 0x17
 409 };
 410
 411 static hda_nid_t stac927x_smux_nids[1] = {
 412         0x21,
 413 };
 414
 415 static hda_nid_t stac927x_dac_nids[6] = {
 416         0x02, 0x03, 0x04, 0x05, 0x06, 0
 417 };
 418
 419 static hda_nid_t stac927x_dmux_nids[1] = {
 420         0x1b,
 421 };
 422
 423 #define STAC927X_NUM_DMICS 2
 424 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
 425         0x13, 0x14, 0
 426 };
 427
 428 static const char *stac927x_spdif_labels[5] = {
 429         "Digital Playback", "ADAT", "Analog Mux 1",
 430         "Analog Mux 2", "Analog Mux 3"
 431 };
 432
 433 static hda_nid_t stac9205_adc_nids[2] = {
 434         0x12, 0x13
 435 };
 436
 437 static hda_nid_t stac9205_mux_nids[2] = {
 438         0x19, 0x1a
 439 };
 440
 441 static hda_nid_t stac9205_dmux_nids[1] = {
 442         0x1d,
 443 };
 444
 445 static hda_nid_t stac9205_smux_nids[1] = {
 446         0x21,
 447 };
 448
 449 #define STAC9205_NUM_DMICS      2
 450 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
 451         0x17, 0x18, 0
 452 };
 453
 454 static hda_nid_t stac9200_pin_nids[8] = {
 455         0x08, 0x09, 0x0d, 0x0e,
 456         0x0f, 0x10, 0x11, 0x12,
 457 };
 458
 459 static hda_nid_t stac925x_pin_nids[8] = {
 460         0x07, 0x08, 0x0a, 0x0b,
 461         0x0c, 0x0d, 0x10, 0x11,
 462 };
 463
 464 static hda_nid_t stac922x_pin_nids[10] = {
 465         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 466         0x0f, 0x10, 0x11, 0x15, 0x1b,
 467 };
 468
 469 static hda_nid_t stac92hd73xx_pin_nids[13] = {
 470         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 471         0x0f, 0x10, 0x11, 0x12, 0x13,
 472         0x14, 0x22, 0x23
 473 };
 474
 475 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
 476         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 477         0x0f, 0x10, 0x11, 0x12, 0x13,
 478         0x1d, 0x1e, 0x1f, 0x20
 479 };
 480 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
 481         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 482         0x0f, 0x14, 0x18, 0x19, 0x1e,
 483         0x1f,
 484 };
 485
 486 static hda_nid_t stac927x_pin_nids[14] = {
 487         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 488         0x0f, 0x10, 0x11, 0x12, 0x13,
 489         0x14, 0x21, 0x22, 0x23,
 490 };
 491
 492 static hda_nid_t stac9205_pin_nids[12] = {
 493         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 494         0x0f, 0x14, 0x16, 0x17, 0x18,
 495         0x21, 0x22,
 496 };
 497
 498 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
 499
 500 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
 501                                  struct snd_ctl_elem_value *ucontrol)
 502 {
 503         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 504         struct sigmatel_spec *spec = codec->spec;
 505         hda_nid_t nid = spec->amp_nids[spec->cur_amux];
 506
 507         kcontrol->private_value ^= get_amp_nid(kcontrol);
 508         kcontrol->private_value |= nid;
 509
 510         return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
 511 }
 512
 513 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
 514                                  struct snd_ctl_elem_value *ucontrol)
 515 {
 516         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 517         struct sigmatel_spec *spec = codec->spec;
 518         hda_nid_t nid = spec->amp_nids[spec->cur_amux];
 519
 520         kcontrol->private_value ^= get_amp_nid(kcontrol);
 521         kcontrol->private_value |= nid;
 522
 523         return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
 524 }
 525
 526 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
 527                                    struct snd_ctl_elem_info *uinfo)
 528 {
 529         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 530         struct sigmatel_spec *spec = codec->spec;
 531         return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
 532 }
 533
 534 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
 535                                   struct snd_ctl_elem_value *ucontrol)
 536 {
 537         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 538         struct sigmatel_spec *spec = codec->spec;
 539         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 540
 541         ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
 542         return 0;
 543 }
 544
 545 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
 546                                   struct snd_ctl_elem_value *ucontrol)
 547 {
 548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 549         struct sigmatel_spec *spec = codec->spec;
 550         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 551
 552         return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
 553                         spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
 554 }
 555
 556 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
 557                                    struct snd_ctl_elem_info *uinfo)
 558 {
 559         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 560         struct sigmatel_spec *spec = codec->spec;
 561         return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
 562 }
 563
 564 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
 565                                   struct snd_ctl_elem_value *ucontrol)
 566 {
 567         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 568         struct sigmatel_spec *spec = codec->spec;
 569         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 570
 571         ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
 572         return 0;
 573 }
 574
 575 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
 576                                   struct snd_ctl_elem_value *ucontrol)
 577 {
 578         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 579         struct sigmatel_spec *spec = codec->spec;
 580         struct hda_input_mux *smux = &spec->private_smux;
 581         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 582         int err, val;
 583         hda_nid_t nid;
 584
 585         err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
 586                         spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
 587         if (err < 0)
 588                 return err;
 589
 590         if (spec->spdif_mute) {
 591                 if (smux_idx == 0)
 592                         nid = spec->multiout.dig_out_nid;
 593                 else
 594                         nid = codec->slave_dig_outs[smux_idx - 1];
 595                 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
 596                         val = HDA_AMP_MUTE;
 597                 else
 598                         val = 0;
 599                 /* un/mute SPDIF out */
 600                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 601                                          HDA_AMP_MUTE, val);
 602         }
 603         return 0;
 604 }
 605
 606 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 607 {
 608         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 609         struct sigmatel_spec *spec = codec->spec;
 610         return snd_hda_input_mux_info(spec->input_mux, uinfo);
 611 }
 612
 613 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 614 {
 615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 616         struct sigmatel_spec *spec = codec->spec;
 617         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 618
 619         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 620         return 0;
 621 }
 622
 623 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 624 {
 625         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 626         struct sigmatel_spec *spec = codec->spec;
 627         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 628
 629         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 630                                      spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
 631 }
 632
 633 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
 634         struct snd_ctl_elem_info *uinfo)
 635 {
 636         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 637         struct sigmatel_spec *spec = codec->spec;
 638         return snd_hda_input_mux_info(spec->mono_mux, uinfo);
 639 }
 640
 641 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
 642         struct snd_ctl_elem_value *ucontrol)
 643 {
 644         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 645         struct sigmatel_spec *spec = codec->spec;
 646
 647         ucontrol->value.enumerated.item[0] = spec->cur_mmux;
 648         return 0;
 649 }
 650
 651 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
 652         struct snd_ctl_elem_value *ucontrol)
 653 {
 654         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 655         struct sigmatel_spec *spec = codec->spec;
 656
 657         return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
 658                                      spec->mono_nid, &spec->cur_mmux);
 659 }
 660
 661 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
 662         struct snd_ctl_elem_info *uinfo)
 663 {
 664         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 665         struct sigmatel_spec *spec = codec->spec;
 666         return snd_hda_input_mux_info(spec->amp_mux, uinfo);
 667 }
 668
 669 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
 670         struct snd_ctl_elem_value *ucontrol)
 671 {
 672         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 673         struct sigmatel_spec *spec = codec->spec;
 674
 675         ucontrol->value.enumerated.item[0] = spec->cur_amux;
 676         return 0;
 677 }
 678
 679 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
 680         struct snd_ctl_elem_value *ucontrol)
 681 {
 682         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 683         struct sigmatel_spec *spec = codec->spec;
 684         struct snd_kcontrol *ctl =
 685                 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
 686         if (!ctl)
 687                 return -EINVAL;
 688
 689         snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
 690                 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
 691
 692         return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
 693                                      0, &spec->cur_amux);
 694 }
 695
 696 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
 697
 698 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
 699         struct snd_ctl_elem_value *ucontrol)
 700 {
 701         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 702         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 703         struct sigmatel_spec *spec = codec->spec;
 704
 705         ucontrol->value.integer.value[0] = !!(spec->aloopback &
 706                                               (spec->aloopback_mask << idx));
 707         return 0;
 708 }
 709
 710 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
 711                 struct snd_ctl_elem_value *ucontrol)
 712 {
 713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 714         struct sigmatel_spec *spec = codec->spec;
 715         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 716         unsigned int dac_mode;
 717         unsigned int val, idx_val;
 718
 719         idx_val = spec->aloopback_mask << idx;
 720         if (ucontrol->value.integer.value[0])
 721                 val = spec->aloopback | idx_val;
 722         else
 723                 val = spec->aloopback & ~idx_val;
 724         if (spec->aloopback == val)
 725                 return 0;
 726
 727         spec->aloopback = val;
 728
 729         /* Only return the bits defined by the shift value of the
 730          * first two bytes of the mask
 731          */
 732         dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
 733                                       kcontrol->private_value & 0xFFFF, 0x0);
 734         dac_mode >>= spec->aloopback_shift;
 735
 736         if (spec->aloopback & idx_val) {
 737                 snd_hda_power_up(codec);
 738                 dac_mode |= idx_val;
 739         } else {
 740                 snd_hda_power_down(codec);
 741                 dac_mode &= ~idx_val;
 742         }
 743
 744         snd_hda_codec_write_cache(codec, codec->afg, 0,
 745                 kcontrol->private_value >> 16, dac_mode);
 746
 747         return 1;
 748 }
 749
 750 static struct hda_verb stac9200_core_init[] = {
 751         /* set dac0mux for dac converter */
 752         { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 753         {}
 754 };
 755
 756 static struct hda_verb stac9200_eapd_init[] = {
 757         /* set dac0mux for dac converter */
 758         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 759         {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 760         {}
 761 };
 762
 763 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
 764         /* set master volume and direct control */
 765         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 766         /* setup adcs to point to mixer */
 767         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 768         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 769         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 770         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 771         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 772         /* setup import muxs */
 773         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 774         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 775         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 776         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
 777         {}
 778 };
 779
 780 static struct hda_verb dell_eq_core_init[] = {
 781         /* set master volume to max value without distortion
 782          * and direct control */
 783         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
 784         /* setup adcs to point to mixer */
 785         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 786         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 787         /* setup import muxs */
 788         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 789         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 790         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 791         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
 792         {}
 793 };
 794
 795 static struct hda_verb dell_m6_core_init[] = {
 796         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 797         /* setup adcs to point to mixer */
 798         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 799         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 800         /* setup import muxs */
 801         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 802         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 803         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 804         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
 805         {}
 806 };
 807
 808 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
 809         /* set master volume and direct control */
 810         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 811         /* setup adcs to point to mixer */
 812         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 813         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 814         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 815         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 816         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 817         /* setup import muxs */
 818         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 819         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 820         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 821         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
 822         {}
 823 };
 824
 825 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
 826         /* set master volume and direct control */
 827         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 828         /* dac3 is connected to import3 mux */
 829         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
 830         /* setup adcs to point to mixer */
 831         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
 832         { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
 833         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 834         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 835         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 836         /* setup import muxs */
 837         { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
 838         { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
 839         { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
 840         { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
 841         {}
 842 };
 843
 844 static struct hda_verb stac92hd83xxx_core_init[] = {
 845         { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
 846         { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
 847         { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
 848
 849         /* power state controls amps */
 850         { 0x01, AC_VERB_SET_EAPD, 1 << 2},
 851         {}
 852 };
 853
 854 static struct hda_verb stac92hd71bxx_core_init[] = {
 855         /* set master volume and direct control */
 856         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 857         /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
 858         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 859         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 860         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 861         {}
 862 };
 863
 864 #define HD_DISABLE_PORTF 2
 865 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
 866         /* start of config #1 */
 867
 868         /* connect port 0f to audio mixer */
 869         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
 870         /* unmute right and left channels for node 0x0f */
 871         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 872         /* start of config #2 */
 873
 874         /* set master volume and direct control */
 875         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 876         /* unmute right and left channels for nodes 0x0a, 0xd */
 877         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 878         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 879         {}
 880 };
 881
 882 static struct hda_verb stac925x_core_init[] = {
 883         /* set dac0mux for dac converter */
 884         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
 885         /* mute the master volume */
 886         { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 887         {}
 888 };
 889
 890 static struct hda_verb stac922x_core_init[] = {
 891         /* set master volume and direct control */
 892         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 893         {}
 894 };
 895
 896 static struct hda_verb d965_core_init[] = {
 897         /* set master volume and direct control */
 898         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 899         /* unmute node 0x1b */
 900         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 901         /* select node 0x03 as DAC */
 902         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 903         {}
 904 };
 905
 906 static struct hda_verb stac927x_core_init[] = {
 907         /* set master volume and direct control */
 908         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 909         /* enable analog pc beep path */
 910         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 911         {}
 912 };
 913
 914 static struct hda_verb stac9205_core_init[] = {
 915         /* set master volume and direct control */
 916         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 917         /* enable analog pc beep path */
 918         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 919         {}
 920 };
 921
 922 #define STAC_MONO_MUX \
 923         { \
 924                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 925                 .name = "Mono Mux", \
 926                 .count = 1, \
 927                 .info = stac92xx_mono_mux_enum_info, \
 928                 .get = stac92xx_mono_mux_enum_get, \
 929                 .put = stac92xx_mono_mux_enum_put, \
 930         }
 931
 932 #define STAC_AMP_MUX \
 933         { \
 934                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 935                 .name = "Amp Selector Capture Switch", \
 936                 .count = 1, \
 937                 .info = stac92xx_amp_mux_enum_info, \
 938                 .get = stac92xx_amp_mux_enum_get, \
 939                 .put = stac92xx_amp_mux_enum_put, \
 940         }
 941
 942 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
 943         { \
 944                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 945                 .name = xname, \
 946                 .index = 0, \
 947                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
 948                         SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
 949                         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
 950                 .info = stac92xx_amp_volume_info, \
 951                 .get = stac92xx_amp_volume_get, \
 952                 .put = stac92xx_amp_volume_put, \
 953                 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
 954                 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
 955         }
 956
 957 #define STAC_INPUT_SOURCE(cnt) \
 958         { \
 959                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 960                 .name = "Input Source", \
 961                 .count = cnt, \
 962                 .info = stac92xx_mux_enum_info, \
 963                 .get = stac92xx_mux_enum_get, \
 964                 .put = stac92xx_mux_enum_put, \
 965         }
 966
 967 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
 968         { \
 969                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 970                 .name  = "Analog Loopback", \
 971                 .count = cnt, \
 972                 .info  = stac92xx_aloopback_info, \
 973                 .get   = stac92xx_aloopback_get, \
 974                 .put   = stac92xx_aloopback_put, \
 975                 .private_value = verb_read | (verb_write << 16), \
 976         }
 977
 978 static struct snd_kcontrol_new stac9200_mixer[] = {
 979         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
 980         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
 981         STAC_INPUT_SOURCE(1),
 982         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
 983         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
 984         { } /* end */
 985 };
 986
 987 #define DELL_M6_MIXER 6
 988 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
 989         /* start of config #1 */
 990         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
 991         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
 992
 993         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
 994         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
 995
 996         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
 997         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
 998
 999         /* start of config #2 */
1000         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1001         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1002
1003         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1004         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1005
1006         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1007
1008         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1009         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1010
1011         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1012         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1013
1014         { } /* end */
1015 };
1016
1017 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1018         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1019
1020         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1021         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1022
1023         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1024         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1025
1026         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1027         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1028
1029         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1030         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1031
1032         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1033         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1034
1035         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1036         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1037
1038         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1039         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1040         { } /* end */
1041 };
1042
1043 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1044         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1045
1046         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1047         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1048
1049         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1050         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1051
1052         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1053         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1054
1055         HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1056         HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1057
1058         HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1059         HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1060
1061         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1062         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1063
1064         HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1065         HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1066         { } /* end */
1067 };
1068
1069
1070 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1071         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1072         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1073
1074         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1075         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1076
1077         HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
1078         HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
1079
1080         HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
1081         HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
1082
1083         HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
1084         HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
1085
1086         HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
1087         HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
1088
1089         /*
1090         HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
1091         HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
1092         */
1093         { } /* end */
1094 };
1095
1096 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1097         STAC_INPUT_SOURCE(2),
1098         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1099
1100         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1101         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1102
1103         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1104         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1105         /* analog pc-beep replaced with digital beep support */
1106         /*
1107         HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1108         HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1109         */
1110
1111         HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1112         HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1113
1114         HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1115         HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1116
1117         HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1118         HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1119
1120         HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1121         HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1122         { } /* end */
1123 };
1124
1125 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1126         STAC_INPUT_SOURCE(2),
1127         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1128
1129         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1130         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1131
1132         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1133         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1134         { } /* end */
1135 };
1136
1137 static struct snd_kcontrol_new stac925x_mixer[] = {
1138         HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1139         HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1140         STAC_INPUT_SOURCE(1),
1141         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1142         HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1143         { } /* end */
1144 };
1145
1146 static struct snd_kcontrol_new stac9205_mixer[] = {
1147         STAC_INPUT_SOURCE(2),
1148         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1149
1150         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1151         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1152
1153         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1154         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1155         { } /* end */
1156 };
1157
1158 /* This needs to be generated dynamically based on sequence */
1159 static struct snd_kcontrol_new stac922x_mixer[] = {
1160         STAC_INPUT_SOURCE(2),
1161         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1162         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1163
1164         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1165         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1166         { } /* end */
1167 };
1168
1169
1170 static struct snd_kcontrol_new stac927x_mixer[] = {
1171         STAC_INPUT_SOURCE(3),
1172         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1173
1174         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1175         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1176
1177         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1178         HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1179
1180         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1181         HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1182         { } /* end */
1183 };
1184
1185 static struct snd_kcontrol_new stac_dmux_mixer = {
1186         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1187         .name = "Digital Input Source",
1188         /* count set later */
1189         .info = stac92xx_dmux_enum_info,
1190         .get = stac92xx_dmux_enum_get,
1191         .put = stac92xx_dmux_enum_put,
1192 };
1193
1194 static struct snd_kcontrol_new stac_smux_mixer = {
1195         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1196         .name = "IEC958 Playback Source",
1197         /* count set later */
1198         .info = stac92xx_smux_enum_info,
1199         .get = stac92xx_smux_enum_get,
1200         .put = stac92xx_smux_enum_put,
1201 };
1202
1203 static const char *slave_vols[] = {
1204         "Front Playback Volume",
1205         "Surround Playback Volume",
1206         "Center Playback Volume",
1207         "LFE Playback Volume",
1208         "Side Playback Volume",
1209         "Headphone Playback Volume",
1210         "Headphone Playback Volume",
1211         "Speaker Playback Volume",
1212         "External Speaker Playback Volume",
1213         "Speaker2 Playback Volume",
1214         NULL
1215 };
1216
1217 static const char *slave_sws[] = {
1218         "Front Playback Switch",
1219         "Surround Playback Switch",
1220         "Center Playback Switch",
1221         "LFE Playback Switch",
1222         "Side Playback Switch",
1223         "Headphone Playback Switch",
1224         "Headphone Playback Switch",
1225         "Speaker Playback Switch",
1226         "External Speaker Playback Switch",
1227         "Speaker2 Playback Switch",
1228         "IEC958 Playback Switch",
1229         NULL
1230 };
1231
1232 static void stac92xx_free_kctls(struct hda_codec *codec);
1233 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1234
1235 static int stac92xx_build_controls(struct hda_codec *codec)
1236 {
1237         struct sigmatel_spec *spec = codec->spec;
1238         struct auto_pin_cfg *cfg = &spec->autocfg;
1239         hda_nid_t nid;
1240         int err;
1241         int i;
1242
1243         err = snd_hda_add_new_ctls(codec, spec->mixer);
1244         if (err < 0)
1245                 return err;
1246
1247         for (i = 0; i < spec->num_mixers; i++) {
1248                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1249                 if (err < 0)
1250                         return err;
1251         }
1252         if (spec->num_dmuxes > 0) {
1253                 stac_dmux_mixer.count = spec->num_dmuxes;
1254                 err = snd_hda_ctl_add(codec,
1255                                   snd_ctl_new1(&stac_dmux_mixer, codec));
1256                 if (err < 0)
1257                         return err;
1258         }
1259         if (spec->num_smuxes > 0) {
1260                 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1261                 struct hda_input_mux *smux = &spec->private_smux;
1262                 /* check for mute support on SPDIF out */
1263                 if (wcaps & AC_WCAP_OUT_AMP) {
1264                         smux->items[smux->num_items].label = "Off";
1265                         smux->items[smux->num_items].index = 0;
1266                         smux->num_items++;
1267                         spec->spdif_mute = 1;
1268                 }
1269                 stac_smux_mixer.count = spec->num_smuxes;
1270                 err = snd_hda_ctl_add(codec,
1271                                   snd_ctl_new1(&stac_smux_mixer, codec));
1272                 if (err < 0)
1273                         return err;
1274         }
1275
1276         if (spec->multiout.dig_out_nid) {
1277                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1278                 if (err < 0)
1279                         return err;
1280                 err = snd_hda_create_spdif_share_sw(codec,
1281                                                     &spec->multiout);
1282                 if (err < 0)
1283                         return err;
1284                 spec->multiout.share_spdif = 1;
1285         }
1286         if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1287                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1288                 if (err < 0)
1289                         return err;
1290         }
1291
1292         /* if we have no master control, let's create it */
1293         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1294                 unsigned int vmaster_tlv[4];
1295                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1296                                         HDA_OUTPUT, vmaster_tlv);
1297                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1298                                           vmaster_tlv, slave_vols);
1299                 if (err < 0)
1300                         return err;
1301         }
1302         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1303                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1304                                           NULL, slave_sws);
1305                 if (err < 0)
1306                         return err;
1307         }
1308
1309         stac92xx_free_kctls(codec); /* no longer needed */
1310
1311         /* create jack input elements */
1312         if (spec->hp_detect) {
1313                 for (i = 0; i < cfg->hp_outs; i++) {
1314                         int type = SND_JACK_HEADPHONE;
1315                         nid = cfg->hp_pins[i];
1316                         /* jack detection */
1317                         if (cfg->hp_outs == i)
1318                                 type |= SND_JACK_LINEOUT;
1319                         err = stac92xx_add_jack(codec, nid, type);
1320                         if (err < 0)
1321                                 return err;
1322                 }
1323         }
1324         for (i = 0; i < cfg->line_outs; i++) {
1325                 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1326                                         SND_JACK_LINEOUT);
1327                 if (err < 0)
1328                         return err;
1329         }
1330         for (i = 0; i < AUTO_PIN_LAST; i++) {
1331                 nid = cfg->input_pins[i];
1332                 if (nid) {
1333                         err = stac92xx_add_jack(codec, nid,
1334                                                 SND_JACK_MICROPHONE);
1335                         if (err < 0)
1336                                 return err;
1337                 }
1338         }
1339
1340         return 0;
1341 }
1342
1343 static unsigned int ref9200_pin_configs[8] = {
1344         0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1345         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1346 };
1347
1348 static unsigned int gateway9200_m4_pin_configs[8] = {
1349         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1350         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1351 };
1352 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1353         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1354         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1355 };
1356
1357 /*
1358     STAC 9200 pin configs for
1359     102801A8
1360     102801DE
1361     102801E8
1362 */
1363 static unsigned int dell9200_d21_pin_configs[8] = {
1364         0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1365         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1366 };
1367
1368 /*
1369     STAC 9200 pin configs for
1370     102801C0
1371     102801C1
1372 */
1373 static unsigned int dell9200_d22_pin_configs[8] = {
1374         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1375         0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1376 };
1377
1378 /*
1379     STAC 9200 pin configs for
1380     102801C4 (Dell Dimension E310)
1381     102801C5
1382     102801C7
1383     102801D9
1384     102801DA
1385     102801E3
1386 */
1387 static unsigned int dell9200_d23_pin_configs[8] = {
1388         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1389         0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1390 };
1391
1392
1393 /*
1394     STAC 9200-32 pin configs for
1395     102801B5 (Dell Inspiron 630m)
1396     102801D8 (Dell Inspiron 640m)
1397 */
1398 static unsigned int dell9200_m21_pin_configs[8] = {
1399         0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1400         0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1401 };
1402
1403 /*
1404     STAC 9200-32 pin configs for
1405     102801C2 (Dell Latitude D620)
1406     102801C8
1407     102801CC (Dell Latitude D820)
1408     102801D4
1409     102801D6
1410 */
1411 static unsigned int dell9200_m22_pin_configs[8] = {
1412         0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1413         0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1414 };
1415
1416 /*
1417     STAC 9200-32 pin configs for
1418     102801CE (Dell XPS M1710)
1419     102801CF (Dell Precision M90)
1420 */
1421 static unsigned int dell9200_m23_pin_configs[8] = {
1422         0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1423         0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1424 };
1425
1426 /*
1427     STAC 9200-32 pin configs for
1428     102801C9
1429     102801CA
1430     102801CB (Dell Latitude 120L)
1431     102801D3
1432 */
1433 static unsigned int dell9200_m24_pin_configs[8] = {
1434         0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1435         0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1436 };
1437
1438 /*
1439     STAC 9200-32 pin configs for
1440     102801BD (Dell Inspiron E1505n)
1441     102801EE
1442     102801EF
1443 */
1444 static unsigned int dell9200_m25_pin_configs[8] = {
1445         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1446         0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1447 };
1448
1449 /*
1450     STAC 9200-32 pin configs for
1451     102801F5 (Dell Inspiron 1501)
1452     102801F6
1453 */
1454 static unsigned int dell9200_m26_pin_configs[8] = {
1455         0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1456         0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1457 };
1458
1459 /*
1460     STAC 9200-32
1461     102801CD (Dell Inspiron E1705/9400)
1462 */
1463 static unsigned int dell9200_m27_pin_configs[8] = {
1464         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1465         0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1466 };
1467
1468 static unsigned int oqo9200_pin_configs[8] = {
1469         0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1470         0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1471 };
1472
1473
1474 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1475         [STAC_REF] = ref9200_pin_configs,
1476         [STAC_9200_OQO] = oqo9200_pin_configs,
1477         [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1478         [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1479         [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1480         [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1481         [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1482         [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1483         [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1484         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1485         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1486         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1487         [STAC_9200_M4] = gateway9200_m4_pin_configs,
1488         [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1489         [STAC_9200_PANASONIC] = ref9200_pin_configs,
1490 };
1491
1492 static const char *stac9200_models[STAC_9200_MODELS] = {
1493         [STAC_REF] = "ref",
1494         [STAC_9200_OQO] = "oqo",
1495         [STAC_9200_DELL_D21] = "dell-d21",
1496         [STAC_9200_DELL_D22] = "dell-d22",
1497         [STAC_9200_DELL_D23] = "dell-d23",
1498         [STAC_9200_DELL_M21] = "dell-m21",
1499         [STAC_9200_DELL_M22] = "dell-m22",
1500         [STAC_9200_DELL_M23] = "dell-m23",
1501         [STAC_9200_DELL_M24] = "dell-m24",
1502         [STAC_9200_DELL_M25] = "dell-m25",
1503         [STAC_9200_DELL_M26] = "dell-m26",
1504         [STAC_9200_DELL_M27] = "dell-m27",
1505         [STAC_9200_M4] = "gateway-m4",
1506         [STAC_9200_M4_2] = "gateway-m4-2",
1507         [STAC_9200_PANASONIC] = "panasonic",
1508 };
1509
1510 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1511         /* SigmaTel reference board */
1512         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1513                       "DFI LanParty", STAC_REF),
1514         /* Dell laptops have BIOS problem */
1515         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1516                       "unknown Dell", STAC_9200_DELL_D21),
1517         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1518                       "Dell Inspiron 630m", STAC_9200_DELL_M21),
1519         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1520                       "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1521         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1522                       "unknown Dell", STAC_9200_DELL_D22),
1523         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1524                       "unknown Dell", STAC_9200_DELL_D22),
1525         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1526                       "Dell Latitude D620", STAC_9200_DELL_M22),
1527         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1528                       "unknown Dell", STAC_9200_DELL_D23),
1529         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1530                       "unknown Dell", STAC_9200_DELL_D23),
1531         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1532                       "unknown Dell", STAC_9200_DELL_M22),
1533         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1534                       "unknown Dell", STAC_9200_DELL_M24),
1535         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1536                       "unknown Dell", STAC_9200_DELL_M24),
1537         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1538                       "Dell Latitude 120L", STAC_9200_DELL_M24),
1539         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1540                       "Dell Latitude D820", STAC_9200_DELL_M22),
1541         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1542                       "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1543         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1544                       "Dell XPS M1710", STAC_9200_DELL_M23),
1545         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1546                       "Dell Precision M90", STAC_9200_DELL_M23),
1547         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1548                       "unknown Dell", STAC_9200_DELL_M22),
1549         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1550                       "unknown Dell", STAC_9200_DELL_M22),
1551         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1552                       "unknown Dell", STAC_9200_DELL_M22),
1553         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1554                       "Dell Inspiron 640m", STAC_9200_DELL_M21),
1555         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1556                       "unknown Dell", STAC_9200_DELL_D23),
1557         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1558                       "unknown Dell", STAC_9200_DELL_D23),
1559         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1560                       "unknown Dell", STAC_9200_DELL_D21),
1561         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1562                       "unknown Dell", STAC_9200_DELL_D23),
1563         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1564                       "unknown Dell", STAC_9200_DELL_D21),
1565         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1566                       "unknown Dell", STAC_9200_DELL_M25),
1567         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1568                       "unknown Dell", STAC_9200_DELL_M25),
1569         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1570                       "Dell Inspiron 1501", STAC_9200_DELL_M26),
1571         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1572                       "unknown Dell", STAC_9200_DELL_M26),
1573         /* Panasonic */
1574         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1575         /* Gateway machines needs EAPD to be set on resume */
1576         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1577         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1578         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1579         /* OQO Mobile */
1580         SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1581         {} /* terminator */
1582 };
1583
1584 static unsigned int ref925x_pin_configs[8] = {
1585         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1586         0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1587 };
1588
1589 static unsigned int stac925xM1_pin_configs[8] = {
1590         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1591         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1592 };
1593
1594 static unsigned int stac925xM1_2_pin_configs[8] = {
1595         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1596         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1597 };
1598
1599 static unsigned int stac925xM2_pin_configs[8] = {
1600         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1601         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1602 };
1603
1604 static unsigned int stac925xM2_2_pin_configs[8] = {
1605         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1606         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1607 };
1608
1609 static unsigned int stac925xM3_pin_configs[8] = {
1610         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1611         0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1612 };
1613
1614 static unsigned int stac925xM5_pin_configs[8] = {
1615         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1616         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1617 };
1618
1619 static unsigned int stac925xM6_pin_configs[8] = {
1620         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1621         0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1622 };
1623
1624 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1625         [STAC_REF] = ref925x_pin_configs,
1626         [STAC_M1] = stac925xM1_pin_configs,
1627         [STAC_M1_2] = stac925xM1_2_pin_configs,
1628         [STAC_M2] = stac925xM2_pin_configs,
1629         [STAC_M2_2] = stac925xM2_2_pin_configs,
1630         [STAC_M3] = stac925xM3_pin_configs,
1631         [STAC_M5] = stac925xM5_pin_configs,
1632         [STAC_M6] = stac925xM6_pin_configs,
1633 };
1634
1635 static const char *stac925x_models[STAC_925x_MODELS] = {
1636         [STAC_REF] = "ref",
1637         [STAC_M1] = "m1",
1638         [STAC_M1_2] = "m1-2",
1639         [STAC_M2] = "m2",
1640         [STAC_M2_2] = "m2-2",
1641         [STAC_M3] = "m3",
1642         [STAC_M5] = "m5",
1643         [STAC_M6] = "m6",
1644 };
1645
1646 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1647         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1648         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1649         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1650         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1651         SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1652         /* Not sure about the brand name for those */
1653         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1654         SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1655         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1656         SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1657         {} /* terminator */
1658 };
1659
1660 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1661         /* SigmaTel reference board */
1662         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1663         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1664
1665         /* Default table for unknown ID */
1666         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1667
1668         {} /* terminator */
1669 };
1670
1671 static unsigned int ref92hd73xx_pin_configs[13] = {
1672         0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1673         0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1674         0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1675         0x01452050,
1676 };
1677
1678 static unsigned int dell_m6_pin_configs[13] = {
1679         0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1680         0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1681         0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1682         0x4f0000f0,
1683 };
1684
1685 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1686         [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
1687         [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
1688         [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
1689         [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
1690         [STAC_DELL_EQ]  = dell_m6_pin_configs,
1691 };
1692
1693 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1694         [STAC_92HD73XX_NO_JD] = "no-jd",
1695         [STAC_92HD73XX_REF] = "ref",
1696         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1697         [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1698         [STAC_DELL_M6_BOTH] = "dell-m6",
1699         [STAC_DELL_EQ] = "dell-eq",
1700 };
1701
1702 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1703         /* SigmaTel reference board */
1704         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1705                                 "DFI LanParty", STAC_92HD73XX_REF),
1706         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1707                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1708         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1709                                 "unknown Dell", STAC_DELL_M6_DMIC),
1710         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1711                                 "unknown Dell", STAC_DELL_M6_BOTH),
1712         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1713                                 "unknown Dell", STAC_DELL_M6_BOTH),
1714         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1715                                 "unknown Dell", STAC_DELL_M6_AMIC),
1716         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1717                                 "unknown Dell", STAC_DELL_M6_AMIC),
1718         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1719                                 "unknown Dell", STAC_DELL_M6_DMIC),
1720         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1721                                 "unknown Dell", STAC_DELL_M6_DMIC),
1722         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1723                                 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1724         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1725                                 "Dell Studio 17", STAC_DELL_M6_DMIC),
1726         {} /* terminator */
1727 };
1728
1729 static unsigned int ref92hd83xxx_pin_configs[14] = {
1730         0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1731         0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1732         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1733         0x01451160, 0x98560170,
1734 };
1735
1736 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1737         [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1738         [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1739 };
1740
1741 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1742         [STAC_92HD83XXX_REF] = "ref",
1743         [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1744 };
1745
1746 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1747         /* SigmaTel reference board */
1748         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1749                       "DFI LanParty", STAC_92HD83XXX_REF),
1750         {} /* terminator */
1751 };
1752
1753 static unsigned int ref92hd71bxx_pin_configs[11] = {
1754         0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1755         0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1756         0x90a000f0, 0x01452050, 0x01452050,
1757 };
1758
1759 static unsigned int dell_m4_1_pin_configs[11] = {
1760         0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1761         0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1762         0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1763 };
1764
1765 static unsigned int dell_m4_2_pin_configs[11] = {
1766         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1767         0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1768         0x40f000f0, 0x044413b0, 0x044413b0,
1769 };
1770
1771 static unsigned int dell_m4_3_pin_configs[11] = {
1772         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1773         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1774         0x40f000f0, 0x044413b0, 0x044413b0,
1775 };
1776
1777 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1778         [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1779         [STAC_DELL_M4_1]        = dell_m4_1_pin_configs,
1780         [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
1781         [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
1782         [STAC_HP_M4]            = NULL,
1783         [STAC_HP_DV5]           = NULL,
1784 };
1785
1786 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1787         [STAC_92HD71BXX_REF] = "ref",
1788         [STAC_DELL_M4_1] = "dell-m4-1",
1789         [STAC_DELL_M4_2] = "dell-m4-2",
1790         [STAC_DELL_M4_3] = "dell-m4-3",
1791         [STAC_HP_M4] = "hp-m4",
1792         [STAC_HP_DV5] = "hp-dv5",
1793 };
1794
1795 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1796         /* SigmaTel reference board */
1797         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1798                       "DFI LanParty", STAC_92HD71BXX_REF),
1799         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
1800                       "HP dv5", STAC_HP_M4),
1801         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
1802                       "HP dv7", STAC_HP_M4),
1803         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f7,
1804                       "HP dv4", STAC_HP_DV5),
1805         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
1806                       "HP dv7", STAC_HP_M4),
1807         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
1808                       "HP dv5", STAC_HP_DV5),
1809         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1810                                 "unknown HP", STAC_HP_M4),
1811         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1812                                 "unknown Dell", STAC_DELL_M4_1),
1813         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1814                                 "unknown Dell", STAC_DELL_M4_1),
1815         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1816                                 "unknown Dell", STAC_DELL_M4_1),
1817         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1818                                 "unknown Dell", STAC_DELL_M4_1),
1819         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1820                                 "unknown Dell", STAC_DELL_M4_1),
1821         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1822                                 "unknown Dell", STAC_DELL_M4_1),
1823         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1824                                 "unknown Dell", STAC_DELL_M4_1),
1825         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1826                                 "unknown Dell", STAC_DELL_M4_2),
1827         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1828                                 "unknown Dell", STAC_DELL_M4_2),
1829         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1830                                 "unknown Dell", STAC_DELL_M4_2),
1831         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1832                                 "unknown Dell", STAC_DELL_M4_2),
1833         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1834                                 "unknown Dell", STAC_DELL_M4_3),
1835         {} /* terminator */
1836 };
1837
1838 static unsigned int ref922x_pin_configs[10] = {
1839         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1840         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1841         0x40000100, 0x40000100,
1842 };
1843
1844 /*
1845     STAC 922X pin configs for
1846     102801A7
1847     102801AB
1848     102801A9
1849     102801D1
1850     102801D2
1851 */
1852 static unsigned int dell_922x_d81_pin_configs[10] = {
1853         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1854         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1855         0x01813122, 0x400001f2,
1856 };
1857
1858 /*
1859     STAC 922X pin configs for
1860     102801AC
1861     102801D0
1862 */
1863 static unsigned int dell_922x_d82_pin_configs[10] = {
1864         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1865         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1866         0x01813122, 0x400001f1,
1867 };
1868
1869 /*
1870     STAC 922X pin configs for
1871     102801BF
1872 */
1873 static unsigned int dell_922x_m81_pin_configs[10] = {
1874         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1875         0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1876         0x40C003f1, 0x405003f0,
1877 };
1878
1879 /*
1880     STAC 9221 A1 pin configs for
1881     102801D7 (Dell XPS M1210)
1882 */
1883 static unsigned int dell_922x_m82_pin_configs[10] = {
1884         0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1885         0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1886         0x508003f3, 0x405003f4,
1887 };
1888
1889 static unsigned int d945gtp3_pin_configs[10] = {
1890         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1891         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1892         0x02a19120, 0x40000100,
1893 };
1894
1895 static unsigned int d945gtp5_pin_configs[10] = {
1896         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1897         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1898         0x02a19320, 0x40000100,
1899 };
1900
1901 static unsigned int intel_mac_v1_pin_configs[10] = {
1902         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1903         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1904         0x400000fc, 0x400000fb,
1905 };
1906
1907 static unsigned int intel_mac_v2_pin_configs[10] = {
1908         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1909         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1910         0x400000fc, 0x400000fb,
1911 };
1912
1913 static unsigned int intel_mac_v3_pin_configs[10] = {
1914         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1915         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1916         0x400000fc, 0x400000fb,
1917 };
1918
1919 static unsigned int intel_mac_v4_pin_configs[10] = {
1920         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1921         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1922         0x400000fc, 0x400000fb,
1923 };
1924
1925 static unsigned int intel_mac_v5_pin_configs[10] = {
1926         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1927         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1928         0x400000fc, 0x400000fb,
1929 };
1930
1931 static unsigned int ecs202_pin_configs[10] = {
1932         0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1933         0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1934         0x9037012e, 0x40e000f2,
1935 };
1936
1937 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1938         [STAC_D945_REF] = ref922x_pin_configs,
1939         [STAC_D945GTP3] = d945gtp3_pin_configs,
1940         [STAC_D945GTP5] = d945gtp5_pin_configs,
1941         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1942         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1943         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1944         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1945         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1946         [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1947         /* for backward compatibility */
1948         [STAC_MACMINI] = intel_mac_v3_pin_configs,
1949         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1950         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1951         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1952         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1953         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1954         [STAC_ECS_202] = ecs202_pin_configs,
1955         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1956         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1957         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1958         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1959 };
1960
1961 static const char *stac922x_models[STAC_922X_MODELS] = {
1962         [STAC_D945_REF] = "ref",
1963         [STAC_D945GTP5] = "5stack",
1964         [STAC_D945GTP3] = "3stack",
1965         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1966         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1967         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1968         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1969         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1970         [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1971         /* for backward compatibility */
1972         [STAC_MACMINI]  = "macmini",
1973         [STAC_MACBOOK]  = "macbook",
1974         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1975         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1976         [STAC_IMAC_INTEL] = "imac-intel",
1977         [STAC_IMAC_INTEL_20] = "imac-intel-20",
1978         [STAC_ECS_202] = "ecs202",
1979         [STAC_922X_DELL_D81] = "dell-d81",
1980         [STAC_922X_DELL_D82] = "dell-d82",
1981         [STAC_922X_DELL_M81] = "dell-m81",
1982         [STAC_922X_DELL_M82] = "dell-m82",
1983 };
1984
1985 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1986         /* SigmaTel reference board */
1987         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1988                       "DFI LanParty", STAC_D945_REF),
1989         /* Intel 945G based systems */
1990         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1991                       "Intel D945G", STAC_D945GTP3),
1992         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1993                       "Intel D945G", STAC_D945GTP3),
1994         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1995                       "Intel D945G", STAC_D945GTP3),
1996         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1997                       "Intel D945G", STAC_D945GTP3),
1998         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1999                       "Intel D945G", STAC_D945GTP3),
2000         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2001                       "Intel D945G", STAC_D945GTP3),
2002         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2003                       "Intel D945G", STAC_D945GTP3),
2004         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2005                       "Intel D945G", STAC_D945GTP3),
2006         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2007                       "Intel D945G", STAC_D945GTP3),
2008         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2009                       "Intel D945G", STAC_D945GTP3),
2010         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2011                       "Intel D945G", STAC_D945GTP3),
2012         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2013                       "Intel D945G", STAC_D945GTP3),
2014         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2015                       "Intel D945G", STAC_D945GTP3),
2016         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2017                       "Intel D945G", STAC_D945GTP3),
2018         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2019                       "Intel D945G", STAC_D945GTP3),
2020         /* Intel D945G 5-stack systems */
2021         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2022                       "Intel D945G", STAC_D945GTP5),
2023         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2024                       "Intel D945G", STAC_D945GTP5),
2025         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2026                       "Intel D945G", STAC_D945GTP5),
2027         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2028                       "Intel D945G", STAC_D945GTP5),
2029         /* Intel 945P based systems */
2030         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2031                       "Intel D945P", STAC_D945GTP3),
2032         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2033                       "Intel D945P", STAC_D945GTP3),
2034         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2035                       "Intel D945P", STAC_D945GTP3),
2036         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2037                       "Intel D945P", STAC_D945GTP3),
2038         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2039                       "Intel D945P", STAC_D945GTP3),
2040         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2041                       "Intel D945P", STAC_D945GTP5),
2042         /* other systems  */
2043         /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2044         SND_PCI_QUIRK(0x8384, 0x7680,
2045                       "Mac", STAC_INTEL_MAC_AUTO),
2046         /* Dell systems  */
2047         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2048                       "unknown Dell", STAC_922X_DELL_D81),
2049         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2050                       "unknown Dell", STAC_922X_DELL_D81),
2051         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2052                       "unknown Dell", STAC_922X_DELL_D81),
2053         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2054                       "unknown Dell", STAC_922X_DELL_D82),
2055         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2056                       "unknown Dell", STAC_922X_DELL_M81),
2057         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2058                       "unknown Dell", STAC_922X_DELL_D82),
2059         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2060                       "unknown Dell", STAC_922X_DELL_D81),
2061         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2062                       "unknown Dell", STAC_922X_DELL_D81),
2063         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2064                       "Dell XPS M1210", STAC_922X_DELL_M82),
2065         /* ECS/PC Chips boards */
2066         SND_PCI_QUIRK(0x1019, 0x2144,
2067                       "ECS/PC chips", STAC_ECS_202),
2068         SND_PCI_QUIRK(0x1019, 0x2608,
2069                       "ECS/PC chips", STAC_ECS_202),
2070         SND_PCI_QUIRK(0x1019, 0x2633,
2071                       "ECS/PC chips P17G/1333", STAC_ECS_202),
2072         SND_PCI_QUIRK(0x1019, 0x2811,
2073                       "ECS/PC chips", STAC_ECS_202),
2074         SND_PCI_QUIRK(0x1019, 0x2812,
2075                       "ECS/PC chips", STAC_ECS_202),
2076         SND_PCI_QUIRK(0x1019, 0x2813,
2077                       "ECS/PC chips", STAC_ECS_202),
2078         SND_PCI_QUIRK(0x1019, 0x2814,
2079                       "ECS/PC chips", STAC_ECS_202),
2080         SND_PCI_QUIRK(0x1019, 0x2815,
2081                       "ECS/PC chips", STAC_ECS_202),
2082         SND_PCI_QUIRK(0x1019, 0x2816,
2083                       "ECS/PC chips", STAC_ECS_202),
2084         SND_PCI_QUIRK(0x1019, 0x2817,
2085                       "ECS/PC chips", STAC_ECS_202),
2086         SND_PCI_QUIRK(0x1019, 0x2818,
2087                       "ECS/PC chips", STAC_ECS_202),
2088         SND_PCI_QUIRK(0x1019, 0x2819,
2089                       "ECS/PC chips", STAC_ECS_202),
2090         SND_PCI_QUIRK(0x1019, 0x2820,
2091                       "ECS/PC chips", STAC_ECS_202),
2092         {} /* terminator */
2093 };
2094
2095 static unsigned int ref927x_pin_configs[14] = {
2096         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2097         0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2098         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2099         0x01c42190, 0x40000100,
2100 };
2101
2102 static unsigned int d965_3st_pin_configs[14] = {
2103         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2104         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2105         0x40000100, 0x40000100, 0x40000100, 0x40000100,
2106         0x40000100, 0x40000100
2107 };
2108
2109 static unsigned int d965_5st_pin_configs[14] = {
2110         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2111         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2112         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2113         0x40000100, 0x40000100
2114 };
2115
2116 static unsigned int dell_3st_pin_configs[14] = {
2117         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2118         0x01111212, 0x01116211, 0x01813050, 0x01112214,
2119         0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2120         0x40c003fc, 0x40000100
2121 };
2122
2123 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2124         [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2125         [STAC_D965_REF]  = ref927x_pin_configs,
2126         [STAC_D965_3ST]  = d965_3st_pin_configs,
2127         [STAC_D965_5ST]  = d965_5st_pin_configs,
2128         [STAC_DELL_3ST]  = dell_3st_pin_configs,
2129         [STAC_DELL_BIOS] = NULL,
2130 };
2131
2132 static const char *stac927x_models[STAC_927X_MODELS] = {
2133         [STAC_D965_REF_NO_JD]   = "ref-no-jd",
2134         [STAC_D965_REF]         = "ref",
2135         [STAC_D965_3ST]         = "3stack",
2136         [STAC_D965_5ST]         = "5stack",
2137         [STAC_DELL_3ST]         = "dell-3stack",
2138         [STAC_DELL_BIOS]        = "dell-bios",
2139 };
2140
2141 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2142         /* SigmaTel reference board */
2143         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2144                       "DFI LanParty", STAC_D965_REF),
2145          /* Intel 946 based systems */
2146         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2147         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2148         /* 965 based 3 stack systems */
2149         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2150         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2151         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2152         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2153         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2154         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2155         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2156         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2157         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2158         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2159         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2160         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2161         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2162         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2163         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2164         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2165         /* Dell 3 stack systems */
2166         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2167         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2168         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2169         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2170         /* Dell 3 stack systems with verb table in BIOS */
2171         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2172         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2173         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2174         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2175         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2176         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2177         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2178         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2179         /* 965 based 5 stack systems */
2180         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2181         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2182         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2183         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2184         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2185         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2186         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2187         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2188         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2189         {} /* terminator */
2190 };
2191
2192 static unsigned int ref9205_pin_configs[12] = {
2193         0x40000100, 0x40000100, 0x01016011, 0x01014010,
2194         0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2195         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2196 };
2197
2198 /*
2199     STAC 9205 pin configs for
2200     102801F1
2201     102801F2
2202     102801FC
2203     102801FD
2204     10280204
2205     1028021F
2206     10280228 (Dell Vostro 1500)
2207 */
2208 static unsigned int dell_9205_m42_pin_configs[12] = {
2209         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2210         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2211         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2212 };
2213
2214 /*
2215     STAC 9205 pin configs for
2216     102801F9
2217     102801FA
2218     102801FE
2219     102801FF (Dell Precision M4300)
2220     10280206
2221     10280200
2222     10280201
2223 */
2224 static unsigned int dell_9205_m43_pin_configs[12] = {
2225         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2226         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2227         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2228 };
2229
2230 static unsigned int dell_9205_m44_pin_configs[12] = {
2231         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2232         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2233         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2234 };
2235
2236 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2237         [STAC_9205_REF] = ref9205_pin_configs,
2238         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2239         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2240         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2241 };
2242
2243 static const char *stac9205_models[STAC_9205_MODELS] = {
2244         [STAC_9205_REF] = "ref",
2245         [STAC_9205_DELL_M42] = "dell-m42",
2246         [STAC_9205_DELL_M43] = "dell-m43",
2247         [STAC_9205_DELL_M44] = "dell-m44",
2248 };
2249
2250 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2251         /* SigmaTel reference board */
2252         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2253                       "DFI LanParty", STAC_9205_REF),
2254         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2255                       "unknown Dell", STAC_9205_DELL_M42),
2256         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2257                       "unknown Dell", STAC_9205_DELL_M42),
2258         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2259                       "Dell Precision", STAC_9205_DELL_M43),
2260         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2261                       "Dell Precision", STAC_9205_DELL_M43),
2262         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2263                       "Dell Precision", STAC_9205_DELL_M43),
2264         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2265                       "unknown Dell", STAC_9205_DELL_M42),
2266         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2267                       "unknown Dell", STAC_9205_DELL_M42),
2268         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2269                       "Dell Precision", STAC_9205_DELL_M43),
2270         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2271                       "Dell Precision M4300", STAC_9205_DELL_M43),
2272         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2273                       "unknown Dell", STAC_9205_DELL_M42),
2274         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2275                       "Dell Precision", STAC_9205_DELL_M43),
2276         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2277                       "Dell Precision", STAC_9205_DELL_M43),
2278         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2279                       "Dell Precision", STAC_9205_DELL_M43),
2280         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2281                       "Dell Inspiron", STAC_9205_DELL_M44),
2282         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2283                       "Dell Vostro 1500", STAC_9205_DELL_M42),
2284         {} /* terminator */
2285 };
2286
2287 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2288 {
2289         int i;
2290         struct sigmatel_spec *spec = codec->spec;
2291
2292         kfree(spec->pin_configs);
2293         spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
2294                                     GFP_KERNEL);
2295         if (!spec->pin_configs)
2296                 return -ENOMEM;
2297
2298         for (i = 0; i < spec->num_pins; i++) {
2299                 hda_nid_t nid = spec->pin_nids[i];
2300                 unsigned int pin_cfg;
2301
2302                 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2303                         AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2304                 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2305                                         nid, pin_cfg);
2306                 spec->pin_configs[i] = pin_cfg;
2307         }
2308
2309         return 0;
2310 }
2311
2312 static void stac92xx_set_config_reg(struct hda_codec *codec,
2313                                     hda_nid_t pin_nid, unsigned int pin_config)
2314 {
2315         int i;
2316         snd_hda_codec_write(codec, pin_nid, 0,
2317                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2318                             pin_config & 0x000000ff);
2319         snd_hda_codec_write(codec, pin_nid, 0,
2320                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2321                             (pin_config & 0x0000ff00) >> 8);
2322         snd_hda_codec_write(codec, pin_nid, 0,
2323                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2324                             (pin_config & 0x00ff0000) >> 16);
2325         snd_hda_codec_write(codec, pin_nid, 0,
2326                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2327                             pin_config >> 24);
2328         i = snd_hda_codec_read(codec, pin_nid, 0,
2329                                AC_VERB_GET_CONFIG_DEFAULT,
2330                                0x00);
2331         snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2332                     pin_nid, i);
2333 }
2334
2335 static void stac92xx_set_config_regs(struct hda_codec *codec)
2336 {
2337         int i;
2338         struct sigmatel_spec *spec = codec->spec;
2339
2340         if (!spec->pin_configs)
2341                 return;
2342
2343         for (i = 0; i < spec->num_pins; i++)
2344                 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2345                                         spec->pin_configs[i]);
2346 }
2347
2348 static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
2349 {
2350         struct sigmatel_spec *spec = codec->spec;
2351
2352         if (!pins)
2353                 return stac92xx_save_bios_config_regs(codec);
2354
2355         kfree(spec->pin_configs);
2356         spec->pin_configs = kmemdup(pins,
2357                                     spec->num_pins * sizeof(*pins),
2358                                     GFP_KERNEL);
2359         if (!spec->pin_configs)
2360                 return -ENOMEM;
2361
2362         stac92xx_set_config_regs(codec);
2363         return 0;
2364 }
2365
2366 static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
2367                                    unsigned int cfg)
2368 {
2369         struct sigmatel_spec *spec = codec->spec;
2370         int i;
2371
2372         for (i = 0; i < spec->num_pins; i++) {
2373                 if (spec->pin_nids[i] == nid) {
2374                         spec->pin_configs[i] = cfg;
2375                         stac92xx_set_config_reg(codec, nid, cfg);
2376                         break;
2377                 }
2378         }
2379 }
2380
2381 /*
2382  * Analog playback callbacks
2383  */
2384 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2385                                       struct hda_codec *codec,
2386                                       struct snd_pcm_substream *substream)
2387 {
2388         struct sigmatel_spec *spec = codec->spec;
2389         if (spec->stream_delay)
2390                 msleep(spec->stream_delay);
2391         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2392                                              hinfo);
2393 }
2394
2395 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2396                                          struct hda_codec *codec,
2397                                          unsigned int stream_tag,
2398                                          unsigned int format,
2399                                          struct snd_pcm_substream *substream)
2400 {
2401         struct sigmatel_spec *spec = codec->spec;
2402         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2403 }
2404
2405 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2406                                         struct hda_codec *codec,
2407                                         struct snd_pcm_substream *substream)
2408 {
2409         struct sigmatel_spec *spec = codec->spec;
2410         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2411 }
2412
2413 /*
2414  * Digital playback callbacks
2415  */
2416 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2417                                           struct hda_codec *codec,
2418                                           struct snd_pcm_substream *substream)
2419 {
2420         struct sigmatel_spec *spec = codec->spec;
2421         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2422 }
2423
2424 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2425                                            struct hda_codec *codec,
2426                                            struct snd_pcm_substream *substream)
2427 {
2428         struct sigmatel_spec *spec = codec->spec;
2429         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2430 }
2431
2432 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2433                                          struct hda_codec *codec,
2434                                          unsigned int stream_tag,
2435                                          unsigned int format,
2436                                          struct snd_pcm_substream *substream)
2437 {
2438         struct sigmatel_spec *spec = codec->spec;
2439         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2440                                              stream_tag, format, substream);
2441 }
2442
2443
2444 /*
2445  * Analog capture callbacks
2446  */
2447 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2448                                         struct hda_codec *codec,
2449                                         unsigned int stream_tag,
2450                                         unsigned int format,
2451                                         struct snd_pcm_substream *substream)
2452 {
2453         struct sigmatel_spec *spec = codec->spec;
2454         hda_nid_t nid = spec->adc_nids[substream->number];
2455
2456         if (spec->powerdown_adcs) {
2457                 msleep(40);
2458                 snd_hda_codec_write(codec, nid, 0,
2459                         AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2460         }
2461         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2462         return 0;
2463 }
2464
2465 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2466                                         struct hda_codec *codec,
2467                                         struct snd_pcm_substream *substream)
2468 {
2469         struct sigmatel_spec *spec = codec->spec;
2470         hda_nid_t nid = spec->adc_nids[substream->number];
2471
2472         snd_hda_codec_cleanup_stream(codec, nid);
2473         if (spec->powerdown_adcs)
2474                 snd_hda_codec_write(codec, nid, 0,
2475                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2476         return 0;
2477 }
2478
2479 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2480         .substreams = 1,
2481         .channels_min = 2,
2482         .channels_max = 2,
2483         /* NID is set in stac92xx_build_pcms */
2484         .ops = {
2485                 .open = stac92xx_dig_playback_pcm_open,
2486                 .close = stac92xx_dig_playback_pcm_close,
2487                 .prepare = stac92xx_dig_playback_pcm_prepare
2488         },
2489 };
2490
2491 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2492         .substreams = 1,
2493         .channels_min = 2,
2494         .channels_max = 2,
2495         /* NID is set in stac92xx_build_pcms */
2496 };
2497
2498 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2499         .substreams = 1,
2500         .channels_min = 2,
2501         .channels_max = 8,
2502         .nid = 0x02, /* NID to query formats and rates */
2503         .ops = {
2504                 .open = stac92xx_playback_pcm_open,
2505                 .prepare = stac92xx_playback_pcm_prepare,
2506                 .cleanup = stac92xx_playback_pcm_cleanup
2507         },
2508 };
2509
2510 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2511         .substreams = 1,
2512         .channels_min = 2,
2513         .channels_max = 2,
2514         .nid = 0x06, /* NID to query formats and rates */
2515         .ops = {
2516                 .open = stac92xx_playback_pcm_open,
2517                 .prepare = stac92xx_playback_pcm_prepare,
2518                 .cleanup = stac92xx_playback_pcm_cleanup
2519         },
2520 };
2521
2522 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2523         .channels_min = 2,
2524         .channels_max = 2,
2525         /* NID + .substreams is set in stac92xx_build_pcms */
2526         .ops = {
2527                 .prepare = stac92xx_capture_pcm_prepare,
2528                 .cleanup = stac92xx_capture_pcm_cleanup
2529         },
2530 };
2531
2532 static int stac92xx_build_pcms(struct hda_codec *codec)
2533 {
2534         struct sigmatel_spec *spec = codec->spec;
2535         struct hda_pcm *info = spec->pcm_rec;
2536
2537         codec->num_pcms = 1;
2538         codec->pcm_info = info;
2539
2540         info->name = "STAC92xx Analog";
2541         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2542         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2543                 spec->multiout.dac_nids[0];
2544         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2545         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2546         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2547
2548         if (spec->alt_switch) {
2549                 codec->num_pcms++;
2550                 info++;
2551                 info->name = "STAC92xx Analog Alt";
2552                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2553         }
2554
2555         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2556                 codec->num_pcms++;
2557                 info++;
2558                 info->name = "STAC92xx Digital";
2559                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2560                 if (spec->multiout.dig_out_nid) {
2561                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2562                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2563                 }
2564                 if (spec->dig_in_nid) {
2565                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2566                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2567                 }
2568         }
2569
2570         return 0;
2571 }
2572
2573 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2574 {
2575         unsigned int pincap = snd_hda_param_read(codec, nid,
2576                                                  AC_PAR_PIN_CAP);
2577         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2578         if (pincap & AC_PINCAP_VREF_100)
2579                 return AC_PINCTL_VREF_100;
2580         if (pincap & AC_PINCAP_VREF_80)
2581                 return AC_PINCTL_VREF_80;
2582         if (pincap & AC_PINCAP_VREF_50)
2583                 return AC_PINCTL_VREF_50;
2584         if (pincap & AC_PINCAP_VREF_GRD)
2585                 return AC_PINCTL_VREF_GRD;
2586         return 0;
2587 }
2588
2589 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2590
2591 {
2592         snd_hda_codec_write_cache(codec, nid, 0,
2593                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2594 }
2595
2596 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2597
2598 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2599                         struct snd_ctl_elem_value *ucontrol)
2600 {
2601         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2602         struct sigmatel_spec *spec = codec->spec;
2603
2604         ucontrol->value.integer.value[0] = !!spec->hp_switch;
2605         return 0;
2606 }
2607
2608 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2609                                    unsigned char type);
2610
2611 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2612                         struct snd_ctl_elem_value *ucontrol)
2613 {
2614         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2615         struct sigmatel_spec *spec = codec->spec;
2616         int nid = kcontrol->private_value;
2617
2618         spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2619
2620         /* check to be sure that the ports are upto date with
2621          * switch changes
2622          */
2623         stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2624
2625         return 1;
2626 }
2627
2628 #define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
2629
2630 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2631 {
2632         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2633         struct sigmatel_spec *spec = codec->spec;
2634         int io_idx = kcontrol-> private_value & 0xff;
2635
2636         ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2637         return 0;
2638 }
2639
2640 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2641 {
2642         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2643         struct sigmatel_spec *spec = codec->spec;
2644         hda_nid_t nid = kcontrol->private_value >> 8;
2645         int io_idx = kcontrol-> private_value & 0xff;
2646         unsigned short val = !!ucontrol->value.integer.value[0];
2647
2648         spec->io_switch[io_idx] = val;
2649
2650         if (val)
2651                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2652         else {
2653                 unsigned int pinctl = AC_PINCTL_IN_EN;
2654                 if (io_idx) /* set VREF for mic */
2655                         pinctl |= stac92xx_get_vref(codec, nid);
2656                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2657         }
2658
2659         /* check the auto-mute again: we need to mute/unmute the speaker
2660          * appropriately according to the pin direction
2661          */
2662         if (spec->hp_detect)
2663                 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2664
2665         return 1;
2666 }
2667
2668 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2669
2670 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2671                 struct snd_ctl_elem_value *ucontrol)
2672 {
2673         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2674         struct sigmatel_spec *spec = codec->spec;
2675
2676         ucontrol->value.integer.value[0] = spec->clfe_swap;
2677         return 0;
2678 }
2679
2680 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2681                 struct snd_ctl_elem_value *ucontrol)
2682 {
2683         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2684         struct sigmatel_spec *spec = codec->spec;
2685         hda_nid_t nid = kcontrol->private_value & 0xff;
2686         unsigned int val = !!ucontrol->value.integer.value[0];
2687
2688         if (spec->clfe_swap == val)
2689                 return 0;
2690
2691         spec->clfe_swap = val;
2692
2693         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2694                 spec->clfe_swap ? 0x4 : 0x0);
2695
2696         return 1;
2697 }
2698
2699 #define STAC_CODEC_HP_SWITCH(xname) \
2700         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2701           .name = xname, \
2702           .index = 0, \
2703           .info = stac92xx_hp_switch_info, \
2704           .get = stac92xx_hp_switch_get, \
2705           .put = stac92xx_hp_switch_put, \
2706         }
2707
2708 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2709         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2710           .name = xname, \
2711           .index = 0, \
2712           .info = stac92xx_io_switch_info, \
2713           .get = stac92xx_io_switch_get, \
2714           .put = stac92xx_io_switch_put, \
2715           .private_value = xpval, \
2716         }
2717
2718 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2719         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2720           .name = xname, \
2721           .index = 0, \
2722           .info = stac92xx_clfe_switch_info, \
2723           .get = stac92xx_clfe_switch_get, \
2724           .put = stac92xx_clfe_switch_put, \
2725           .private_value = xpval, \
2726         }
2727
2728 enum {
2729         STAC_CTL_WIDGET_VOL,
2730         STAC_CTL_WIDGET_MUTE,
2731         STAC_CTL_WIDGET_MONO_MUX,
2732         STAC_CTL_WIDGET_AMP_MUX,
2733         STAC_CTL_WIDGET_AMP_VOL,
2734         STAC_CTL_WIDGET_HP_SWITCH,
2735         STAC_CTL_WIDGET_IO_SWITCH,
2736         STAC_CTL_WIDGET_CLFE_SWITCH
2737 };
2738
2739 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2740         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2741         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2742         STAC_MONO_MUX,
2743         STAC_AMP_MUX,
2744         STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2745         STAC_CODEC_HP_SWITCH(NULL),
2746         STAC_CODEC_IO_SWITCH(NULL, 0),
2747         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2748 };
2749
2750 /* add dynamic controls */
2751 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2752                                      struct snd_kcontrol_new *ktemp,
2753                                      int idx, const char *name,
2754                                      unsigned long val)
2755 {
2756         struct snd_kcontrol_new *knew;
2757
2758         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2759         knew = snd_array_new(&spec->kctls);
2760         if (!knew)
2761                 return -ENOMEM;
2762         *knew = *ktemp;
2763         knew->index = idx;
2764         knew->name = kstrdup(name, GFP_KERNEL);
2765         if (!knew->name)
2766                 return -ENOMEM;
2767         knew->private_value = val;
2768         return 0;
2769 }
2770
2771 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2772                                            int type, int idx, const char *name,
2773                                            unsigned long val)
2774 {
2775         return stac92xx_add_control_temp(spec,
2776                                          &stac92xx_control_templates[type],
2777                                          idx, name, val);
2778 }
2779
2780
2781 /* add dynamic controls */
2782 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2783                                        const char *name, unsigned long val)
2784 {
2785         return stac92xx_add_control_idx(spec, type, 0, name, val);
2786 }
2787
2788 /* check whether the line-input can be used as line-out */
2789 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2790 {
2791         struct sigmatel_spec *spec = codec->spec;
2792         struct auto_pin_cfg *cfg = &spec->autocfg;
2793         hda_nid_t nid;
2794         unsigned int pincap;
2795
2796         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2797                 return 0;
2798         nid = cfg->input_pins[AUTO_PIN_LINE];
2799         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2800         if (pincap & AC_PINCAP_OUT)
2801                 return nid;
2802         return 0;
2803 }
2804
2805 /* check whether the mic-input can be used as line-out */
2806 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2807 {
2808         struct sigmatel_spec *spec = codec->spec;
2809         struct auto_pin_cfg *cfg = &spec->autocfg;
2810         unsigned int def_conf, pincap;
2811         unsigned int mic_pin;
2812
2813         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2814                 return 0;
2815         mic_pin = AUTO_PIN_MIC;
2816         for (;;) {
2817                 hda_nid_t nid = cfg->input_pins[mic_pin];
2818                 def_conf = snd_hda_codec_read(codec, nid, 0,
2819                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
2820                 /* some laptops have an internal analog microphone
2821                  * which can't be used as a output */
2822                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2823                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2824                         if (pincap & AC_PINCAP_OUT)
2825                                 return nid;
2826                 }
2827                 if (mic_pin == AUTO_PIN_MIC)
2828                         mic_pin = AUTO_PIN_FRONT_MIC;
2829                 else
2830                         break;
2831         }
2832         return 0;
2833 }
2834
2835 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2836 {
2837         int i;
2838
2839         for (i = 0; i < spec->multiout.num_dacs; i++) {
2840                 if (spec->multiout.dac_nids[i] == nid)
2841                         return 1;
2842         }
2843
2844         return 0;
2845 }
2846
2847 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2848 {
2849         int i;
2850         if (is_in_dac_nids(spec, nid))
2851                 return 1;
2852         for (i = 0; i < spec->autocfg.hp_outs; i++)
2853                 if (spec->hp_dacs[i] == nid)
2854                         return 1;
2855         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2856                 if (spec->speaker_dacs[i] == nid)
2857                         return 1;
2858         return 0;
2859 }
2860
2861 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2862 {
2863         struct sigmatel_spec *spec = codec->spec;
2864         int j, conn_len;
2865         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2866         unsigned int wcaps, wtype;
2867
2868         conn_len = snd_hda_get_connections(codec, nid, conn,
2869                                            HDA_MAX_CONNECTIONS);
2870         for (j = 0; j < conn_len; j++) {
2871                 wcaps = snd_hda_param_read(codec, conn[j],
2872                                            AC_PAR_AUDIO_WIDGET_CAP);
2873                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2874                 /* we check only analog outputs */
2875                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2876                         continue;
2877                 /* if this route has a free DAC, assign it */
2878                 if (!check_all_dac_nids(spec, conn[j])) {
2879                         if (conn_len > 1) {
2880                                 /* select this DAC in the pin's input mux */
2881                                 snd_hda_codec_write_cache(codec, nid, 0,
2882                                                   AC_VERB_SET_CONNECT_SEL, j);
2883                         }
2884                         return conn[j];
2885                 }
2886         }
2887         return 0;
2888 }
2889
2890 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2891 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2892
2893 /*
2894  * Fill in the dac_nids table from the parsed pin configuration
2895  * This function only works when every pin in line_out_pins[]
2896  * contains atleast one DAC in its connection list. Some 92xx
2897  * codecs are not connected directly to a DAC, such as the 9200
2898  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2899  */
2900 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2901 {
2902         struct sigmatel_spec *spec = codec->spec;
2903         struct auto_pin_cfg *cfg = &spec->autocfg;
2904         int i;
2905         hda_nid_t nid, dac;
2906
2907         for (i = 0; i < cfg->line_outs; i++) {
2908                 nid = cfg->line_out_pins[i];
2909                 dac = get_unassigned_dac(codec, nid);
2910                 if (!dac) {
2911                         if (spec->multiout.num_dacs > 0) {
2912                                 /* we have already working output pins,
2913                                  * so let's drop the broken ones again
2914                                  */
2915                                 cfg->line_outs = spec->multiout.num_dacs;
2916                                 break;
2917                         }
2918                         /* error out, no available DAC found */
2919                         snd_printk(KERN_ERR
2920                                    "%s: No available DAC for pin 0x%x\n",
2921                                    __func__, nid);
2922                         return -ENODEV;
2923                 }
2924                 add_spec_dacs(spec, dac);
2925         }
2926
2927         /* add line-in as output */
2928         nid = check_line_out_switch(codec);
2929         if (nid) {
2930                 dac = get_unassigned_dac(codec, nid);
2931                 if (dac) {
2932                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2933                                     nid, cfg->line_outs);
2934                         cfg->line_out_pins[cfg->line_outs] = nid;
2935                         cfg->line_outs++;
2936                         spec->line_switch = nid;
2937                         add_spec_dacs(spec, dac);
2938                 }
2939         }
2940         /* add mic as output */
2941         nid = check_mic_out_switch(codec);
2942         if (nid) {
2943                 dac = get_unassigned_dac(codec, nid);
2944                 if (dac) {
2945                         snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2946                                     nid, cfg->line_outs);
2947                         cfg->line_out_pins[cfg->line_outs] = nid;
2948                         cfg->line_outs++;
2949                         spec->mic_switch = nid;
2950                         add_spec_dacs(spec, dac);
2951                 }
2952         }
2953
2954         for (i = 0; i < cfg->hp_outs; i++) {
2955                 nid = cfg->hp_pins[i];
2956                 dac = get_unassigned_dac(codec, nid);
2957                 if (dac) {
2958                         if (!spec->multiout.hp_nid)
2959                                 spec->multiout.hp_nid = dac;
2960                         else
2961                                 add_spec_extra_dacs(spec, dac);
2962                 }
2963                 spec->hp_dacs[i] = dac;
2964         }
2965
2966         for (i = 0; i < cfg->speaker_outs; i++) {
2967                 nid = cfg->speaker_pins[i];
2968                 dac = get_unassigned_dac(codec, nid);
2969                 if (dac)
2970                         add_spec_extra_dacs(spec, dac);
2971                 spec->speaker_dacs[i] = dac;
2972         }
2973
2974         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2975                    spec->multiout.num_dacs,
2976                    spec->multiout.dac_nids[0],
2977                    spec->multiout.dac_nids[1],
2978                    spec->multiout.dac_nids[2],
2979                    spec->multiout.dac_nids[3],
2980                    spec->multiout.dac_nids[4]);
2981
2982         return 0;
2983 }
2984
2985 /* create volume control/switch for the given prefx type */
2986 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2987 {
2988         char name[32];
2989         int err;
2990
2991         sprintf(name, "%s Playback Volume", pfx);
2992         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2993                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2994         if (err < 0)
2995                 return err;
2996         sprintf(name, "%s Playback Switch", pfx);
2997         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2998                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2999         if (err < 0)
3000                 return err;
3001         return 0;
3002 }
3003
3004 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3005 {
3006         if (spec->multiout.num_dacs > 4) {
3007                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3008                 return 1;
3009         } else {
3010                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3011                 spec->multiout.num_dacs++;
3012         }
3013         return 0;
3014 }
3015
3016 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3017 {
3018         int i;
3019         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3020                 if (!spec->multiout.extra_out_nid[i]) {
3021                         spec->multiout.extra_out_nid[i] = nid;
3022                         return 0;
3023                 }
3024         }
3025         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3026         return 1;
3027 }
3028
3029 static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
3030 {
3031         int i;
3032
3033         if (spec->autocfg.line_outs != 1)
3034                 return 0;
3035         if (spec->multiout.hp_nid == nid)
3036                 return 0;
3037         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
3038                 if (spec->multiout.extra_out_nid[i] == nid)
3039                         return 0;
3040         return 1;
3041 }
3042
3043 /* add playback controls from the parsed DAC table */
3044 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3045                                                const struct auto_pin_cfg *cfg)
3046 {
3047         struct sigmatel_spec *spec = codec->spec;
3048         static const char *chname[4] = {
3049                 "Front", "Surround", NULL /*CLFE*/, "Side"
3050         };
3051         hda_nid_t nid = 0;
3052         int i, err;
3053         unsigned int wid_caps;
3054
3055         for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
3056                 nid = spec->multiout.dac_nids[i];
3057                 if (i == 2) {
3058                         /* Center/LFE */
3059                         err = create_controls(spec, "Center", nid, 1);
3060                         if (err < 0)
3061                                 return err;
3062                         err = create_controls(spec, "LFE", nid, 2);
3063                         if (err < 0)
3064                                 return err;
3065
3066                         wid_caps = get_wcaps(codec, nid);
3067
3068                         if (wid_caps & AC_WCAP_LR_SWAP) {
3069                                 err = stac92xx_add_control(spec,
3070                                         STAC_CTL_WIDGET_CLFE_SWITCH,
3071                                         "Swap Center/LFE Playback Switch", nid);
3072
3073                                 if (err < 0)
3074                                         return err;
3075                         }
3076
3077                 } else {
3078                         const char *name = chname[i];
3079                         /* if it's a single DAC, assign a better name */
3080                         if (!i && is_unique_dac(spec, nid)) {
3081                                 switch (cfg->line_out_type) {
3082                                 case AUTO_PIN_HP_OUT:
3083                                         name = "Headphone";
3084                                         break;
3085                                 case AUTO_PIN_SPEAKER_OUT:
3086                                         name = "Speaker";
3087                                         break;
3088                                 }
3089                         }
3090                         err = create_controls(spec, name, nid, 3);
3091                         if (err < 0)
3092                                 return err;
3093                 }
3094         }
3095
3096         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3097                 err = stac92xx_add_control(spec,
3098                         STAC_CTL_WIDGET_HP_SWITCH,
3099                         "Headphone as Line Out Switch",
3100                         cfg->hp_pins[cfg->hp_outs - 1]);
3101                 if (err < 0)
3102                         return err;
3103         }
3104
3105         if (spec->line_switch) {
3106                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3107                                            "Line In as Output Switch",
3108                                            spec->line_switch << 8);
3109                 if (err < 0)
3110                         return err;
3111         }
3112
3113         if (spec->mic_switch) {
3114                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3115                                            "Mic as Output Switch",
3116                                            (spec->mic_switch << 8) | 1);
3117                 if (err < 0)
3118                         return err;
3119         }
3120
3121         return 0;
3122 }
3123
3124 /* add playback controls for Speaker and HP outputs */
3125 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3126                                         struct auto_pin_cfg *cfg)
3127 {
3128         struct sigmatel_spec *spec = codec->spec;
3129         hda_nid_t nid;
3130         int i, err, nums;
3131
3132         nums = 0;
3133         for (i = 0; i < cfg->hp_outs; i++) {
3134                 static const char *pfxs[] = {
3135                         "Headphone", "Headphone2", "Headphone3",
3136                 };
3137                 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
3138                 if (wid_caps & AC_WCAP_UNSOL_CAP)
3139                         spec->hp_detect = 1;
3140                 if (nums >= ARRAY_SIZE(pfxs))
3141                         continue;
3142                 nid = spec->hp_dacs[i];
3143                 if (!nid)
3144                         continue;
3145                 err = create_controls(spec, pfxs[nums++], nid, 3);
3146                 if (err < 0)
3147                         return err;
3148         }
3149         nums = 0;
3150         for (i = 0; i < cfg->speaker_outs; i++) {
3151                 static const char *pfxs[] = {
3152                         "Speaker", "External Speaker", "Speaker2",
3153                 };
3154                 if (nums >= ARRAY_SIZE(pfxs))
3155                         continue;
3156                 nid = spec->speaker_dacs[i];
3157                 if (!nid)
3158                         continue;
3159                 err = create_controls(spec, pfxs[nums++], nid, 3);
3160                 if (err < 0)
3161                         return err;
3162         }
3163         return 0;
3164 }
3165
3166 /* labels for mono mux outputs */
3167 static const char *stac92xx_mono_labels[4] = {
3168         "DAC0", "DAC1", "Mixer", "DAC2"
3169 };
3170
3171 /* create mono mux for mono out on capable codecs */
3172 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3173 {
3174         struct sigmatel_spec *spec = codec->spec;
3175         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3176         int i, num_cons;
3177         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3178
3179         num_cons = snd_hda_get_connections(codec,
3180                                 spec->mono_nid,
3181                                 con_lst,
3182                                 HDA_MAX_NUM_INPUTS);
3183         if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3184                 return -EINVAL;
3185
3186         for (i = 0; i < num_cons; i++) {
3187                 mono_mux->items[mono_mux->num_items].label =
3188                                         stac92xx_mono_labels[i];
3189                 mono_mux->items[mono_mux->num_items].index = i;
3190                 mono_mux->num_items++;
3191         }
3192
3193         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3194                                 "Mono Mux", spec->mono_nid);
3195 }
3196
3197 /* labels for amp mux outputs */
3198 static const char *stac92xx_amp_labels[3] = {
3199         "Front Microphone", "Microphone", "Line In",
3200 };
3201
3202 /* create amp out controls mux on capable codecs */
3203 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3204 {
3205         struct sigmatel_spec *spec = codec->spec;
3206         struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3207         int i, err;
3208
3209         for (i = 0; i < spec->num_amps; i++) {
3210                 amp_mux->items[amp_mux->num_items].label =
3211                                         stac92xx_amp_labels[i];
3212                 amp_mux->items[amp_mux->num_items].index = i;
3213                 amp_mux->num_items++;
3214         }
3215
3216         if (spec->num_amps > 1) {
3217                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3218                         "Amp Selector Capture Switch", 0);
3219                 if (err < 0)
3220                         return err;
3221         }
3222         return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3223                 "Amp Capture Volume",
3224                 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3225 }
3226
3227
3228 /* create PC beep volume controls */
3229 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3230                                                 hda_nid_t nid)
3231 {
3232         struct sigmatel_spec *spec = codec->spec;
3233         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3234         int err;
3235
3236         /* check for mute support for the the amp */
3237         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3238                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3239                         "PC Beep Playback Switch",
3240                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3241                         if (err < 0)
3242                                 return err;
3243         }
3244
3245         /* check to see if there is volume support for the amp */
3246         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3247                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3248                         "PC Beep Playback Volume",
3249                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3250                         if (err < 0)
3251                                 return err;
3252         }
3253         return 0;
3254 }
3255
3256 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3257 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3258
3259 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3260                                         struct snd_ctl_elem_value *ucontrol)
3261 {
3262         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3263         ucontrol->value.integer.value[0] = codec->beep->enabled;
3264         return 0;
3265 }
3266
3267 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3268                                         struct snd_ctl_elem_value *ucontrol)
3269 {
3270         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3271         int enabled = !!ucontrol->value.integer.value[0];
3272         if (codec->beep->enabled != enabled) {
3273                 codec->beep->enabled = enabled;
3274                 return 1;
3275         }
3276         return 0;
3277 }
3278
3279 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3280         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3281         .info = stac92xx_dig_beep_switch_info,
3282         .get = stac92xx_dig_beep_switch_get,
3283         .put = stac92xx_dig_beep_switch_put,
3284 };
3285
3286 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3287 {
3288         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3289                                          0, "PC Beep Playback Switch", 0);
3290 }
3291 #endif
3292
3293 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3294 {
3295         struct sigmatel_spec *spec = codec->spec;
3296         int wcaps, nid, i, err = 0;
3297
3298         for (i = 0; i < spec->num_muxes; i++) {
3299                 nid = spec->mux_nids[i];
3300                 wcaps = get_wcaps(codec, nid);
3301
3302                 if (wcaps & AC_WCAP_OUT_AMP) {
3303                         err = stac92xx_add_control_idx(spec,
3304                                 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3305                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3306                         if (err < 0)
3307                                 return err;
3308                 }
3309         }
3310         return 0;
3311 };
3312
3313 static const char *stac92xx_spdif_labels[3] = {
3314         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3315 };
3316
3317 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3318 {
3319         struct sigmatel_spec *spec = codec->spec;
3320         struct hda_input_mux *spdif_mux = &spec->private_smux;
3321         const char **labels = spec->spdif_labels;
3322         int i, num_cons;
3323         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3324
3325         num_cons = snd_hda_get_connections(codec,
3326                                 spec->smux_nids[0],
3327                                 con_lst,
3328                                 HDA_MAX_NUM_INPUTS);
3329         if (!num_cons)
3330                 return -EINVAL;
3331
3332         if (!labels)
3333                 labels = stac92xx_spdif_labels;
3334
3335         for (i = 0; i < num_cons; i++) {
3336                 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3337                 spdif_mux->items[spdif_mux->num_items].index = i;
3338                 spdif_mux->num_items++;
3339         }
3340
3341         return 0;
3342 }
3343
3344 /* labels for dmic mux inputs */
3345 static const char *stac92xx_dmic_labels[5] = {
3346         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3347         "Digital Mic 3", "Digital Mic 4"
3348 };
3349
3350 /* create playback/capture controls for input pins on dmic capable codecs */
3351 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3352                                                 const struct auto_pin_cfg *cfg)
3353 {
3354         struct sigmatel_spec *spec = codec->spec;
3355         struct hda_input_mux *dimux = &spec->private_dimux;
3356         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3357         int err, i, j;
3358         char name[32];
3359
3360         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3361         dimux->items[dimux->num_items].index = 0;
3362         dimux->num_items++;
3363
3364         for (i = 0; i < spec->num_dmics; i++) {
3365                 hda_nid_t nid;
3366                 int index;
3367                 int num_cons;
3368                 unsigned int wcaps;
3369                 unsigned int def_conf;
3370
3371                 def_conf = snd_hda_codec_read(codec,
3372                                               spec->dmic_nids[i],
3373                                               0,
3374                                               AC_VERB_GET_CONFIG_DEFAULT,
3375                                               0);
3376                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3377                         continue;
3378
3379                 nid = spec->dmic_nids[i];
3380                 num_cons = snd_hda_get_connections(codec,
3381                                 spec->dmux_nids[0],
3382                                 con_lst,
3383                                 HDA_MAX_NUM_INPUTS);
3384                 for (j = 0; j < num_cons; j++)
3385                         if (con_lst[j] == nid) {
3386                                 index = j;
3387                                 goto found;
3388                         }
3389                 continue;
3390 found:
3391                 wcaps = get_wcaps(codec, nid) &
3392                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3393
3394                 if (wcaps) {
3395                         sprintf(name, "%s Capture Volume",
3396                                 stac92xx_dmic_labels[dimux->num_items]);
3397
3398                         err = stac92xx_add_control(spec,
3399                                 STAC_CTL_WIDGET_VOL,
3400                                 name,
3401                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3402                                 (wcaps & AC_WCAP_OUT_AMP) ?
3403                                 HDA_OUTPUT : HDA_INPUT));
3404                         if (err < 0)
3405                                 return err;
3406                 }
3407
3408                 dimux->items[dimux->num_items].label =
3409                         stac92xx_dmic_labels[dimux->num_items];
3410                 dimux->items[dimux->num_items].index = index;
3411                 dimux->num_items++;
3412         }
3413
3414         return 0;
3415 }
3416
3417 /* create playback/capture controls for input pins */
3418 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3419 {
3420         struct sigmatel_spec *spec = codec->spec;
3421         struct hda_input_mux *imux = &spec->private_imux;
3422         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3423         int i, j, k;
3424
3425         for (i = 0; i < AUTO_PIN_LAST; i++) {
3426                 int index;
3427
3428                 if (!cfg->input_pins[i])
3429                         continue;
3430                 index = -1;
3431                 for (j = 0; j < spec->num_muxes; j++) {
3432                         int num_cons;
3433                         num_cons = snd_hda_get_connections(codec,
3434                                                            spec->mux_nids[j],
3435                                                            con_lst,
3436                                                            HDA_MAX_NUM_INPUTS);
3437                         for (k = 0; k < num_cons; k++)
3438                                 if (con_lst[k] == cfg->input_pins[i]) {
3439                                         index = k;
3440                                         goto found;
3441                                 }
3442                 }
3443                 continue;
3444         found:
3445                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3446                 imux->items[imux->num_items].index = index;
3447                 imux->num_items++;
3448         }
3449
3450         if (imux->num_items) {
3451                 /*
3452                  * Set the current input for the muxes.
3453                  * The STAC9221 has two input muxes with identical source
3454                  * NID lists.  Hopefully this won't get confused.
3455                  */
3456                 for (i = 0; i < spec->num_muxes; i++) {
3457                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3458                                                   AC_VERB_SET_CONNECT_SEL,
3459                                                   imux->items[0].index);
3460                 }
3461         }
3462
3463         return 0;
3464 }
3465
3466 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3467 {
3468         struct sigmatel_spec *spec = codec->spec;
3469         int i;
3470
3471         for (i = 0; i < spec->autocfg.line_outs; i++) {
3472                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3473                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3474         }
3475 }
3476
3477 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3478 {
3479         struct sigmatel_spec *spec = codec->spec;
3480         int i;
3481
3482         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3483                 hda_nid_t pin;
3484                 pin = spec->autocfg.hp_pins[i];
3485                 if (pin) /* connect to front */
3486                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3487         }
3488         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3489                 hda_nid_t pin;
3490                 pin = spec->autocfg.speaker_pins[i];
3491                 if (pin) /* connect to front */
3492                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3493         }
3494 }
3495
3496 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3497 {
3498         struct sigmatel_spec *spec = codec->spec;
3499         int err;
3500
3501         if ((err = snd_hda_parse_pin_def_config(codec,
3502                                                 &spec->autocfg,
3503                                                 spec->dmic_nids)) < 0)
3504                 return err;
3505         if (! spec->autocfg.line_outs)
3506                 return 0; /* can't find valid pin config */
3507
3508         /* If we have no real line-out pin and multiple hp-outs, HPs should
3509          * be set up as multi-channel outputs.
3510          */
3511         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3512             spec->autocfg.hp_outs > 1) {
3513                 /* Copy hp_outs to line_outs, backup line_outs in
3514                  * speaker_outs so that the following routines can handle
3515                  * HP pins as primary outputs.
3516                  */
3517                 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3518                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3519                        sizeof(spec->autocfg.line_out_pins));
3520                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3521                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3522                        sizeof(spec->autocfg.hp_pins));
3523                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3524                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3525                 spec->autocfg.hp_outs = 0;
3526         }
3527         if (spec->autocfg.mono_out_pin) {
3528                 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3529                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3530                 u32 caps = query_amp_caps(codec,
3531                                 spec->autocfg.mono_out_pin, dir);
3532                 hda_nid_t conn_list[1];
3533
3534                 /* get the mixer node and then the mono mux if it exists */
3535                 if (snd_hda_get_connections(codec,
3536                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
3537                                 snd_hda_get_connections(codec, conn_list[0],
3538                                 conn_list, 1)) {
3539
3540                                 int wcaps = get_wcaps(codec, conn_list[0]);
3541                                 int wid_type = (wcaps & AC_WCAP_TYPE)
3542                                         >> AC_WCAP_TYPE_SHIFT;
3543                                 /* LR swap check, some stac925x have a mux that
3544                                  * changes the DACs output path instead of the
3545                                  * mono-mux path.
3546                                  */
3547                                 if (wid_type == AC_WID_AUD_SEL &&
3548                                                 !(wcaps & AC_WCAP_LR_SWAP))
3549                                         spec->mono_nid = conn_list[0];
3550                 }
3551                 if (dir) {
3552                         hda_nid_t nid = spec->autocfg.mono_out_pin;
3553
3554                         /* most mono outs have a least a mute/unmute switch */
3555                         dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3556                         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3557                                 "Mono Playback Switch",
3558                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3559                         if (err < 0)
3560                                 return err;
3561                         /* check for volume support for the amp */
3562                         if ((caps & AC_AMPCAP_NUM_STEPS)
3563                                         >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3564                                 err = stac92xx_add_control(spec,
3565                                         STAC_CTL_WIDGET_VOL,
3566                                         "Mono Playback Volume",
3567                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3568                                 if (err < 0)
3569                                         return err;
3570                         }
3571                 }
3572
3573                 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3574                                          AC_PINCTL_OUT_EN);
3575         }
3576
3577         if (!spec->multiout.num_dacs) {
3578                 err = stac92xx_auto_fill_dac_nids(codec);
3579                 if (err < 0)
3580                         return err;
3581                 err = stac92xx_auto_create_multi_out_ctls(codec,
3582                                                           &spec->autocfg);
3583                 if (err < 0)
3584                         return err;
3585         }
3586
3587         /* setup analog beep controls */
3588         if (spec->anabeep_nid > 0) {
3589                 err = stac92xx_auto_create_beep_ctls(codec,
3590                         spec->anabeep_nid);
3591                 if (err < 0)
3592                         return err;
3593         }
3594
3595         /* setup digital beep controls and input device */
3596 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3597         if (spec->digbeep_nid > 0) {
3598                 hda_nid_t nid = spec->digbeep_nid;
3599                 unsigned int caps;
3600
3601                 err = stac92xx_auto_create_beep_ctls(codec, nid);
3602                 if (err < 0)
3603                         return err;
3604                 err = snd_hda_attach_beep_device(codec, nid);
3605                 if (err < 0)
3606                         return err;
3607                 /* if no beep switch is available, make its own one */
3608                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3609                 if (codec->beep &&
3610                     !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3611                         err = stac92xx_beep_switch_ctl(codec);
3612                         if (err < 0)
3613                                 return err;
3614                 }
3615         }
3616 #endif
3617
3618         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3619
3620         if (err < 0)
3621                 return err;
3622
3623         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3624
3625         if (err < 0)
3626                 return err;
3627
3628         if (spec->mono_nid > 0) {
3629                 err = stac92xx_auto_create_mono_output_ctls(codec);
3630                 if (err < 0)
3631                         return err;
3632         }
3633         if (spec->num_amps > 0) {
3634                 err = stac92xx_auto_create_amp_output_ctls(codec);
3635                 if (err < 0)
3636                         return err;
3637         }
3638         if (spec->num_dmics > 0 && !spec->dinput_mux)
3639                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3640                                                 &spec->autocfg)) < 0)
3641                         return err;
3642         if (spec->num_muxes > 0) {
3643                 err = stac92xx_auto_create_mux_input_ctls(codec);
3644                 if (err < 0)
3645                         return err;
3646         }
3647         if (spec->num_smuxes > 0) {
3648                 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3649                 if (err < 0)
3650                         return err;
3651         }
3652
3653         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3654         if (spec->multiout.max_channels > 2)
3655                 spec->surr_switch = 1;
3656
3657         if (spec->autocfg.dig_out_pin)
3658                 spec->multiout.dig_out_nid = dig_out;
3659         if (dig_in && spec->autocfg.dig_in_pin)
3660                 spec->dig_in_nid = dig_in;
3661
3662         if (spec->kctls.list)
3663                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3664
3665         spec->input_mux = &spec->private_imux;
3666         if (!spec->dinput_mux)
3667                 spec->dinput_mux = &spec->private_dimux;
3668         spec->sinput_mux = &spec->private_smux;
3669         spec->mono_mux = &spec->private_mono_mux;
3670         spec->amp_mux = &spec->private_amp_mux;
3671         return 1;
3672 }
3673
3674 /* add playback controls for HP output */
3675 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3676                                         struct auto_pin_cfg *cfg)
3677 {
3678         struct sigmatel_spec *spec = codec->spec;
3679         hda_nid_t pin = cfg->hp_pins[0];
3680         unsigned int wid_caps;
3681
3682         if (! pin)
3683                 return 0;
3684
3685         wid_caps = get_wcaps(codec, pin);
3686         if (wid_caps & AC_WCAP_UNSOL_CAP)
3687                 spec->hp_detect = 1;
3688
3689         return 0;
3690 }
3691
3692 /* add playback controls for LFE output */
3693 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3694                                         struct auto_pin_cfg *cfg)
3695 {
3696         struct sigmatel_spec *spec = codec->spec;
3697         int err;
3698         hda_nid_t lfe_pin = 0x0;
3699         int i;
3700
3701         /*
3702          * search speaker outs and line outs for a mono speaker pin
3703          * with an amp.  If one is found, add LFE controls
3704          * for it.
3705          */
3706         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3707                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3708                 unsigned int wcaps = get_wcaps(codec, pin);
3709                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3710                 if (wcaps == AC_WCAP_OUT_AMP)
3711                         /* found a mono speaker with an amp, must be lfe */
3712                         lfe_pin = pin;
3713         }
3714
3715         /* if speaker_outs is 0, then speakers may be in line_outs */
3716         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3717                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3718                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
3719                         unsigned int defcfg;
3720                         defcfg = snd_hda_codec_read(codec, pin, 0,
3721                                                  AC_VERB_GET_CONFIG_DEFAULT,
3722                                                  0x00);
3723                         if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3724                                 unsigned int wcaps = get_wcaps(codec, pin);
3725                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3726                                 if (wcaps == AC_WCAP_OUT_AMP)
3727                                         /* found a mono speaker with an amp,
3728                                            must be lfe */
3729                                         lfe_pin = pin;
3730                         }
3731                 }
3732         }
3733
3734         if (lfe_pin) {
3735                 err = create_controls(spec, "LFE", lfe_pin, 1);
3736                 if (err < 0)
3737                         return err;
3738         }
3739
3740         return 0;
3741 }
3742
3743 static int stac9200_parse_auto_config(struct hda_codec *codec)
3744 {
3745         struct sigmatel_spec *spec = codec->spec;
3746         int err;
3747
3748         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3749                 return err;
3750
3751         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3752                 return err;
3753
3754         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3755                 return err;
3756
3757         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3758                 return err;
3759
3760         if (spec->num_muxes > 0) {
3761                 err = stac92xx_auto_create_mux_input_ctls(codec);
3762                 if (err < 0)
3763                         return err;
3764         }
3765
3766         if (spec->autocfg.dig_out_pin)
3767                 spec->multiout.dig_out_nid = 0x05;
3768         if (spec->autocfg.dig_in_pin)
3769                 spec->dig_in_nid = 0x04;
3770
3771         if (spec->kctls.list)
3772                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3773
3774         spec->input_mux = &spec->private_imux;
3775         spec->dinput_mux = &spec->private_dimux;
3776
3777         return 1;
3778 }
3779
3780 /*
3781  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3782  * funky external mute control using GPIO pins.
3783  */
3784
3785 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3786                           unsigned int dir_mask, unsigned int data)
3787 {
3788         unsigned int gpiostate, gpiomask, gpiodir;
3789
3790         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3791                                        AC_VERB_GET_GPIO_DATA, 0);
3792         gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3793
3794         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3795                                       AC_VERB_GET_GPIO_MASK, 0);
3796         gpiomask |= mask;
3797
3798         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3799                                      AC_VERB_GET_GPIO_DIRECTION, 0);
3800         gpiodir |= dir_mask;
3801
3802         /* Configure GPIOx as CMOS */
3803         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3804
3805         snd_hda_codec_write(codec, codec->afg, 0,
3806                             AC_VERB_SET_GPIO_MASK, gpiomask);
3807         snd_hda_codec_read(codec, codec->afg, 0,
3808                            AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3809
3810         msleep(1);
3811
3812         snd_hda_codec_read(codec, codec->afg, 0,
3813                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3814 }
3815
3816 static int stac92xx_add_jack(struct hda_codec *codec,
3817                 hda_nid_t nid, int type)
3818 {
3819 #ifdef CONFIG_SND_JACK
3820         struct sigmatel_spec *spec = codec->spec;
3821         struct sigmatel_jack *jack;
3822         int def_conf = snd_hda_codec_read(codec, nid,
3823                         0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3824         int connectivity = get_defcfg_connect(def_conf);
3825         char name[32];
3826
3827         if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3828                 return 0;
3829
3830         snd_array_init(&spec->jacks, sizeof(*jack), 32);
3831         jack = snd_array_new(&spec->jacks);
3832         if (!jack)
3833                 return -ENOMEM;
3834         jack->nid = nid;
3835         jack->type = type;
3836
3837         sprintf(name, "%s at %s %s Jack",
3838                 snd_hda_get_jack_type(def_conf),
3839                 snd_hda_get_jack_connectivity(def_conf),
3840                 snd_hda_get_jack_location(def_conf));
3841
3842         return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3843 #else
3844         return 0;
3845 #endif
3846 }
3847
3848 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3849                           unsigned char type, int data)
3850 {
3851         struct sigmatel_event *event;
3852
3853         snd_array_init(&spec->events, sizeof(*event), 32);
3854         event = snd_array_new(&spec->events);
3855         if (!event)
3856                 return -ENOMEM;
3857         event->nid = nid;
3858         event->type = type;
3859         event->tag = spec->events.used;
3860         event->data = data;
3861
3862         return event->tag;
3863 }
3864
3865 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3866                                              hda_nid_t nid, unsigned char type)
3867 {
3868         struct sigmatel_spec *spec = codec->spec;
3869         struct sigmatel_event *event = spec->events.list;
3870         int i;
3871
3872         for (i = 0; i < spec->events.used; i++, event++) {
3873                 if (event->nid == nid && event->type == type)
3874                         return event;
3875         }
3876         return NULL;
3877 }
3878
3879 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3880                                                       unsigned char tag)
3881 {
3882         struct sigmatel_spec *spec = codec->spec;
3883         struct sigmatel_event *event = spec->events.list;
3884         int i;
3885
3886         for (i = 0; i < spec->events.used; i++, event++) {
3887                 if (event->tag == tag)
3888                         return event;
3889         }
3890         return NULL;
3891 }
3892
3893 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3894                               unsigned int type)
3895 {
3896         struct sigmatel_event *event;
3897         int tag;
3898
3899         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3900                 return;
3901         event = stac_get_event(codec, nid, type);
3902         if (event)
3903                 tag = event->tag;
3904         else
3905                 tag = stac_add_event(codec->spec, nid, type, 0);
3906         if (tag < 0)
3907                 return;
3908         snd_hda_codec_write_cache(codec, nid, 0,
3909                                   AC_VERB_SET_UNSOLICITED_ENABLE,
3910                                   AC_USRSP_EN | tag);
3911 }
3912
3913 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3914 {
3915         int i;
3916         for (i = 0; i < cfg->hp_outs; i++)
3917                 if (cfg->hp_pins[i] == nid)
3918                         return 1; /* nid is a HP-Out */
3919
3920         return 0; /* nid is not a HP-Out */
3921 };
3922
3923 static void stac92xx_power_down(struct hda_codec *codec)
3924 {
3925         struct sigmatel_spec *spec = codec->spec;
3926
3927         /* power down inactive DACs */
3928         hda_nid_t *dac;
3929         for (dac = spec->dac_list; *dac; dac++)
3930                 if (!check_all_dac_nids(spec, *dac))
3931                         snd_hda_codec_write(codec, *dac, 0,
3932                                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3933 }
3934
3935 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3936                                   int enable);
3937
3938 static int stac92xx_init(struct hda_codec *codec)
3939 {
3940         struct sigmatel_spec *spec = codec->spec;
3941         struct auto_pin_cfg *cfg = &spec->autocfg;
3942         unsigned int gpio;
3943         int i;
3944
3945         snd_hda_sequence_write(codec, spec->init);
3946
3947         /* power down adcs initially */
3948         if (spec->powerdown_adcs)
3949                 for (i = 0; i < spec->num_adcs; i++)
3950                         snd_hda_codec_write(codec,
3951                                 spec->adc_nids[i], 0,
3952                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3953
3954         /* set up GPIO */
3955         gpio = spec->gpio_data;
3956         /* turn on EAPD statically when spec->eapd_switch isn't set.
3957          * otherwise, unsol event will turn it on/off dynamically
3958          */
3959         if (!spec->eapd_switch)
3960                 gpio |= spec->eapd_mask;
3961         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
3962
3963         /* set up pins */
3964         if (spec->hp_detect) {
3965                 /* Enable unsolicited responses on the HP widget */
3966                 for (i = 0; i < cfg->hp_outs; i++) {
3967                         hda_nid_t nid = cfg->hp_pins[i];
3968                         enable_pin_detect(codec, nid, STAC_HP_EVENT);
3969                 }
3970                 /* force to enable the first line-out; the others are set up
3971                  * in unsol_event
3972                  */
3973                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3974                                 AC_PINCTL_OUT_EN);
3975                 /* fake event to set up pins */
3976                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
3977                                        STAC_HP_EVENT);
3978         } else {
3979                 stac92xx_auto_init_multi_out(codec);
3980                 stac92xx_auto_init_hp_out(codec);
3981                 for (i = 0; i < cfg->hp_outs; i++)
3982                         stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
3983         }
3984         for (i = 0; i < AUTO_PIN_LAST; i++) {
3985                 hda_nid_t nid = cfg->input_pins[i];
3986                 if (nid) {
3987                         unsigned int pinctl, conf;
3988                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3989                                 /* for mic pins, force to initialize */
3990                                 pinctl = stac92xx_get_vref(codec, nid);
3991                                 pinctl |= AC_PINCTL_IN_EN;
3992                                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3993                         } else {
3994                                 pinctl = snd_hda_codec_read(codec, nid, 0,
3995                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3996                                 /* if PINCTL already set then skip */
3997                                 if (!(pinctl & AC_PINCTL_IN_EN)) {
3998                                         pinctl |= AC_PINCTL_IN_EN;
3999                                         stac92xx_auto_set_pinctl(codec, nid,
4000                                                                  pinctl);
4001                                 }
4002                         }
4003                         conf = snd_hda_codec_read(codec, nid, 0,
4004                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
4005                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4006                                 enable_pin_detect(codec, nid,
4007                                                   STAC_INSERT_EVENT);
4008                                 stac_issue_unsol_event(codec, nid,
4009                                                        STAC_INSERT_EVENT);
4010                         }
4011                 }
4012         }
4013         for (i = 0; i < spec->num_dmics; i++)
4014                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4015                                         AC_PINCTL_IN_EN);
4016         if (cfg->dig_out_pin)
4017                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
4018                                          AC_PINCTL_OUT_EN);
4019         if (cfg->dig_in_pin)
4020                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4021                                          AC_PINCTL_IN_EN);
4022         for (i = 0; i < spec->num_pwrs; i++)  {
4023                 hda_nid_t nid = spec->pwr_nids[i];
4024                 int pinctl, def_conf;
4025
4026                 /* power on when no jack detection is available */
4027                 if (!spec->hp_detect) {
4028                         stac_toggle_power_map(codec, nid, 1);
4029                         continue;
4030                 }
4031
4032                 if (is_nid_hp_pin(cfg, nid))
4033                         continue; /* already has an unsol event */
4034
4035                 pinctl = snd_hda_codec_read(codec, nid, 0,
4036                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4037                 /* outputs are only ports capable of power management
4038                  * any attempts on powering down a input port cause the
4039                  * referenced VREF to act quirky.
4040                  */
4041                 if (pinctl & AC_PINCTL_IN_EN) {
4042                         stac_toggle_power_map(codec, nid, 1);
4043                         continue;
4044                 }
4045                 def_conf = snd_hda_codec_read(codec, nid, 0,
4046                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
4047                 def_conf = get_defcfg_connect(def_conf);
4048                 /* skip any ports that don't have jacks since presence
4049                  * detection is useless */
4050                 if (def_conf != AC_JACK_PORT_COMPLEX) {
4051                         if (def_conf != AC_JACK_PORT_NONE)
4052                                 stac_toggle_power_map(codec, nid, 1);
4053                         continue;
4054                 }
4055                 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4056                         enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4057                         stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4058                 }
4059         }
4060         if (spec->dac_list)
4061                 stac92xx_power_down(codec);
4062         return 0;
4063 }
4064
4065 static void stac92xx_free_jacks(struct hda_codec *codec)
4066 {
4067 #ifdef CONFIG_SND_JACK
4068         /* free jack instances manually when clearing/reconfiguring */
4069         struct sigmatel_spec *spec = codec->spec;
4070         if (!codec->bus->shutdown && spec->jacks.list) {
4071                 struct sigmatel_jack *jacks = spec->jacks.list;
4072                 int i;
4073                 for (i = 0; i < spec->jacks.used; i++)
4074                         snd_device_free(codec->bus->card, &jacks[i].jack);
4075         }
4076         snd_array_free(&spec->jacks);
4077 #endif
4078 }
4079
4080 static void stac92xx_free_kctls(struct hda_codec *codec)
4081 {
4082         struct sigmatel_spec *spec = codec->spec;
4083
4084         if (spec->kctls.list) {
4085                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4086                 int i;
4087                 for (i = 0; i < spec->kctls.used; i++)
4088                         kfree(kctl[i].name);
4089         }
4090         snd_array_free(&spec->kctls);
4091 }
4092
4093 static void stac92xx_free(struct hda_codec *codec)
4094 {
4095         struct sigmatel_spec *spec = codec->spec;
4096
4097         if (! spec)
4098                 return;
4099
4100         kfree(spec->pin_configs);
4101         stac92xx_free_jacks(codec);
4102         snd_array_free(&spec->events);
4103
4104         kfree(spec);
4105         snd_hda_detach_beep_device(codec);
4106 }
4107
4108 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4109                                 unsigned int flag)
4110 {
4111         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4112                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4113
4114         if (pin_ctl & AC_PINCTL_IN_EN) {
4115                 /*
4116                  * we need to check the current set-up direction of
4117                  * shared input pins since they can be switched via
4118                  * "xxx as Output" mixer switch
4119                  */
4120                 struct sigmatel_spec *spec = codec->spec;
4121                 if (nid == spec->line_switch || nid == spec->mic_switch)
4122                         return;
4123         }
4124
4125         /* if setting pin direction bits, clear the current
4126            direction bits first */
4127         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4128                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4129
4130         snd_hda_codec_write_cache(codec, nid, 0,
4131                         AC_VERB_SET_PIN_WIDGET_CONTROL,
4132                         pin_ctl | flag);
4133 }
4134
4135 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4136                                   unsigned int flag)
4137 {
4138         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4139                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4140         snd_hda_codec_write_cache(codec, nid, 0,
4141                         AC_VERB_SET_PIN_WIDGET_CONTROL,
4142                         pin_ctl & ~flag);
4143 }
4144
4145 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4146 {
4147         if (!nid)
4148                 return 0;
4149         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4150             & (1 << 31))
4151                 return 1;
4152         return 0;
4153 }
4154
4155 /* return non-zero if the hp-pin of the given array index isn't
4156  * a jack-detection target
4157  */
4158 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4159 {
4160         struct auto_pin_cfg *cfg = &spec->autocfg;
4161
4162         /* ignore sensing of shared line and mic jacks */
4163         if (cfg->hp_pins[i] == spec->line_switch)
4164                 return 1;
4165         if (cfg->hp_pins[i] == spec->mic_switch)
4166                 return 1;
4167         /* ignore if the pin is set as line-out */
4168         if (cfg->hp_pins[i] == spec->hp_switch)
4169                 return 1;
4170         return 0;
4171 }
4172
4173 static void stac92xx_hp_detect(struct hda_codec *codec)
4174 {
4175         struct sigmatel_spec *spec = codec->spec;
4176         struct auto_pin_cfg *cfg = &spec->autocfg;
4177         int i, presence;
4178
4179         presence = 0;
4180         if (spec->gpio_mute)
4181                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4182                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4183
4184         for (i = 0; i < cfg->hp_outs; i++) {
4185                 if (presence)
4186                         break;
4187                 if (no_hp_sensing(spec, i))
4188                         continue;
4189                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4190                 if (presence) {
4191                         unsigned int pinctl;
4192                         pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4193                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4194                         if (pinctl & AC_PINCTL_IN_EN)
4195                                 presence = 0; /* mic- or line-input */
4196                 }
4197         }
4198
4199         if (presence) {
4200                 /* disable lineouts */
4201                 if (spec->hp_switch)
4202                         stac92xx_reset_pinctl(codec, spec->hp_switch,
4203                                               AC_PINCTL_OUT_EN);
4204                 for (i = 0; i < cfg->line_outs; i++)
4205                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4206                                                 AC_PINCTL_OUT_EN);
4207                 for (i = 0; i < cfg->speaker_outs; i++)
4208                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4209                                                 AC_PINCTL_OUT_EN);
4210                 if (spec->eapd_mask && spec->eapd_switch)
4211                         stac_gpio_set(codec, spec->gpio_mask,
4212                                 spec->gpio_dir, spec->gpio_data &
4213                                 ~spec->eapd_mask);
4214         } else {
4215                 /* enable lineouts */
4216                 if (spec->hp_switch)
4217                         stac92xx_set_pinctl(codec, spec->hp_switch,
4218                                             AC_PINCTL_OUT_EN);
4219                 for (i = 0; i < cfg->line_outs; i++)
4220                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4221                                                 AC_PINCTL_OUT_EN);
4222                 for (i = 0; i < cfg->speaker_outs; i++)
4223                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4224                                                 AC_PINCTL_OUT_EN);
4225                 if (spec->eapd_mask && spec->eapd_switch)
4226                         stac_gpio_set(codec, spec->gpio_mask,
4227                                 spec->gpio_dir, spec->gpio_data |
4228                                 spec->eapd_mask);
4229         }
4230         /* toggle hp outs */
4231         for (i = 0; i < cfg->hp_outs; i++) {
4232                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4233                 if (no_hp_sensing(spec, i))
4234                         continue;
4235                 if (presence)
4236                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4237 #if 0 /* FIXME */
4238 /* Resetting the pinctl like below may lead to (a sort of) regressions
4239  * on some devices since they use the HP pin actually for line/speaker
4240  * outs although the default pin config shows a different pin (that is
4241  * wrong and useless).
4242  *
4243  * So, it's basically a problem of default pin configs, likely a BIOS issue.
4244  * But, disabling the code below just works around it, and I'm too tired of
4245  * bug reports with such devices...
4246  */
4247                 else
4248                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4249 #endif /* FIXME */
4250         }
4251 }
4252
4253 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4254                                   int enable)
4255 {
4256         struct sigmatel_spec *spec = codec->spec;
4257         unsigned int idx, val;
4258
4259         for (idx = 0; idx < spec->num_pwrs; idx++) {
4260                 if (spec->pwr_nids[idx] == nid)
4261                         break;
4262         }
4263         if (idx >= spec->num_pwrs)
4264                 return;
4265
4266         /* several codecs have two power down bits */
4267         if (spec->pwr_mapping)
4268                 idx = spec->pwr_mapping[idx];
4269         else
4270                 idx = 1 << idx;
4271
4272         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4273         if (enable)
4274                 val &= ~idx;
4275         else
4276                 val |= idx;
4277
4278         /* power down unused output ports */
4279         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4280 }
4281
4282 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4283 {
4284         stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4285 }
4286
4287 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4288 {
4289         struct sigmatel_spec *spec = codec->spec;
4290         struct sigmatel_jack *jacks = spec->jacks.list;
4291
4292         if (jacks) {
4293                 int i;
4294                 for (i = 0; i < spec->jacks.used; i++) {
4295                         if (jacks->nid == nid) {
4296                                 unsigned int pin_ctl =
4297                                         snd_hda_codec_read(codec, nid,
4298                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4299                                          0x00);
4300                                 int type = jacks->type;
4301                                 if (type == (SND_JACK_LINEOUT
4302                                                 | SND_JACK_HEADPHONE))
4303                                         type = (pin_ctl & AC_PINCTL_HP_EN)
4304                                         ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4305                                 snd_jack_report(jacks->jack,
4306                                         get_pin_presence(codec, nid)
4307                                         ? type : 0);
4308                         }
4309                         jacks++;
4310                 }
4311         }
4312 }
4313
4314 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4315                                    unsigned char type)
4316 {
4317         struct sigmatel_event *event = stac_get_event(codec, nid, type);
4318         if (!event)
4319                 return;
4320         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4321 }
4322
4323 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4324 {
4325         struct sigmatel_spec *spec = codec->spec;
4326         struct sigmatel_event *event;
4327         int tag, data;
4328
4329         tag = (res >> 26) & 0x7f;
4330         event = stac_get_event_from_tag(codec, tag);
4331         if (!event)
4332                 return;
4333
4334         switch (event->type) {
4335         case STAC_HP_EVENT:
4336                 stac92xx_hp_detect(codec);
4337                 /* fallthru */
4338         case STAC_INSERT_EVENT:
4339         case STAC_PWR_EVENT:
4340                 if (spec->num_pwrs > 0)
4341                         stac92xx_pin_sense(codec, event->nid);
4342                 stac92xx_report_jack(codec, event->nid);
4343                 break;
4344         case STAC_VREF_EVENT:
4345                 data = snd_hda_codec_read(codec, codec->afg, 0,
4346                                           AC_VERB_GET_GPIO_DATA, 0);
4347                 /* toggle VREF state based on GPIOx status */
4348                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4349                                     !!(data & (1 << event->data)));
4350                 break;
4351         }
4352 }
4353
4354 #ifdef CONFIG_PROC_FS
4355 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4356                                struct hda_codec *codec, hda_nid_t nid)
4357 {
4358         if (nid == codec->afg)
4359                 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4360                             snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4361 }
4362
4363 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4364                                   struct hda_codec *codec,
4365                                   unsigned int verb)
4366 {
4367         snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4368                     snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4369 }
4370
4371 /* stac92hd71bxx, stac92hd73xx */
4372 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4373                                  struct hda_codec *codec, hda_nid_t nid)
4374 {
4375         stac92hd_proc_hook(buffer, codec, nid);
4376         if (nid == codec->afg)
4377                 analog_loop_proc_hook(buffer, codec, 0xfa0);
4378 }
4379
4380 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4381                                struct hda_codec *codec, hda_nid_t nid)
4382 {
4383         if (nid == codec->afg)
4384                 analog_loop_proc_hook(buffer, codec, 0xfe0);
4385 }
4386
4387 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4388                                struct hda_codec *codec, hda_nid_t nid)
4389 {
4390         if (nid == codec->afg)
4391                 analog_loop_proc_hook(buffer, codec, 0xfeb);
4392 }
4393 #else
4394 #define stac92hd_proc_hook      NULL
4395 #define stac92hd7x_proc_hook    NULL
4396 #define stac9205_proc_hook      NULL
4397 #define stac927x_proc_hook      NULL
4398 #endif
4399
4400 #ifdef SND_HDA_NEEDS_RESUME
4401 static int stac92xx_resume(struct hda_codec *codec)
4402 {
4403         struct sigmatel_spec *spec = codec->spec;
4404
4405         stac92xx_set_config_regs(codec);
4406         stac92xx_init(codec);
4407         snd_hda_codec_resume_amp(codec);
4408         snd_hda_codec_resume_cache(codec);
4409         /* fake event to set up pins again to override cached values */
4410         if (spec->hp_detect)
4411                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4412                                        STAC_HP_EVENT);
4413         return 0;
4414 }
4415
4416 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4417 {
4418         struct sigmatel_spec *spec = codec->spec;
4419         if (spec->eapd_mask)
4420                 stac_gpio_set(codec, spec->gpio_mask,
4421                                 spec->gpio_dir, spec->gpio_data &
4422                                 ~spec->eapd_mask);
4423         return 0;
4424 }
4425 #endif
4426
4427 static struct hda_codec_ops stac92xx_patch_ops = {
4428         .build_controls = stac92xx_build_controls,
4429         .build_pcms = stac92xx_build_pcms,
4430         .init = stac92xx_init,
4431         .free = stac92xx_free,
4432         .unsol_event = stac92xx_unsol_event,
4433 #ifdef SND_HDA_NEEDS_RESUME
4434         .suspend = stac92xx_suspend,
4435         .resume = stac92xx_resume,
4436 #endif
4437 };
4438
4439 static int patch_stac9200(struct hda_codec *codec)
4440 {
4441         struct sigmatel_spec *spec;
4442         int err;
4443
4444         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4445         if (spec == NULL)
4446                 return -ENOMEM;
4447
4448         codec->spec = spec;
4449         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4450         spec->pin_nids = stac9200_pin_nids;
4451         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4452                                                         stac9200_models,
4453                                                         stac9200_cfg_tbl);
4454         if (spec->board_config < 0) {
4455                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4456                 err = stac92xx_save_bios_config_regs(codec);
4457         } else
4458                 err = stac_save_pin_cfgs(codec,
4459                                          stac9200_brd_tbl[spec->board_config]);
4460         if (err < 0) {
4461                 stac92xx_free(codec);
4462                 return err;
4463         }
4464
4465         spec->multiout.max_channels = 2;
4466         spec->multiout.num_dacs = 1;
4467         spec->multiout.dac_nids = stac9200_dac_nids;
4468         spec->adc_nids = stac9200_adc_nids;
4469         spec->mux_nids = stac9200_mux_nids;
4470         spec->num_muxes = 1;
4471         spec->num_dmics = 0;
4472         spec->num_adcs = 1;
4473         spec->num_pwrs = 0;
4474
4475         if (spec->board_config == STAC_9200_M4 ||
4476             spec->board_config == STAC_9200_M4_2 ||
4477             spec->board_config == STAC_9200_OQO)
4478                 spec->init = stac9200_eapd_init;
4479         else
4480                 spec->init = stac9200_core_init;
4481         spec->mixer = stac9200_mixer;
4482
4483         if (spec->board_config == STAC_9200_PANASONIC) {
4484                 spec->gpio_mask = spec->gpio_dir = 0x09;
4485                 spec->gpio_data = 0x00;
4486         }
4487
4488         err = stac9200_parse_auto_config(codec);
4489         if (err < 0) {
4490                 stac92xx_free(codec);
4491                 return err;
4492         }
4493
4494         /* CF-74 has no headphone detection, and the driver should *NOT*
4495          * do detection and HP/speaker toggle because the hardware does it.
4496          */
4497         if (spec->board_config == STAC_9200_PANASONIC)
4498                 spec->hp_detect = 0;
4499
4500         codec->patch_ops = stac92xx_patch_ops;
4501
4502         return 0;
4503 }
4504
4505 static int patch_stac925x(struct hda_codec *codec)
4506 {
4507         struct sigmatel_spec *spec;
4508         int err;
4509
4510         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4511         if (spec == NULL)
4512                 return -ENOMEM;
4513
4514         codec->spec = spec;
4515         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4516         spec->pin_nids = stac925x_pin_nids;
4517
4518         /* Check first for codec ID */
4519         spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4520                                                         STAC_925x_MODELS,
4521                                                         stac925x_models,
4522                                                         stac925x_codec_id_cfg_tbl);
4523
4524         /* Now checks for PCI ID, if codec ID is not found */
4525         if (spec->board_config < 0)
4526                 spec->board_config = snd_hda_check_board_config(codec,
4527                                                         STAC_925x_MODELS,
4528                                                         stac925x_models,
4529                                                         stac925x_cfg_tbl);
4530  again:
4531         if (spec->board_config < 0) {
4532                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4533                                       "using BIOS defaults\n");
4534                 err = stac92xx_save_bios_config_regs(codec);
4535         } else
4536                 err = stac_save_pin_cfgs(codec,
4537                                          stac925x_brd_tbl[spec->board_config]);
4538         if (err < 0) {
4539                 stac92xx_free(codec);
4540                 return err;
4541         }
4542
4543         spec->multiout.max_channels = 2;
4544         spec->multiout.num_dacs = 1;
4545         spec->multiout.dac_nids = stac925x_dac_nids;
4546         spec->adc_nids = stac925x_adc_nids;
4547         spec->mux_nids = stac925x_mux_nids;
4548         spec->num_muxes = 1;
4549         spec->num_adcs = 1;
4550         spec->num_pwrs = 0;
4551         switch (codec->vendor_id) {
4552         case 0x83847632: /* STAC9202  */
4553         case 0x83847633: /* STAC9202D */
4554         case 0x83847636: /* STAC9251  */
4555         case 0x83847637: /* STAC9251D */
4556                 spec->num_dmics = STAC925X_NUM_DMICS;
4557                 spec->dmic_nids = stac925x_dmic_nids;
4558                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4559                 spec->dmux_nids = stac925x_dmux_nids;
4560                 break;
4561         default:
4562                 spec->num_dmics = 0;
4563                 break;
4564         }
4565
4566         spec->init = stac925x_core_init;
4567         spec->mixer = stac925x_mixer;
4568
4569         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4570         if (!err) {
4571                 if (spec->board_config < 0) {
4572                         printk(KERN_WARNING "hda_codec: No auto-config is "
4573                                "available, default to model=ref\n");
4574                         spec->board_config = STAC_925x_REF;
4575                         goto again;
4576                 }
4577                 err = -EINVAL;
4578         }
4579         if (err < 0) {
4580                 stac92xx_free(codec);
4581                 return err;
4582         }
4583
4584         codec->patch_ops = stac92xx_patch_ops;
4585
4586         return 0;
4587 }
4588
4589 static struct hda_input_mux stac92hd73xx_dmux = {
4590         .num_items = 4,
4591         .items = {
4592                 { "Analog Inputs", 0x0b },
4593                 { "Digital Mic 1", 0x09 },
4594                 { "Digital Mic 2", 0x0a },
4595                 { "CD", 0x08 },
4596         }
4597 };
4598
4599 static int patch_stac92hd73xx(struct hda_codec *codec)
4600 {
4601         struct sigmatel_spec *spec;
4602         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4603         int err = 0;
4604         int num_dacs;
4605
4606         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4607         if (spec == NULL)
4608                 return -ENOMEM;
4609
4610         codec->spec = spec;
4611         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4612         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4613         spec->pin_nids = stac92hd73xx_pin_nids;
4614         spec->board_config = snd_hda_check_board_config(codec,
4615                                                         STAC_92HD73XX_MODELS,
4616                                                         stac92hd73xx_models,
4617                                                         stac92hd73xx_cfg_tbl);
4618 again:
4619         if (spec->board_config < 0) {
4620                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4621                         " STAC92HD73XX, using BIOS defaults\n");
4622                 err = stac92xx_save_bios_config_regs(codec);
4623         } else
4624                 err = stac_save_pin_cfgs(codec,
4625                                 stac92hd73xx_brd_tbl[spec->board_config]);
4626         if (err < 0) {
4627                 stac92xx_free(codec);
4628                 return err;
4629         }
4630
4631         num_dacs = snd_hda_get_connections(codec, 0x0a,
4632                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
4633
4634         if (num_dacs < 3 || num_dacs > 5) {
4635                 printk(KERN_WARNING "hda_codec: Could not determine "
4636                        "number of channels defaulting to DAC count\n");
4637                 num_dacs = STAC92HD73_DAC_COUNT;
4638         }
4639         switch (num_dacs) {
4640         case 0x3: /* 6 Channel */
4641                 spec->mixer = stac92hd73xx_6ch_mixer;
4642                 spec->init = stac92hd73xx_6ch_core_init;
4643                 break;
4644         case 0x4: /* 8 Channel */
4645                 spec->mixer = stac92hd73xx_8ch_mixer;
4646                 spec->init = stac92hd73xx_8ch_core_init;
4647                 break;
4648         case 0x5: /* 10 Channel */
4649                 spec->mixer = stac92hd73xx_10ch_mixer;
4650                 spec->init = stac92hd73xx_10ch_core_init;
4651         }
4652         spec->multiout.dac_nids = spec->dac_nids;
4653
4654         spec->aloopback_mask = 0x01;
4655         spec->aloopback_shift = 8;
4656
4657         spec->digbeep_nid = 0x1c;
4658         spec->mux_nids = stac92hd73xx_mux_nids;
4659         spec->adc_nids = stac92hd73xx_adc_nids;
4660         spec->dmic_nids = stac92hd73xx_dmic_nids;
4661         spec->dmux_nids = stac92hd73xx_dmux_nids;
4662         spec->smux_nids = stac92hd73xx_smux_nids;
4663         spec->amp_nids = stac92hd73xx_amp_nids;
4664         spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4665
4666         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4667         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4668         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4669         memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4670                         sizeof(stac92hd73xx_dmux));
4671
4672         switch (spec->board_config) {
4673         case STAC_DELL_EQ:
4674                 spec->init = dell_eq_core_init;
4675                 /* fallthru */
4676         case STAC_DELL_M6_AMIC:
4677         case STAC_DELL_M6_DMIC:
4678         case STAC_DELL_M6_BOTH:
4679                 spec->num_smuxes = 0;
4680                 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4681                 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4682                 spec->eapd_switch = 0;
4683                 spec->num_amps = 1;
4684
4685                 if (spec->board_config != STAC_DELL_EQ)
4686                         spec->init = dell_m6_core_init;
4687                 switch (spec->board_config) {
4688                 case STAC_DELL_M6_AMIC: /* Analog Mics */
4689                         stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4690                         spec->num_dmics = 0;
4691                         spec->private_dimux.num_items = 1;
4692                         break;
4693                 case STAC_DELL_M6_DMIC: /* Digital Mics */
4694                         stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4695                         spec->num_dmics = 1;
4696                         spec->private_dimux.num_items = 2;
4697                         break;
4698                 case STAC_DELL_M6_BOTH: /* Both */
4699                         stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4700                         stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4701                         spec->num_dmics = 1;
4702                         spec->private_dimux.num_items = 2;
4703                         break;
4704                 }
4705                 break;
4706         default:
4707                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4708                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4709                 spec->eapd_switch = 1;
4710         }
4711         if (spec->board_config > STAC_92HD73XX_REF) {
4712                 /* GPIO0 High = Enable EAPD */
4713                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4714                 spec->gpio_data = 0x01;
4715         }
4716         spec->dinput_mux = &spec->private_dimux;
4717
4718         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4719         spec->pwr_nids = stac92hd73xx_pwr_nids;
4720
4721         err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4722
4723         if (!err) {
4724                 if (spec->board_config < 0) {
4725                         printk(KERN_WARNING "hda_codec: No auto-config is "
4726                                "available, default to model=ref\n");
4727                         spec->board_config = STAC_92HD73XX_REF;
4728                         goto again;
4729                 }
4730                 err = -EINVAL;
4731         }
4732
4733         if (err < 0) {
4734                 stac92xx_free(codec);
4735                 return err;
4736         }
4737
4738         if (spec->board_config == STAC_92HD73XX_NO_JD)
4739                 spec->hp_detect = 0;
4740
4741         codec->patch_ops = stac92xx_patch_ops;
4742
4743         codec->proc_widget_hook = stac92hd7x_proc_hook;
4744
4745         return 0;
4746 }
4747
4748 static struct hda_input_mux stac92hd83xxx_dmux = {
4749         .num_items = 3,
4750         .items = {
4751                 { "Analog Inputs", 0x03 },
4752                 { "Digital Mic 1", 0x04 },
4753                 { "Digital Mic 2", 0x05 },
4754         }
4755 };
4756
4757 static int patch_stac92hd83xxx(struct hda_codec *codec)
4758 {
4759         struct sigmatel_spec *spec;
4760         hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4761         int err;
4762         int num_dacs;
4763
4764         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4765         if (spec == NULL)
4766                 return -ENOMEM;
4767
4768         codec->spec = spec;
4769         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4770         spec->mono_nid = 0x19;
4771         spec->digbeep_nid = 0x21;
4772         spec->dmic_nids = stac92hd83xxx_dmic_nids;
4773         spec->dmux_nids = stac92hd83xxx_dmux_nids;
4774         spec->adc_nids = stac92hd83xxx_adc_nids;
4775         spec->pwr_nids = stac92hd83xxx_pwr_nids;
4776         spec->amp_nids = stac92hd83xxx_amp_nids;
4777         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4778         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4779         spec->multiout.dac_nids = spec->dac_nids;
4780
4781
4782         /* set port 0xe to select the last DAC
4783          */
4784         num_dacs = snd_hda_get_connections(codec, 0x0e,
4785                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4786
4787         snd_hda_codec_write_cache(codec, 0xe, 0,
4788                 AC_VERB_SET_CONNECT_SEL, num_dacs);
4789
4790         spec->init = stac92hd83xxx_core_init;
4791         spec->mixer = stac92hd83xxx_mixer;
4792         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4793         spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4794         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4795         spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4796         spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4797         spec->dinput_mux = &stac92hd83xxx_dmux;
4798         spec->pin_nids = stac92hd83xxx_pin_nids;
4799         spec->board_config = snd_hda_check_board_config(codec,
4800                                                         STAC_92HD83XXX_MODELS,
4801                                                         stac92hd83xxx_models,
4802                                                         stac92hd83xxx_cfg_tbl);
4803 again:
4804         if (spec->board_config < 0) {
4805                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4806                         " STAC92HD83XXX, using BIOS defaults\n");
4807                 err = stac92xx_save_bios_config_regs(codec);
4808         } else
4809                 err = stac_save_pin_cfgs(codec,
4810                                 stac92hd83xxx_brd_tbl[spec->board_config]);
4811         if (err < 0) {
4812                 stac92xx_free(codec);
4813                 return err;
4814         }
4815
4816         switch (codec->vendor_id) {
4817         case 0x111d7604:
4818         case 0x111d7605:
4819                 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4820                         break;
4821                 spec->num_pwrs = 0;
4822                 break;
4823         }
4824
4825         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4826         if (!err) {
4827                 if (spec->board_config < 0) {
4828                         printk(KERN_WARNING "hda_codec: No auto-config is "
4829                                "available, default to model=ref\n");
4830                         spec->board_config = STAC_92HD83XXX_REF;
4831                         goto again;
4832                 }
4833                 err = -EINVAL;
4834         }
4835
4836         if (err < 0) {
4837                 stac92xx_free(codec);
4838                 return err;
4839         }
4840
4841         codec->patch_ops = stac92xx_patch_ops;
4842
4843         codec->proc_widget_hook = stac92hd_proc_hook;
4844
4845         return 0;
4846 }
4847
4848 static struct hda_input_mux stac92hd71bxx_dmux = {
4849         .num_items = 4,
4850         .items = {
4851                 { "Analog Inputs", 0x00 },
4852                 { "Mixer", 0x01 },
4853                 { "Digital Mic 1", 0x02 },
4854                 { "Digital Mic 2", 0x03 },
4855         }
4856 };
4857
4858 static int patch_stac92hd71bxx(struct hda_codec *codec)
4859 {
4860         struct sigmatel_spec *spec;
4861         int err = 0;
4862
4863         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4864         if (spec == NULL)
4865                 return -ENOMEM;
4866
4867         codec->spec = spec;
4868         codec->patch_ops = stac92xx_patch_ops;
4869         spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4870         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4871         spec->pin_nids = stac92hd71bxx_pin_nids;
4872         memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4873                         sizeof(stac92hd71bxx_dmux));
4874         spec->board_config = snd_hda_check_board_config(codec,
4875                                                         STAC_92HD71BXX_MODELS,
4876                                                         stac92hd71bxx_models,
4877                                                         stac92hd71bxx_cfg_tbl);
4878 again:
4879         if (spec->board_config < 0) {
4880                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4881                         " STAC92HD71BXX, using BIOS defaults\n");
4882                 err = stac92xx_save_bios_config_regs(codec);
4883         } else
4884                 err = stac_save_pin_cfgs(codec,
4885                                 stac92hd71bxx_brd_tbl[spec->board_config]);
4886         if (err < 0) {
4887                 stac92xx_free(codec);
4888                 return err;
4889         }
4890
4891         if (spec->board_config > STAC_92HD71BXX_REF) {
4892                 /* GPIO0 = EAPD */
4893                 spec->gpio_mask = 0x01;
4894                 spec->gpio_dir = 0x01;
4895                 spec->gpio_data = 0x01;
4896         }
4897
4898         switch (codec->vendor_id) {
4899         case 0x111d76b6: /* 4 Port without Analog Mixer */
4900         case 0x111d76b7:
4901         case 0x111d76b4: /* 6 Port without Analog Mixer */
4902         case 0x111d76b5:
4903                 spec->mixer = stac92hd71bxx_mixer;
4904                 spec->init = stac92hd71bxx_core_init;
4905                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4906                 break;
4907         case 0x111d7608: /* 5 Port with Analog Mixer */
4908                 switch (spec->board_config) {
4909                 case STAC_HP_M4:
4910                         /* Enable VREF power saving on GPIO1 detect */
4911                         err = stac_add_event(spec, codec->afg,
4912                                              STAC_VREF_EVENT, 0x02);
4913                         if (err < 0)
4914                                 return err;
4915                         snd_hda_codec_write_cache(codec, codec->afg, 0,
4916                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4917                         snd_hda_codec_write_cache(codec, codec->afg, 0,
4918                                 AC_VERB_SET_UNSOLICITED_ENABLE,
4919                                 AC_USRSP_EN | err);
4920                         spec->gpio_mask |= 0x02;
4921                         break;
4922                 }
4923                 if ((codec->revision_id & 0xf) == 0 ||
4924                     (codec->revision_id & 0xf) == 1)
4925                         spec->stream_delay = 40; /* 40 milliseconds */
4926
4927                 /* no output amps */
4928                 spec->num_pwrs = 0;
4929                 spec->mixer = stac92hd71bxx_analog_mixer;
4930                 spec->dinput_mux = &spec->private_dimux;
4931
4932                 /* disable VSW */
4933                 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4934                 stac_change_pin_config(codec, 0xf, 0x40f000f0);
4935                 break;
4936         case 0x111d7603: /* 6 Port with Analog Mixer */
4937                 if ((codec->revision_id & 0xf) == 1)
4938                         spec->stream_delay = 40; /* 40 milliseconds */
4939
4940                 /* no output amps */
4941                 spec->num_pwrs = 0;
4942                 /* fallthru */
4943         default:
4944                 spec->dinput_mux = &spec->private_dimux;
4945                 spec->mixer = stac92hd71bxx_analog_mixer;
4946                 spec->init = stac92hd71bxx_analog_core_init;
4947                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4948         }
4949
4950         spec->aloopback_mask = 0x50;
4951         spec->aloopback_shift = 0;
4952
4953         spec->powerdown_adcs = 1;
4954         spec->digbeep_nid = 0x26;
4955         spec->mux_nids = stac92hd71bxx_mux_nids;
4956         spec->adc_nids = stac92hd71bxx_adc_nids;
4957         spec->dmic_nids = stac92hd71bxx_dmic_nids;
4958         spec->dmux_nids = stac92hd71bxx_dmux_nids;
4959         spec->smux_nids = stac92hd71bxx_smux_nids;
4960         spec->pwr_nids = stac92hd71bxx_pwr_nids;
4961
4962         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4963         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4964
4965         switch (spec->board_config) {
4966         case STAC_HP_M4:
4967                 /* enable internal microphone */
4968                 stac_change_pin_config(codec, 0x0e, 0x01813040);
4969                 stac92xx_auto_set_pinctl(codec, 0x0e,
4970                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4971                 /* fallthru */
4972         case STAC_DELL_M4_2:
4973                 spec->num_dmics = 0;
4974                 spec->num_smuxes = 0;
4975                 spec->num_dmuxes = 0;
4976                 break;
4977         case STAC_DELL_M4_1:
4978         case STAC_DELL_M4_3:
4979                 spec->num_dmics = 1;
4980                 spec->num_smuxes = 0;
4981                 spec->num_dmuxes = 0;
4982                 break;
4983         default:
4984                 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4985                 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4986                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4987         };
4988
4989         spec->multiout.dac_nids = spec->dac_nids;
4990         if (spec->dinput_mux)
4991                 spec->private_dimux.num_items +=
4992                         spec->num_dmics -
4993                                 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4994
4995         err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4996         if (!err) {
4997                 if (spec->board_config < 0) {
4998                         printk(KERN_WARNING "hda_codec: No auto-config is "
4999                                "available, default to model=ref\n");
5000                         spec->board_config = STAC_92HD71BXX_REF;
5001                         goto again;
5002                 }
5003                 err = -EINVAL;
5004         }
5005
5006         if (err < 0) {
5007                 stac92xx_free(codec);
5008                 return err;
5009         }
5010
5011         codec->proc_widget_hook = stac92hd7x_proc_hook;
5012
5013         return 0;
5014 };
5015
5016 static int patch_stac922x(struct hda_codec *codec)
5017 {
5018         struct sigmatel_spec *spec;
5019         int err;
5020
5021         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5022         if (spec == NULL)
5023                 return -ENOMEM;
5024
5025         codec->spec = spec;
5026         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5027         spec->pin_nids = stac922x_pin_nids;
5028         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5029                                                         stac922x_models,
5030                                                         stac922x_cfg_tbl);
5031         if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5032                 spec->gpio_mask = spec->gpio_dir = 0x03;
5033                 spec->gpio_data = 0x03;
5034                 /* Intel Macs have all same PCI SSID, so we need to check
5035                  * codec SSID to distinguish the exact models
5036                  */
5037                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5038                 switch (codec->subsystem_id) {
5039
5040                 case 0x106b0800:
5041                         spec->board_config = STAC_INTEL_MAC_V1;
5042                         break;
5043                 case 0x106b0600:
5044                 case 0x106b0700:
5045                         spec->board_config = STAC_INTEL_MAC_V2;
5046                         break;
5047                 case 0x106b0e00:
5048                 case 0x106b0f00:
5049                 case 0x106b1600:
5050                 case 0x106b1700:
5051                 case 0x106b0200:
5052                 case 0x106b1e00:
5053                         spec->board_config = STAC_INTEL_MAC_V3;
5054                         break;
5055                 case 0x106b1a00:
5056                 case 0x00000100:
5057                         spec->board_config = STAC_INTEL_MAC_V4;
5058                         break;
5059                 case 0x106b0a00:
5060                 case 0x106b2200:
5061                         spec->board_config = STAC_INTEL_MAC_V5;
5062                         break;
5063                 default:
5064                         spec->board_config = STAC_INTEL_MAC_V3;
5065                         break;
5066                 }
5067         }
5068
5069  again:
5070         if (spec->board_config < 0) {
5071                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5072                         "using BIOS defaults\n");
5073                 err = stac92xx_save_bios_config_regs(codec);
5074         } else
5075                 err = stac_save_pin_cfgs(codec,
5076                                 stac922x_brd_tbl[spec->board_config]);
5077         if (err < 0) {
5078                 stac92xx_free(codec);
5079                 return err;
5080         }
5081
5082         spec->adc_nids = stac922x_adc_nids;
5083         spec->mux_nids = stac922x_mux_nids;
5084         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5085         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5086         spec->num_dmics = 0;
5087         spec->num_pwrs = 0;
5088
5089         spec->init = stac922x_core_init;
5090         spec->mixer = stac922x_mixer;
5091
5092         spec->multiout.dac_nids = spec->dac_nids;
5093
5094         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5095         if (!err) {
5096                 if (spec->board_config < 0) {
5097                         printk(KERN_WARNING "hda_codec: No auto-config is "
5098                                "available, default to model=ref\n");
5099                         spec->board_config = STAC_D945_REF;
5100                         goto again;
5101                 }
5102                 err = -EINVAL;
5103         }
5104         if (err < 0) {
5105                 stac92xx_free(codec);
5106                 return err;
5107         }
5108
5109         codec->patch_ops = stac92xx_patch_ops;
5110
5111         /* Fix Mux capture level; max to 2 */
5112         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5113                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
5114                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5115                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5116                                   (0 << AC_AMPCAP_MUTE_SHIFT));
5117
5118         return 0;
5119 }
5120
5121 static int patch_stac927x(struct hda_codec *codec)
5122 {
5123         struct sigmatel_spec *spec;
5124         int err;
5125
5126         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5127         if (spec == NULL)
5128                 return -ENOMEM;
5129
5130         codec->spec = spec;
5131         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5132         spec->pin_nids = stac927x_pin_nids;
5133         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5134                                                         stac927x_models,
5135                                                         stac927x_cfg_tbl);
5136  again:
5137         if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
5138                 if (spec->board_config < 0)
5139                         snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5140                                     "STAC927x, using BIOS defaults\n");
5141                 err = stac92xx_save_bios_config_regs(codec);
5142         } else
5143                 err = stac_save_pin_cfgs(codec,
5144                                 stac927x_brd_tbl[spec->board_config]);
5145         if (err < 0) {
5146                 stac92xx_free(codec);
5147                 return err;
5148         }
5149
5150         spec->digbeep_nid = 0x23;
5151         spec->adc_nids = stac927x_adc_nids;
5152         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5153         spec->mux_nids = stac927x_mux_nids;
5154         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5155         spec->smux_nids = stac927x_smux_nids;
5156         spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5157         spec->spdif_labels = stac927x_spdif_labels;
5158         spec->dac_list = stac927x_dac_nids;
5159         spec->multiout.dac_nids = spec->dac_nids;
5160
5161         switch (spec->board_config) {
5162         case STAC_D965_3ST:
5163         case STAC_D965_5ST:
5164                 /* GPIO0 High = Enable EAPD */
5165                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5166                 spec->gpio_data = 0x01;
5167                 spec->num_dmics = 0;
5168
5169                 spec->init = d965_core_init;
5170                 spec->mixer = stac927x_mixer;
5171                 break;
5172         case STAC_DELL_BIOS:
5173                 switch (codec->subsystem_id) {
5174                 case 0x10280209:
5175                 case 0x1028022e:
5176                         /* correct the device field to SPDIF out */
5177                         stac_change_pin_config(codec, 0x21, 0x01442070);
5178                         break;
5179                 };
5180                 /* configure the analog microphone on some laptops */
5181                 stac_change_pin_config(codec, 0x0c, 0x90a79130);
5182                 /* correct the front output jack as a hp out */
5183                 stac_change_pin_config(codec, 0x0f, 0x0227011f);
5184                 /* correct the front input jack as a mic */
5185                 stac_change_pin_config(codec, 0x0e, 0x02a79130);
5186                 /* fallthru */
5187         case STAC_DELL_3ST:
5188                 /* GPIO2 High = Enable EAPD */
5189                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5190                 spec->gpio_data = 0x04;
5191                 spec->dmic_nids = stac927x_dmic_nids;
5192                 spec->num_dmics = STAC927X_NUM_DMICS;
5193
5194                 spec->init = d965_core_init;
5195                 spec->mixer = stac927x_mixer;
5196                 spec->dmux_nids = stac927x_dmux_nids;
5197                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5198                 break;
5199         default:
5200                 if (spec->board_config > STAC_D965_REF) {
5201                         /* GPIO0 High = Enable EAPD */
5202                         spec->eapd_mask = spec->gpio_mask = 0x01;
5203                         spec->gpio_dir = spec->gpio_data = 0x01;
5204                 }
5205                 spec->num_dmics = 0;
5206
5207                 spec->init = stac927x_core_init;
5208                 spec->mixer = stac927x_mixer;
5209         }
5210
5211         spec->num_pwrs = 0;
5212         spec->aloopback_mask = 0x40;
5213         spec->aloopback_shift = 0;
5214         spec->eapd_switch = 1;
5215
5216         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5217         if (!err) {
5218                 if (spec->board_config < 0) {
5219                         printk(KERN_WARNING "hda_codec: No auto-config is "
5220                                "available, default to model=ref\n");
5221                         spec->board_config = STAC_D965_REF;
5222                         goto again;
5223                 }
5224                 err = -EINVAL;
5225         }
5226         if (err < 0) {
5227                 stac92xx_free(codec);
5228                 return err;
5229         }
5230
5231         codec->patch_ops = stac92xx_patch_ops;
5232
5233         codec->proc_widget_hook = stac927x_proc_hook;
5234
5235         /*
5236          * !!FIXME!!
5237          * The STAC927x seem to require fairly long delays for certain
5238          * command sequences.  With too short delays (even if the answer
5239          * is set to RIRB properly), it results in the silence output
5240          * on some hardwares like Dell.
5241          *
5242          * The below flag enables the longer delay (see get_response
5243          * in hda_intel.c).
5244          */
5245         codec->bus->needs_damn_long_delay = 1;
5246
5247         /* no jack detecion for ref-no-jd model */
5248         if (spec->board_config == STAC_D965_REF_NO_JD)
5249                 spec->hp_detect = 0;
5250
5251         return 0;
5252 }
5253
5254 static int patch_stac9205(struct hda_codec *codec)
5255 {
5256         struct sigmatel_spec *spec;
5257         int err;
5258
5259         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5260         if (spec == NULL)
5261                 return -ENOMEM;
5262
5263         codec->spec = spec;
5264         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5265         spec->pin_nids = stac9205_pin_nids;
5266         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5267                                                         stac9205_models,
5268                                                         stac9205_cfg_tbl);
5269  again:
5270         if (spec->board_config < 0) {
5271                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5272                 err = stac92xx_save_bios_config_regs(codec);
5273         } else
5274                 err = stac_save_pin_cfgs(codec,
5275                                          stac9205_brd_tbl[spec->board_config]);
5276         if (err < 0) {
5277                 stac92xx_free(codec);
5278                 return err;
5279         }
5280
5281         spec->digbeep_nid = 0x23;
5282         spec->adc_nids = stac9205_adc_nids;
5283         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5284         spec->mux_nids = stac9205_mux_nids;
5285         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5286         spec->smux_nids = stac9205_smux_nids;
5287         spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5288         spec->dmic_nids = stac9205_dmic_nids;
5289         spec->num_dmics = STAC9205_NUM_DMICS;
5290         spec->dmux_nids = stac9205_dmux_nids;
5291         spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5292         spec->num_pwrs = 0;
5293
5294         spec->init = stac9205_core_init;
5295         spec->mixer = stac9205_mixer;
5296
5297         spec->aloopback_mask = 0x40;
5298         spec->aloopback_shift = 0;
5299         spec->eapd_switch = 1;
5300         spec->multiout.dac_nids = spec->dac_nids;
5301
5302         switch (spec->board_config){
5303         case STAC_9205_DELL_M43:
5304                 /* Enable SPDIF in/out */
5305                 stac_change_pin_config(codec, 0x1f, 0x01441030);
5306                 stac_change_pin_config(codec, 0x20, 0x1c410030);
5307
5308                 /* Enable unsol response for GPIO4/Dock HP connection */
5309                 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5310                 if (err < 0)
5311                         return err;
5312                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5313                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5314                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5315                                           AC_VERB_SET_UNSOLICITED_ENABLE,
5316                                           AC_USRSP_EN | err);
5317
5318                 spec->gpio_dir = 0x0b;
5319                 spec->eapd_mask = 0x01;
5320                 spec->gpio_mask = 0x1b;
5321                 spec->gpio_mute = 0x10;
5322                 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5323                  * GPIO3 Low = DRM
5324                  */
5325                 spec->gpio_data = 0x01;
5326                 break;
5327         case STAC_9205_REF:
5328                 /* SPDIF-In enabled */
5329                 break;
5330         default:
5331                 /* GPIO0 High = EAPD */
5332                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5333                 spec->gpio_data = 0x01;
5334                 break;
5335         }
5336
5337         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5338         if (!err) {
5339                 if (spec->board_config < 0) {
5340                         printk(KERN_WARNING "hda_codec: No auto-config is "
5341                                "available, default to model=ref\n");
5342                         spec->board_config = STAC_9205_REF;
5343                         goto again;
5344                 }
5345                 err = -EINVAL;
5346         }
5347         if (err < 0) {
5348                 stac92xx_free(codec);
5349                 return err;
5350         }
5351
5352         codec->patch_ops = stac92xx_patch_ops;
5353
5354         codec->proc_widget_hook = stac9205_proc_hook;
5355
5356         return 0;
5357 }
5358
5359 /*
5360  * STAC9872 hack
5361  */
5362
5363 /* static config for Sony VAIO FE550G and Sony VAIO AR */
5364 static hda_nid_t vaio_dacs[] = { 0x2 };
5365 #define VAIO_HP_DAC     0x5
5366 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
5367 static hda_nid_t vaio_mux_nids[] = { 0x15 };
5368
5369 static struct hda_input_mux vaio_mux = {
5370         .num_items = 3,
5371         .items = {
5372                 /* { "HP", 0x0 }, */
5373                 { "Mic Jack", 0x1 },
5374                 { "Internal Mic", 0x2 },
5375                 { "PCM", 0x3 },
5376         }
5377 };
5378
5379 static struct hda_verb vaio_init[] = {
5380         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5381         {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
5382         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5383         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5384         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5385         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5386         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5387         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5388         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5389         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5390         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5391         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5392         {}
5393 };
5394
5395 static struct hda_verb vaio_ar_init[] = {
5396         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5397         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5398         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5399         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5400 /*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
5401         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5402         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5403         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5404         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5405 /*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
5406         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5407         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5408         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5409         {}
5410 };
5411
5412 static struct snd_kcontrol_new vaio_mixer[] = {
5413         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5414         HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5415         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5416         HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5417         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5418         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5419         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5420         {
5421                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5422                 .name = "Capture Source",
5423                 .count = 1,
5424                 .info = stac92xx_mux_enum_info,
5425                 .get = stac92xx_mux_enum_get,
5426                 .put = stac92xx_mux_enum_put,
5427         },
5428         {}
5429 };
5430
5431 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5432         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5433         HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5434         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5435         HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5436         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5437         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5438         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5439         /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5440         HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5441         {
5442                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5443                 .name = "Capture Source",
5444                 .count = 1,
5445                 .info = stac92xx_mux_enum_info,
5446                 .get = stac92xx_mux_enum_get,
5447                 .put = stac92xx_mux_enum_put,
5448         },
5449         {}
5450 };
5451
5452 static struct hda_codec_ops stac9872_patch_ops = {
5453         .build_controls = stac92xx_build_controls,
5454         .build_pcms = stac92xx_build_pcms,
5455         .init = stac92xx_init,
5456         .free = stac92xx_free,
5457 #ifdef SND_HDA_NEEDS_RESUME
5458         .resume = stac92xx_resume,
5459 #endif
5460 };
5461
5462 static int stac9872_vaio_init(struct hda_codec *codec)
5463 {
5464         int err;
5465
5466         err = stac92xx_init(codec);
5467         if (err < 0)
5468                 return err;
5469         if (codec->patch_ops.unsol_event)
5470                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5471         return 0;
5472 }
5473
5474 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5475 {
5476         if (get_pin_presence(codec, 0x0a)) {
5477                 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5478                 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5479         } else {
5480                 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5481                 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5482         }
5483 }
5484
5485 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5486 {
5487         switch (res >> 26) {
5488         case STAC_HP_EVENT:
5489                 stac9872_vaio_hp_detect(codec, res);
5490                 break;
5491         }
5492 }
5493
5494 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5495         .build_controls = stac92xx_build_controls,
5496         .build_pcms = stac92xx_build_pcms,
5497         .init = stac9872_vaio_init,
5498         .free = stac92xx_free,
5499         .unsol_event = stac9872_vaio_unsol_event,
5500 #ifdef CONFIG_PM
5501         .resume = stac92xx_resume,
5502 #endif
5503 };
5504
5505 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5506        CXD9872RD_VAIO,
5507        /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5508        STAC9872AK_VAIO,
5509        /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5510        STAC9872K_VAIO,
5511        /* AR Series. id=0x83847664 and subsys=104D1300 */
5512        CXD9872AKD_VAIO,
5513        STAC_9872_MODELS,
5514 };
5515
5516 static const char *stac9872_models[STAC_9872_MODELS] = {
5517         [CXD9872RD_VAIO]        = "vaio",
5518         [CXD9872AKD_VAIO]       = "vaio-ar",
5519 };
5520
5521 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5522         SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5523         SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5524         SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5525         SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5526         {}
5527 };
5528
5529 static int patch_stac9872(struct hda_codec *codec)
5530 {
5531         struct sigmatel_spec *spec;
5532         int board_config;
5533
5534         board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5535                                                   stac9872_models,
5536                                                   stac9872_cfg_tbl);
5537         if (board_config < 0)
5538                 /* unknown config, let generic-parser do its job... */
5539                 return snd_hda_parse_generic_codec(codec);
5540
5541         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5542         if (spec == NULL)
5543                 return -ENOMEM;
5544
5545         codec->spec = spec;
5546         switch (board_config) {
5547         case CXD9872RD_VAIO:
5548         case STAC9872AK_VAIO:
5549         case STAC9872K_VAIO:
5550                 spec->mixer = vaio_mixer;
5551                 spec->init = vaio_init;
5552                 spec->multiout.max_channels = 2;
5553                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5554                 spec->multiout.dac_nids = vaio_dacs;
5555                 spec->multiout.hp_nid = VAIO_HP_DAC;
5556                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5557                 spec->adc_nids = vaio_adcs;
5558                 spec->num_pwrs = 0;
5559                 spec->input_mux = &vaio_mux;
5560                 spec->mux_nids = vaio_mux_nids;
5561                 codec->patch_ops = stac9872_vaio_patch_ops;
5562                 break;
5563
5564         case CXD9872AKD_VAIO:
5565                 spec->mixer = vaio_ar_mixer;
5566                 spec->init = vaio_ar_init;
5567                 spec->multiout.max_channels = 2;
5568                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5569                 spec->multiout.dac_nids = vaio_dacs;
5570                 spec->multiout.hp_nid = VAIO_HP_DAC;
5571                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5572                 spec->num_pwrs = 0;
5573                 spec->adc_nids = vaio_adcs;
5574                 spec->input_mux = &vaio_mux;
5575                 spec->mux_nids = vaio_mux_nids;
5576                 codec->patch_ops = stac9872_patch_ops;
5577                 break;
5578         }
5579
5580         return 0;
5581 }
5582
5583
5584 /*
5585  * patch entries
5586  */
5587 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5588         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5589         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5590         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5591         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5592         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5593         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5594         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5595         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5596         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5597         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5598         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5599         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5600         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5601         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5602         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5603         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5604         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5605         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5606         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5607         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5608         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5609         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5610         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5611         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
5612         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5613         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5614         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5615         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5616         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5617         { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5618         { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5619         /* The following does not take into account .id=0x83847661 when subsys =
5620          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5621          * currently not fully supported.
5622          */
5623         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5624         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5625         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5626         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5627         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5628         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5629         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5630         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5631         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5632         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5633         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5634         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5635         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5636         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5637         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5638         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5639         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5640         { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5641         { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5642         { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5643         { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5644         { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5645         { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5646         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5647         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5648         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5649         {} /* terminator */
5650 };
5651
5652 MODULE_ALIAS("snd-hda-codec-id:8384*");
5653 MODULE_ALIAS("snd-hda-codec-id:111d*");
5654
5655 MODULE_LICENSE("GPL");
5656 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5657
5658 static struct hda_codec_preset_list sigmatel_list = {
5659         .preset = snd_hda_preset_sigmatel,
5660         .owner = THIS_MODULE,
5661 };
5662
5663 static int __init patch_sigmatel_init(void)
5664 {
5665         return snd_hda_add_codec_preset(&sigmatel_list);
5666 }
5667
5668 static void __exit patch_sigmatel_exit(void)
5669 {
5670         snd_hda_delete_codec_preset(&sigmatel_list);
5671 }
5672
5673 module_init(patch_sigmatel_init)
5674 module_exit(patch_sigmatel_exit)