SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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