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, 0x361a,
1735                                 "unknown HP", STAC_HP_M4),
1736         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1737                                 "unknown Dell", STAC_DELL_M4_1),
1738         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1739                                 "unknown Dell", STAC_DELL_M4_1),
1740         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1741                                 "unknown Dell", STAC_DELL_M4_1),
1742         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1743                                 "unknown Dell", STAC_DELL_M4_1),
1744         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1745                                 "unknown Dell", STAC_DELL_M4_1),
1746         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1747                                 "unknown Dell", STAC_DELL_M4_1),
1748         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1749                                 "unknown Dell", STAC_DELL_M4_1),
1750         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1751                                 "unknown Dell", STAC_DELL_M4_2),
1752         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1753                                 "unknown Dell", STAC_DELL_M4_2),
1754         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1755                                 "unknown Dell", STAC_DELL_M4_2),
1756         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1757                                 "unknown Dell", STAC_DELL_M4_2),
1758         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1759                                 "unknown Dell", STAC_DELL_M4_3),
1760         {} /* terminator */
1761 };
1762
1763 static unsigned int ref922x_pin_configs[10] = {
1764         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1765         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1766         0x40000100, 0x40000100,
1767 };
1768
1769 /*
1770     STAC 922X pin configs for
1771     102801A7
1772     102801AB
1773     102801A9
1774     102801D1
1775     102801D2
1776 */
1777 static unsigned int dell_922x_d81_pin_configs[10] = {
1778         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1779         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1780         0x01813122, 0x400001f2,
1781 };
1782
1783 /*
1784     STAC 922X pin configs for
1785     102801AC
1786     102801D0
1787 */
1788 static unsigned int dell_922x_d82_pin_configs[10] = {
1789         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1790         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1791         0x01813122, 0x400001f1,
1792 };
1793
1794 /*
1795     STAC 922X pin configs for
1796     102801BF
1797 */
1798 static unsigned int dell_922x_m81_pin_configs[10] = {
1799         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1800         0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1801         0x40C003f1, 0x405003f0,
1802 };
1803
1804 /*
1805     STAC 9221 A1 pin configs for
1806     102801D7 (Dell XPS M1210)
1807 */
1808 static unsigned int dell_922x_m82_pin_configs[10] = {
1809         0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1810         0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1811         0x508003f3, 0x405003f4,
1812 };
1813
1814 static unsigned int d945gtp3_pin_configs[10] = {
1815         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1816         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1817         0x02a19120, 0x40000100,
1818 };
1819
1820 static unsigned int d945gtp5_pin_configs[10] = {
1821         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1822         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1823         0x02a19320, 0x40000100,
1824 };
1825
1826 static unsigned int intel_mac_v1_pin_configs[10] = {
1827         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1828         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1829         0x400000fc, 0x400000fb,
1830 };
1831
1832 static unsigned int intel_mac_v2_pin_configs[10] = {
1833         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1834         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1835         0x400000fc, 0x400000fb,
1836 };
1837
1838 static unsigned int intel_mac_v3_pin_configs[10] = {
1839         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1840         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1841         0x400000fc, 0x400000fb,
1842 };
1843
1844 static unsigned int intel_mac_v4_pin_configs[10] = {
1845         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1846         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1847         0x400000fc, 0x400000fb,
1848 };
1849
1850 static unsigned int intel_mac_v5_pin_configs[10] = {
1851         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1852         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1853         0x400000fc, 0x400000fb,
1854 };
1855
1856 static unsigned int ecs202_pin_configs[10] = {
1857         0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1858         0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1859         0x9037012e, 0x40e000f2,
1860 };
1861
1862 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1863         [STAC_D945_REF] = ref922x_pin_configs,
1864         [STAC_D945GTP3] = d945gtp3_pin_configs,
1865         [STAC_D945GTP5] = d945gtp5_pin_configs,
1866         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1867         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1868         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1869         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1870         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1871         [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1872         /* for backward compatibility */
1873         [STAC_MACMINI] = intel_mac_v3_pin_configs,
1874         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1875         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1876         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1877         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1878         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1879         [STAC_ECS_202] = ecs202_pin_configs,
1880         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1881         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1882         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1883         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1884 };
1885
1886 static const char *stac922x_models[STAC_922X_MODELS] = {
1887         [STAC_D945_REF] = "ref",
1888         [STAC_D945GTP5] = "5stack",
1889         [STAC_D945GTP3] = "3stack",
1890         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1891         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1892         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1893         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1894         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1895         [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1896         /* for backward compatibility */
1897         [STAC_MACMINI]  = "macmini",
1898         [STAC_MACBOOK]  = "macbook",
1899         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1900         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1901         [STAC_IMAC_INTEL] = "imac-intel",
1902         [STAC_IMAC_INTEL_20] = "imac-intel-20",
1903         [STAC_ECS_202] = "ecs202",
1904         [STAC_922X_DELL_D81] = "dell-d81",
1905         [STAC_922X_DELL_D82] = "dell-d82",
1906         [STAC_922X_DELL_M81] = "dell-m81",
1907         [STAC_922X_DELL_M82] = "dell-m82",
1908 };
1909
1910 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1911         /* SigmaTel reference board */
1912         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1913                       "DFI LanParty", STAC_D945_REF),
1914         /* Intel 945G based systems */
1915         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1916                       "Intel D945G", STAC_D945GTP3),
1917         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1918                       "Intel D945G", STAC_D945GTP3),
1919         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1920                       "Intel D945G", STAC_D945GTP3),
1921         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1922                       "Intel D945G", STAC_D945GTP3),
1923         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1924                       "Intel D945G", STAC_D945GTP3),
1925         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1926                       "Intel D945G", STAC_D945GTP3),
1927         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1928                       "Intel D945G", STAC_D945GTP3),
1929         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1930                       "Intel D945G", STAC_D945GTP3),
1931         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1932                       "Intel D945G", STAC_D945GTP3),
1933         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1934                       "Intel D945G", STAC_D945GTP3),
1935         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1936                       "Intel D945G", STAC_D945GTP3),
1937         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1938                       "Intel D945G", STAC_D945GTP3),
1939         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1940                       "Intel D945G", STAC_D945GTP3),
1941         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1942                       "Intel D945G", STAC_D945GTP3),
1943         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1944                       "Intel D945G", STAC_D945GTP3),
1945         /* Intel D945G 5-stack systems */
1946         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1947                       "Intel D945G", STAC_D945GTP5),
1948         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1949                       "Intel D945G", STAC_D945GTP5),
1950         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1951                       "Intel D945G", STAC_D945GTP5),
1952         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1953                       "Intel D945G", STAC_D945GTP5),
1954         /* Intel 945P based systems */
1955         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1956                       "Intel D945P", STAC_D945GTP3),
1957         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1958                       "Intel D945P", STAC_D945GTP3),
1959         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1960                       "Intel D945P", STAC_D945GTP3),
1961         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1962                       "Intel D945P", STAC_D945GTP3),
1963         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1964                       "Intel D945P", STAC_D945GTP3),
1965         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1966                       "Intel D945P", STAC_D945GTP5),
1967         /* other systems  */
1968         /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1969         SND_PCI_QUIRK(0x8384, 0x7680,
1970                       "Mac", STAC_INTEL_MAC_AUTO),
1971         /* Dell systems  */
1972         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1973                       "unknown Dell", STAC_922X_DELL_D81),
1974         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1975                       "unknown Dell", STAC_922X_DELL_D81),
1976         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1977                       "unknown Dell", STAC_922X_DELL_D81),
1978         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1979                       "unknown Dell", STAC_922X_DELL_D82),
1980         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1981                       "unknown Dell", STAC_922X_DELL_M81),
1982         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1983                       "unknown Dell", STAC_922X_DELL_D82),
1984         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1985                       "unknown Dell", STAC_922X_DELL_D81),
1986         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1987                       "unknown Dell", STAC_922X_DELL_D81),
1988         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1989                       "Dell XPS M1210", STAC_922X_DELL_M82),
1990         /* ECS/PC Chips boards */
1991         SND_PCI_QUIRK(0x1019, 0x2144,
1992                       "ECS/PC chips", STAC_ECS_202),
1993         SND_PCI_QUIRK(0x1019, 0x2608,
1994                       "ECS/PC chips", STAC_ECS_202),
1995         SND_PCI_QUIRK(0x1019, 0x2633,
1996                       "ECS/PC chips P17G/1333", STAC_ECS_202),
1997         SND_PCI_QUIRK(0x1019, 0x2811,
1998                       "ECS/PC chips", STAC_ECS_202),
1999         SND_PCI_QUIRK(0x1019, 0x2812,
2000                       "ECS/PC chips", STAC_ECS_202),
2001         SND_PCI_QUIRK(0x1019, 0x2813,
2002                       "ECS/PC chips", STAC_ECS_202),
2003         SND_PCI_QUIRK(0x1019, 0x2814,
2004                       "ECS/PC chips", STAC_ECS_202),
2005         SND_PCI_QUIRK(0x1019, 0x2815,
2006                       "ECS/PC chips", STAC_ECS_202),
2007         SND_PCI_QUIRK(0x1019, 0x2816,
2008                       "ECS/PC chips", STAC_ECS_202),
2009         SND_PCI_QUIRK(0x1019, 0x2817,
2010                       "ECS/PC chips", STAC_ECS_202),
2011         SND_PCI_QUIRK(0x1019, 0x2818,
2012                       "ECS/PC chips", STAC_ECS_202),
2013         SND_PCI_QUIRK(0x1019, 0x2819,
2014                       "ECS/PC chips", STAC_ECS_202),
2015         SND_PCI_QUIRK(0x1019, 0x2820,
2016                       "ECS/PC chips", STAC_ECS_202),
2017         {} /* terminator */
2018 };
2019
2020 static unsigned int ref927x_pin_configs[14] = {
2021         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2022         0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2023         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2024         0x01c42190, 0x40000100,
2025 };
2026
2027 static unsigned int d965_3st_pin_configs[14] = {
2028         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2029         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2030         0x40000100, 0x40000100, 0x40000100, 0x40000100,
2031         0x40000100, 0x40000100
2032 };
2033
2034 static unsigned int d965_5st_pin_configs[14] = {
2035         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2036         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2037         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2038         0x40000100, 0x40000100
2039 };
2040
2041 static unsigned int dell_3st_pin_configs[14] = {
2042         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2043         0x01111212, 0x01116211, 0x01813050, 0x01112214,
2044         0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2045         0x40c003fc, 0x40000100
2046 };
2047
2048 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2049         [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2050         [STAC_D965_REF]  = ref927x_pin_configs,
2051         [STAC_D965_3ST]  = d965_3st_pin_configs,
2052         [STAC_D965_5ST]  = d965_5st_pin_configs,
2053         [STAC_DELL_3ST]  = dell_3st_pin_configs,
2054         [STAC_DELL_BIOS] = NULL,
2055 };
2056
2057 static const char *stac927x_models[STAC_927X_MODELS] = {
2058         [STAC_D965_REF_NO_JD]   = "ref-no-jd",
2059         [STAC_D965_REF]         = "ref",
2060         [STAC_D965_3ST]         = "3stack",
2061         [STAC_D965_5ST]         = "5stack",
2062         [STAC_DELL_3ST]         = "dell-3stack",
2063         [STAC_DELL_BIOS]        = "dell-bios",
2064 };
2065
2066 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2067         /* SigmaTel reference board */
2068         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2069                       "DFI LanParty", STAC_D965_REF),
2070          /* Intel 946 based systems */
2071         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2072         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2073         /* 965 based 3 stack systems */
2074         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2075         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2076         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2077         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2078         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2079         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2080         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2081         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2082         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2083         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2084         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2085         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2086         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2087         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2088         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2089         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2090         /* Dell 3 stack systems */
2091         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2092         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2093         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2094         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2095         /* Dell 3 stack systems with verb table in BIOS */
2096         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2097         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2098         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2099         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2100         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2101         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2102         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2103         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2104         /* 965 based 5 stack systems */
2105         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2106         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2107         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2108         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2109         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2110         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2111         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2112         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2113         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2114         {} /* terminator */
2115 };
2116
2117 static unsigned int ref9205_pin_configs[12] = {
2118         0x40000100, 0x40000100, 0x01016011, 0x01014010,
2119         0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2120         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2121 };
2122
2123 /*
2124     STAC 9205 pin configs for
2125     102801F1
2126     102801F2
2127     102801FC
2128     102801FD
2129     10280204
2130     1028021F
2131     10280228 (Dell Vostro 1500)
2132 */
2133 static unsigned int dell_9205_m42_pin_configs[12] = {
2134         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2135         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2136         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2137 };
2138
2139 /*
2140     STAC 9205 pin configs for
2141     102801F9
2142     102801FA
2143     102801FE
2144     102801FF (Dell Precision M4300)
2145     10280206
2146     10280200
2147     10280201
2148 */
2149 static unsigned int dell_9205_m43_pin_configs[12] = {
2150         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2151         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2152         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2153 };
2154
2155 static unsigned int dell_9205_m44_pin_configs[12] = {
2156         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2157         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2158         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2159 };
2160
2161 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2162         [STAC_9205_REF] = ref9205_pin_configs,
2163         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2164         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2165         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2166 };
2167
2168 static const char *stac9205_models[STAC_9205_MODELS] = {
2169         [STAC_9205_REF] = "ref",
2170         [STAC_9205_DELL_M42] = "dell-m42",
2171         [STAC_9205_DELL_M43] = "dell-m43",
2172         [STAC_9205_DELL_M44] = "dell-m44",
2173 };
2174
2175 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2176         /* SigmaTel reference board */
2177         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2178                       "DFI LanParty", STAC_9205_REF),
2179         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2180                       "unknown Dell", STAC_9205_DELL_M42),
2181         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2182                       "unknown Dell", STAC_9205_DELL_M42),
2183         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2184                       "Dell Precision", STAC_9205_DELL_M43),
2185         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2186                       "Dell Precision", STAC_9205_DELL_M43),
2187         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2188                       "Dell Precision", STAC_9205_DELL_M43),
2189         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2190                       "unknown Dell", STAC_9205_DELL_M42),
2191         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2192                       "unknown Dell", STAC_9205_DELL_M42),
2193         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2194                       "Dell Precision", STAC_9205_DELL_M43),
2195         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2196                       "Dell Precision M4300", STAC_9205_DELL_M43),
2197         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2198                       "unknown Dell", STAC_9205_DELL_M42),
2199         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2200                       "Dell Precision", STAC_9205_DELL_M43),
2201         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2202                       "Dell Precision", STAC_9205_DELL_M43),
2203         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2204                       "Dell Precision", STAC_9205_DELL_M43),
2205         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2206                       "Dell Inspiron", STAC_9205_DELL_M44),
2207         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2208                       "Dell Vostro 1500", STAC_9205_DELL_M42),
2209         {} /* terminator */
2210 };
2211
2212 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2213 {
2214         int i;
2215         struct sigmatel_spec *spec = codec->spec;
2216
2217         kfree(spec->pin_configs);
2218         spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
2219                                     GFP_KERNEL);
2220         if (!spec->pin_configs)
2221                 return -ENOMEM;
2222
2223         for (i = 0; i < spec->num_pins; i++) {
2224                 hda_nid_t nid = spec->pin_nids[i];
2225                 unsigned int pin_cfg;
2226
2227                 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2228                         AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2229                 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2230                                         nid, pin_cfg);
2231                 spec->pin_configs[i] = pin_cfg;
2232         }
2233
2234         return 0;
2235 }
2236
2237 static void stac92xx_set_config_reg(struct hda_codec *codec,
2238                                     hda_nid_t pin_nid, unsigned int pin_config)
2239 {
2240         int i;
2241         snd_hda_codec_write(codec, pin_nid, 0,
2242                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2243                             pin_config & 0x000000ff);
2244         snd_hda_codec_write(codec, pin_nid, 0,
2245                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2246                             (pin_config & 0x0000ff00) >> 8);
2247         snd_hda_codec_write(codec, pin_nid, 0,
2248                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2249                             (pin_config & 0x00ff0000) >> 16);
2250         snd_hda_codec_write(codec, pin_nid, 0,
2251                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2252                             pin_config >> 24);
2253         i = snd_hda_codec_read(codec, pin_nid, 0,
2254                                AC_VERB_GET_CONFIG_DEFAULT,
2255                                0x00);
2256         snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2257                     pin_nid, i);
2258 }
2259
2260 static void stac92xx_set_config_regs(struct hda_codec *codec)
2261 {
2262         int i;
2263         struct sigmatel_spec *spec = codec->spec;
2264
2265         if (!spec->pin_configs)
2266                 return;
2267
2268         for (i = 0; i < spec->num_pins; i++)
2269                 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2270                                         spec->pin_configs[i]);
2271 }
2272
2273 static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
2274 {
2275         struct sigmatel_spec *spec = codec->spec;
2276
2277         if (!pins)
2278                 return stac92xx_save_bios_config_regs(codec);
2279
2280         kfree(spec->pin_configs);
2281         spec->pin_configs = kmemdup(pins,
2282                                     spec->num_pins * sizeof(*pins),
2283                                     GFP_KERNEL);
2284         if (!spec->pin_configs)
2285                 return -ENOMEM;
2286
2287         stac92xx_set_config_regs(codec);
2288         return 0;
2289 }
2290
2291 static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
2292                                    unsigned int cfg)
2293 {
2294         struct sigmatel_spec *spec = codec->spec;
2295         int i;
2296
2297         for (i = 0; i < spec->num_pins; i++) {
2298                 if (spec->pin_nids[i] == nid) {
2299                         spec->pin_configs[i] = cfg;
2300                         stac92xx_set_config_reg(codec, nid, cfg);
2301                         break;
2302                 }
2303         }
2304 }
2305
2306 /*
2307  * Analog playback callbacks
2308  */
2309 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2310                                       struct hda_codec *codec,
2311                                       struct snd_pcm_substream *substream)
2312 {
2313         struct sigmatel_spec *spec = codec->spec;
2314         if (spec->stream_delay)
2315                 msleep(spec->stream_delay);
2316         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2317                                              hinfo);
2318 }
2319
2320 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2321                                          struct hda_codec *codec,
2322                                          unsigned int stream_tag,
2323                                          unsigned int format,
2324                                          struct snd_pcm_substream *substream)
2325 {
2326         struct sigmatel_spec *spec = codec->spec;
2327         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2328 }
2329
2330 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2331                                         struct hda_codec *codec,
2332                                         struct snd_pcm_substream *substream)
2333 {
2334         struct sigmatel_spec *spec = codec->spec;
2335         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2336 }
2337
2338 /*
2339  * Digital playback callbacks
2340  */
2341 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2342                                           struct hda_codec *codec,
2343                                           struct snd_pcm_substream *substream)
2344 {
2345         struct sigmatel_spec *spec = codec->spec;
2346         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2347 }
2348
2349 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2350                                            struct hda_codec *codec,
2351                                            struct snd_pcm_substream *substream)
2352 {
2353         struct sigmatel_spec *spec = codec->spec;
2354         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2355 }
2356
2357 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2358                                          struct hda_codec *codec,
2359                                          unsigned int stream_tag,
2360                                          unsigned int format,
2361                                          struct snd_pcm_substream *substream)
2362 {
2363         struct sigmatel_spec *spec = codec->spec;
2364         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2365                                              stream_tag, format, substream);
2366 }
2367
2368
2369 /*
2370  * Analog capture callbacks
2371  */
2372 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2373                                         struct hda_codec *codec,
2374                                         unsigned int stream_tag,
2375                                         unsigned int format,
2376                                         struct snd_pcm_substream *substream)
2377 {
2378         struct sigmatel_spec *spec = codec->spec;
2379         hda_nid_t nid = spec->adc_nids[substream->number];
2380
2381         if (spec->powerdown_adcs) {
2382                 msleep(40);
2383                 snd_hda_codec_write(codec, nid, 0,
2384                         AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2385         }
2386         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2387         return 0;
2388 }
2389
2390 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2391                                         struct hda_codec *codec,
2392                                         struct snd_pcm_substream *substream)
2393 {
2394         struct sigmatel_spec *spec = codec->spec;
2395         hda_nid_t nid = spec->adc_nids[substream->number];
2396
2397         snd_hda_codec_cleanup_stream(codec, nid);
2398         if (spec->powerdown_adcs)
2399                 snd_hda_codec_write(codec, nid, 0,
2400                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2401         return 0;
2402 }
2403
2404 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2405         .substreams = 1,
2406         .channels_min = 2,
2407         .channels_max = 2,
2408         /* NID is set in stac92xx_build_pcms */
2409         .ops = {
2410                 .open = stac92xx_dig_playback_pcm_open,
2411                 .close = stac92xx_dig_playback_pcm_close,
2412                 .prepare = stac92xx_dig_playback_pcm_prepare
2413         },
2414 };
2415
2416 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2417         .substreams = 1,
2418         .channels_min = 2,
2419         .channels_max = 2,
2420         /* NID is set in stac92xx_build_pcms */
2421 };
2422
2423 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2424         .substreams = 1,
2425         .channels_min = 2,
2426         .channels_max = 8,
2427         .nid = 0x02, /* NID to query formats and rates */
2428         .ops = {
2429                 .open = stac92xx_playback_pcm_open,
2430                 .prepare = stac92xx_playback_pcm_prepare,
2431                 .cleanup = stac92xx_playback_pcm_cleanup
2432         },
2433 };
2434
2435 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2436         .substreams = 1,
2437         .channels_min = 2,
2438         .channels_max = 2,
2439         .nid = 0x06, /* NID to query formats and rates */
2440         .ops = {
2441                 .open = stac92xx_playback_pcm_open,
2442                 .prepare = stac92xx_playback_pcm_prepare,
2443                 .cleanup = stac92xx_playback_pcm_cleanup
2444         },
2445 };
2446
2447 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2448         .channels_min = 2,
2449         .channels_max = 2,
2450         /* NID + .substreams is set in stac92xx_build_pcms */
2451         .ops = {
2452                 .prepare = stac92xx_capture_pcm_prepare,
2453                 .cleanup = stac92xx_capture_pcm_cleanup
2454         },
2455 };
2456
2457 static int stac92xx_build_pcms(struct hda_codec *codec)
2458 {
2459         struct sigmatel_spec *spec = codec->spec;
2460         struct hda_pcm *info = spec->pcm_rec;
2461
2462         codec->num_pcms = 1;
2463         codec->pcm_info = info;
2464
2465         info->name = "STAC92xx Analog";
2466         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2467         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2468         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2469         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2470
2471         if (spec->alt_switch) {
2472                 codec->num_pcms++;
2473                 info++;
2474                 info->name = "STAC92xx Analog Alt";
2475                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2476         }
2477
2478         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2479                 codec->num_pcms++;
2480                 info++;
2481                 info->name = "STAC92xx Digital";
2482                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2483                 if (spec->multiout.dig_out_nid) {
2484                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2485                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2486                 }
2487                 if (spec->dig_in_nid) {
2488                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2489                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2490                 }
2491         }
2492
2493         return 0;
2494 }
2495
2496 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2497 {
2498         unsigned int pincap = snd_hda_param_read(codec, nid,
2499                                                  AC_PAR_PIN_CAP);
2500         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2501         if (pincap & AC_PINCAP_VREF_100)
2502                 return AC_PINCTL_VREF_100;
2503         if (pincap & AC_PINCAP_VREF_80)
2504                 return AC_PINCTL_VREF_80;
2505         if (pincap & AC_PINCAP_VREF_50)
2506                 return AC_PINCTL_VREF_50;
2507         if (pincap & AC_PINCAP_VREF_GRD)
2508                 return AC_PINCTL_VREF_GRD;
2509         return 0;
2510 }
2511
2512 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2513
2514 {
2515         snd_hda_codec_write_cache(codec, nid, 0,
2516                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2517 }
2518
2519 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2520
2521 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2522                         struct snd_ctl_elem_value *ucontrol)
2523 {
2524         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2525         struct sigmatel_spec *spec = codec->spec;
2526
2527         ucontrol->value.integer.value[0] = !!spec->hp_switch;
2528         return 0;
2529 }
2530
2531 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2532                                    unsigned char type);
2533
2534 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2535                         struct snd_ctl_elem_value *ucontrol)
2536 {
2537         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2538         struct sigmatel_spec *spec = codec->spec;
2539         int nid = kcontrol->private_value;
2540
2541         spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2542
2543         /* check to be sure that the ports are upto date with
2544          * switch changes
2545          */
2546         stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2547
2548         return 1;
2549 }
2550
2551 #define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
2552
2553 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2554 {
2555         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2556         struct sigmatel_spec *spec = codec->spec;
2557         int io_idx = kcontrol-> private_value & 0xff;
2558
2559         ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2560         return 0;
2561 }
2562
2563 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2564 {
2565         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2566         struct sigmatel_spec *spec = codec->spec;
2567         hda_nid_t nid = kcontrol->private_value >> 8;
2568         int io_idx = kcontrol-> private_value & 0xff;
2569         unsigned short val = !!ucontrol->value.integer.value[0];
2570
2571         spec->io_switch[io_idx] = val;
2572
2573         if (val)
2574                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2575         else {
2576                 unsigned int pinctl = AC_PINCTL_IN_EN;
2577                 if (io_idx) /* set VREF for mic */
2578                         pinctl |= stac92xx_get_vref(codec, nid);
2579                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2580         }
2581
2582         /* check the auto-mute again: we need to mute/unmute the speaker
2583          * appropriately according to the pin direction
2584          */
2585         if (spec->hp_detect)
2586                 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2587
2588         return 1;
2589 }
2590
2591 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2592
2593 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2594                 struct snd_ctl_elem_value *ucontrol)
2595 {
2596         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2597         struct sigmatel_spec *spec = codec->spec;
2598
2599         ucontrol->value.integer.value[0] = spec->clfe_swap;
2600         return 0;
2601 }
2602
2603 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2604                 struct snd_ctl_elem_value *ucontrol)
2605 {
2606         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2607         struct sigmatel_spec *spec = codec->spec;
2608         hda_nid_t nid = kcontrol->private_value & 0xff;
2609         unsigned int val = !!ucontrol->value.integer.value[0];
2610
2611         if (spec->clfe_swap == val)
2612                 return 0;
2613
2614         spec->clfe_swap = val;
2615
2616         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2617                 spec->clfe_swap ? 0x4 : 0x0);
2618
2619         return 1;
2620 }
2621
2622 #define STAC_CODEC_HP_SWITCH(xname) \
2623         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2624           .name = xname, \
2625           .index = 0, \
2626           .info = stac92xx_hp_switch_info, \
2627           .get = stac92xx_hp_switch_get, \
2628           .put = stac92xx_hp_switch_put, \
2629         }
2630
2631 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2632         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2633           .name = xname, \
2634           .index = 0, \
2635           .info = stac92xx_io_switch_info, \
2636           .get = stac92xx_io_switch_get, \
2637           .put = stac92xx_io_switch_put, \
2638           .private_value = xpval, \
2639         }
2640
2641 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2642         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2643           .name = xname, \
2644           .index = 0, \
2645           .info = stac92xx_clfe_switch_info, \
2646           .get = stac92xx_clfe_switch_get, \
2647           .put = stac92xx_clfe_switch_put, \
2648           .private_value = xpval, \
2649         }
2650
2651 enum {
2652         STAC_CTL_WIDGET_VOL,
2653         STAC_CTL_WIDGET_MUTE,
2654         STAC_CTL_WIDGET_MONO_MUX,
2655         STAC_CTL_WIDGET_AMP_MUX,
2656         STAC_CTL_WIDGET_AMP_VOL,
2657         STAC_CTL_WIDGET_HP_SWITCH,
2658         STAC_CTL_WIDGET_IO_SWITCH,
2659         STAC_CTL_WIDGET_CLFE_SWITCH
2660 };
2661
2662 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2663         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2664         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2665         STAC_MONO_MUX,
2666         STAC_AMP_MUX,
2667         STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2668         STAC_CODEC_HP_SWITCH(NULL),
2669         STAC_CODEC_IO_SWITCH(NULL, 0),
2670         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2671 };
2672
2673 /* add dynamic controls */
2674 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2675                                      struct snd_kcontrol_new *ktemp,
2676                                      int idx, const char *name,
2677                                      unsigned long val)
2678 {
2679         struct snd_kcontrol_new *knew;
2680
2681         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2682         knew = snd_array_new(&spec->kctls);
2683         if (!knew)
2684                 return -ENOMEM;
2685         *knew = *ktemp;
2686         knew->index = idx;
2687         knew->name = kstrdup(name, GFP_KERNEL);
2688         if (!knew->name)
2689                 return -ENOMEM;
2690         knew->private_value = val;
2691         return 0;
2692 }
2693
2694 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2695                                            int type, int idx, const char *name,
2696                                            unsigned long val)
2697 {
2698         return stac92xx_add_control_temp(spec,
2699                                          &stac92xx_control_templates[type],
2700                                          idx, name, val);
2701 }
2702
2703
2704 /* add dynamic controls */
2705 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2706                                        const char *name, unsigned long val)
2707 {
2708         return stac92xx_add_control_idx(spec, type, 0, name, val);
2709 }
2710
2711 /* check whether the line-input can be used as line-out */
2712 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2713 {
2714         struct sigmatel_spec *spec = codec->spec;
2715         struct auto_pin_cfg *cfg = &spec->autocfg;
2716         hda_nid_t nid;
2717         unsigned int pincap;
2718
2719         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2720                 return 0;
2721         nid = cfg->input_pins[AUTO_PIN_LINE];
2722         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2723         if (pincap & AC_PINCAP_OUT)
2724                 return nid;
2725         return 0;
2726 }
2727
2728 /* check whether the mic-input can be used as line-out */
2729 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2730 {
2731         struct sigmatel_spec *spec = codec->spec;
2732         struct auto_pin_cfg *cfg = &spec->autocfg;
2733         unsigned int def_conf, pincap;
2734         unsigned int mic_pin;
2735
2736         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2737                 return 0;
2738         mic_pin = AUTO_PIN_MIC;
2739         for (;;) {
2740                 hda_nid_t nid = cfg->input_pins[mic_pin];
2741                 def_conf = snd_hda_codec_read(codec, nid, 0,
2742                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
2743                 /* some laptops have an internal analog microphone
2744                  * which can't be used as a output */
2745                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2746                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2747                         if (pincap & AC_PINCAP_OUT)
2748                                 return nid;
2749                 }
2750                 if (mic_pin == AUTO_PIN_MIC)
2751                         mic_pin = AUTO_PIN_FRONT_MIC;
2752                 else
2753                         break;
2754         }
2755         return 0;
2756 }
2757
2758 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2759 {
2760         int i;
2761
2762         for (i = 0; i < spec->multiout.num_dacs; i++) {
2763                 if (spec->multiout.dac_nids[i] == nid)
2764                         return 1;
2765         }
2766
2767         return 0;
2768 }
2769
2770 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2771 {
2772         int i;
2773         if (is_in_dac_nids(spec, nid))
2774                 return 1;
2775         for (i = 0; i < spec->autocfg.hp_outs; i++)
2776                 if (spec->hp_dacs[i] == nid)
2777                         return 1;
2778         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2779                 if (spec->speaker_dacs[i] == nid)
2780                         return 1;
2781         return 0;
2782 }
2783
2784 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2785 {
2786         struct sigmatel_spec *spec = codec->spec;
2787         int j, conn_len;
2788         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2789         unsigned int wcaps, wtype;
2790
2791         conn_len = snd_hda_get_connections(codec, nid, conn,
2792                                            HDA_MAX_CONNECTIONS);
2793         for (j = 0; j < conn_len; j++) {
2794                 wcaps = snd_hda_param_read(codec, conn[j],
2795                                            AC_PAR_AUDIO_WIDGET_CAP);
2796                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2797                 /* we check only analog outputs */
2798                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2799                         continue;
2800                 /* if this route has a free DAC, assign it */
2801                 if (!check_all_dac_nids(spec, conn[j])) {
2802                         if (conn_len > 1) {
2803                                 /* select this DAC in the pin's input mux */
2804                                 snd_hda_codec_write_cache(codec, nid, 0,
2805                                                   AC_VERB_SET_CONNECT_SEL, j);
2806                         }
2807                         return conn[j];
2808                 }
2809         }
2810         return 0;
2811 }
2812
2813 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2814 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2815
2816 /*
2817  * Fill in the dac_nids table from the parsed pin configuration
2818  * This function only works when every pin in line_out_pins[]
2819  * contains atleast one DAC in its connection list. Some 92xx
2820  * codecs are not connected directly to a DAC, such as the 9200
2821  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2822  */
2823 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2824 {
2825         struct sigmatel_spec *spec = codec->spec;
2826         struct auto_pin_cfg *cfg = &spec->autocfg;
2827         int i;
2828         hda_nid_t nid, dac;
2829
2830         for (i = 0; i < cfg->line_outs; i++) {
2831                 nid = cfg->line_out_pins[i];
2832                 dac = get_unassigned_dac(codec, nid);
2833                 if (!dac) {
2834                         if (spec->multiout.num_dacs > 0) {
2835                                 /* we have already working output pins,
2836                                  * so let's drop the broken ones again
2837                                  */
2838                                 cfg->line_outs = spec->multiout.num_dacs;
2839                                 break;
2840                         }
2841                         /* error out, no available DAC found */
2842                         snd_printk(KERN_ERR
2843                                    "%s: No available DAC for pin 0x%x\n",
2844                                    __func__, nid);
2845                         return -ENODEV;
2846                 }
2847                 add_spec_dacs(spec, dac);
2848         }
2849
2850         /* add line-in as output */
2851         nid = check_line_out_switch(codec);
2852         if (nid) {
2853                 dac = get_unassigned_dac(codec, nid);
2854                 if (dac) {
2855                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2856                                     nid, cfg->line_outs);
2857                         cfg->line_out_pins[cfg->line_outs] = nid;
2858                         cfg->line_outs++;
2859                         spec->line_switch = nid;
2860                         add_spec_dacs(spec, dac);
2861                 }
2862         }
2863         /* add mic as output */
2864         nid = check_mic_out_switch(codec);
2865         if (nid) {
2866                 dac = get_unassigned_dac(codec, nid);
2867                 if (dac) {
2868                         snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2869                                     nid, cfg->line_outs);
2870                         cfg->line_out_pins[cfg->line_outs] = nid;
2871                         cfg->line_outs++;
2872                         spec->mic_switch = nid;
2873                         add_spec_dacs(spec, dac);
2874                 }
2875         }
2876
2877         for (i = 0; i < cfg->hp_outs; i++) {
2878                 nid = cfg->hp_pins[i];
2879                 dac = get_unassigned_dac(codec, nid);
2880                 if (dac) {
2881                         if (!spec->multiout.hp_nid)
2882                                 spec->multiout.hp_nid = dac;
2883                         else
2884                                 add_spec_extra_dacs(spec, dac);
2885                 }
2886                 spec->hp_dacs[i] = dac;
2887         }
2888
2889         for (i = 0; i < cfg->speaker_outs; i++) {
2890                 nid = cfg->speaker_pins[i];
2891                 dac = get_unassigned_dac(codec, nid);
2892                 if (dac)
2893                         add_spec_extra_dacs(spec, dac);
2894                 spec->speaker_dacs[i] = dac;
2895         }
2896
2897         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2898                    spec->multiout.num_dacs,
2899                    spec->multiout.dac_nids[0],
2900                    spec->multiout.dac_nids[1],
2901                    spec->multiout.dac_nids[2],
2902                    spec->multiout.dac_nids[3],
2903                    spec->multiout.dac_nids[4]);
2904
2905         return 0;
2906 }
2907
2908 /* create volume control/switch for the given prefx type */
2909 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2910 {
2911         char name[32];
2912         int err;
2913
2914         sprintf(name, "%s Playback Volume", pfx);
2915         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2916                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2917         if (err < 0)
2918                 return err;
2919         sprintf(name, "%s Playback Switch", pfx);
2920         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2921                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2922         if (err < 0)
2923                 return err;
2924         return 0;
2925 }
2926
2927 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2928 {
2929         if (spec->multiout.num_dacs > 4) {
2930                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2931                 return 1;
2932         } else {
2933                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2934                 spec->multiout.num_dacs++;
2935         }
2936         return 0;
2937 }
2938
2939 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2940 {
2941         int i;
2942         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
2943                 if (!spec->multiout.extra_out_nid[i]) {
2944                         spec->multiout.extra_out_nid[i] = nid;
2945                         return 0;
2946                 }
2947         }
2948         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
2949         return 1;
2950 }
2951
2952 static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
2953 {
2954         int i;
2955
2956         if (spec->autocfg.line_outs != 1)
2957                 return 0;
2958         if (spec->multiout.hp_nid == nid)
2959                 return 0;
2960         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
2961                 if (spec->multiout.extra_out_nid[i] == nid)
2962                         return 0;
2963         return 1;
2964 }
2965
2966 /* add playback controls from the parsed DAC table */
2967 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2968                                                const struct auto_pin_cfg *cfg)
2969 {
2970         struct sigmatel_spec *spec = codec->spec;
2971         static const char *chname[4] = {
2972                 "Front", "Surround", NULL /*CLFE*/, "Side"
2973         };
2974         hda_nid_t nid = 0;
2975         int i, err;
2976         unsigned int wid_caps;
2977
2978         for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
2979                 nid = spec->multiout.dac_nids[i];
2980                 if (i == 2) {
2981                         /* Center/LFE */
2982                         err = create_controls(spec, "Center", nid, 1);
2983                         if (err < 0)
2984                                 return err;
2985                         err = create_controls(spec, "LFE", nid, 2);
2986                         if (err < 0)
2987                                 return err;
2988
2989                         wid_caps = get_wcaps(codec, nid);
2990
2991                         if (wid_caps & AC_WCAP_LR_SWAP) {
2992                                 err = stac92xx_add_control(spec,
2993                                         STAC_CTL_WIDGET_CLFE_SWITCH,
2994                                         "Swap Center/LFE Playback Switch", nid);
2995
2996                                 if (err < 0)
2997                                         return err;
2998                         }
2999
3000                 } else {
3001                         const char *name = chname[i];
3002                         /* if it's a single DAC, assign a better name */
3003                         if (!i && is_unique_dac(spec, nid)) {
3004                                 switch (cfg->line_out_type) {
3005                                 case AUTO_PIN_HP_OUT:
3006                                         name = "Headphone";
3007                                         break;
3008                                 case AUTO_PIN_SPEAKER_OUT:
3009                                         name = "Speaker";
3010                                         break;
3011                                 }
3012                         }
3013                         err = create_controls(spec, name, nid, 3);
3014                         if (err < 0)
3015                                 return err;
3016                 }
3017         }
3018
3019         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3020                 err = stac92xx_add_control(spec,
3021                         STAC_CTL_WIDGET_HP_SWITCH,
3022                         "Headphone as Line Out Switch",
3023                         cfg->hp_pins[cfg->hp_outs - 1]);
3024                 if (err < 0)
3025                         return err;
3026         }
3027
3028         if (spec->line_switch) {
3029                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3030                                            "Line In as Output Switch",
3031                                            spec->line_switch << 8);
3032                 if (err < 0)
3033                         return err;
3034         }
3035
3036         if (spec->mic_switch) {
3037                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3038                                            "Mic as Output Switch",
3039                                            (spec->mic_switch << 8) | 1);
3040                 if (err < 0)
3041                         return err;
3042         }
3043
3044         return 0;
3045 }
3046
3047 /* add playback controls for Speaker and HP outputs */
3048 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3049                                         struct auto_pin_cfg *cfg)
3050 {
3051         struct sigmatel_spec *spec = codec->spec;
3052         hda_nid_t nid;
3053         int i, err, nums;
3054
3055         nums = 0;
3056         for (i = 0; i < cfg->hp_outs; i++) {
3057                 static const char *pfxs[] = {
3058                         "Headphone", "Headphone2", "Headphone3",
3059                 };
3060                 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
3061                 if (wid_caps & AC_WCAP_UNSOL_CAP)
3062                         spec->hp_detect = 1;
3063                 if (nums >= ARRAY_SIZE(pfxs))
3064                         continue;
3065                 nid = spec->hp_dacs[i];
3066                 if (!nid)
3067                         continue;
3068                 err = create_controls(spec, pfxs[nums++], nid, 3);
3069                 if (err < 0)
3070                         return err;
3071         }
3072         nums = 0;
3073         for (i = 0; i < cfg->speaker_outs; i++) {
3074                 static const char *pfxs[] = {
3075                         "Speaker", "External Speaker", "Speaker2",
3076                 };
3077                 if (nums >= ARRAY_SIZE(pfxs))
3078                         continue;
3079                 nid = spec->speaker_dacs[i];
3080                 if (!nid)
3081                         continue;
3082                 err = create_controls(spec, pfxs[nums++], nid, 3);
3083                 if (err < 0)
3084                         return err;
3085         }
3086         return 0;
3087 }
3088
3089 /* labels for mono mux outputs */
3090 static const char *stac92xx_mono_labels[4] = {
3091         "DAC0", "DAC1", "Mixer", "DAC2"
3092 };
3093
3094 /* create mono mux for mono out on capable codecs */
3095 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3096 {
3097         struct sigmatel_spec *spec = codec->spec;
3098         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3099         int i, num_cons;
3100         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3101
3102         num_cons = snd_hda_get_connections(codec,
3103                                 spec->mono_nid,
3104                                 con_lst,
3105                                 HDA_MAX_NUM_INPUTS);
3106         if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3107                 return -EINVAL;
3108
3109         for (i = 0; i < num_cons; i++) {
3110                 mono_mux->items[mono_mux->num_items].label =
3111                                         stac92xx_mono_labels[i];
3112                 mono_mux->items[mono_mux->num_items].index = i;
3113                 mono_mux->num_items++;
3114         }
3115
3116         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3117                                 "Mono Mux", spec->mono_nid);
3118 }
3119
3120 /* labels for amp mux outputs */
3121 static const char *stac92xx_amp_labels[3] = {
3122         "Front Microphone", "Microphone", "Line In",
3123 };
3124
3125 /* create amp out controls mux on capable codecs */
3126 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3127 {
3128         struct sigmatel_spec *spec = codec->spec;
3129         struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3130         int i, err;
3131
3132         for (i = 0; i < spec->num_amps; i++) {
3133                 amp_mux->items[amp_mux->num_items].label =
3134                                         stac92xx_amp_labels[i];
3135                 amp_mux->items[amp_mux->num_items].index = i;
3136                 amp_mux->num_items++;
3137         }
3138
3139         if (spec->num_amps > 1) {
3140                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3141                         "Amp Selector Capture Switch", 0);
3142                 if (err < 0)
3143                         return err;
3144         }
3145         return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3146                 "Amp Capture Volume",
3147                 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3148 }
3149
3150
3151 /* create PC beep volume controls */
3152 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3153                                                 hda_nid_t nid)
3154 {
3155         struct sigmatel_spec *spec = codec->spec;
3156         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3157         int err;
3158
3159         /* check for mute support for the the amp */
3160         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3161                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3162                         "PC Beep Playback Switch",
3163                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3164                         if (err < 0)
3165                                 return err;
3166         }
3167
3168         /* check to see if there is volume support for the amp */
3169         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3170                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3171                         "PC Beep Playback Volume",
3172                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3173                         if (err < 0)
3174                                 return err;
3175         }
3176         return 0;
3177 }
3178
3179 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3180 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3181
3182 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3183                                         struct snd_ctl_elem_value *ucontrol)
3184 {
3185         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3186         ucontrol->value.integer.value[0] = codec->beep->enabled;
3187         return 0;
3188 }
3189
3190 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3191                                         struct snd_ctl_elem_value *ucontrol)
3192 {
3193         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3194         int enabled = !!ucontrol->value.integer.value[0];
3195         if (codec->beep->enabled != enabled) {
3196                 codec->beep->enabled = enabled;
3197                 return 1;
3198         }
3199         return 0;
3200 }
3201
3202 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3203         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3204         .info = stac92xx_dig_beep_switch_info,
3205         .get = stac92xx_dig_beep_switch_get,
3206         .put = stac92xx_dig_beep_switch_put,
3207 };
3208
3209 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3210 {
3211         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3212                                          0, "PC Beep Playback Switch", 0);
3213 }
3214 #endif
3215
3216 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3217 {
3218         struct sigmatel_spec *spec = codec->spec;
3219         int wcaps, nid, i, err = 0;
3220
3221         for (i = 0; i < spec->num_muxes; i++) {
3222                 nid = spec->mux_nids[i];
3223                 wcaps = get_wcaps(codec, nid);
3224
3225                 if (wcaps & AC_WCAP_OUT_AMP) {
3226                         err = stac92xx_add_control_idx(spec,
3227                                 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3228                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3229                         if (err < 0)
3230                                 return err;
3231                 }
3232         }
3233         return 0;
3234 };
3235
3236 static const char *stac92xx_spdif_labels[3] = {
3237         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3238 };
3239
3240 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3241 {
3242         struct sigmatel_spec *spec = codec->spec;
3243         struct hda_input_mux *spdif_mux = &spec->private_smux;
3244         const char **labels = spec->spdif_labels;
3245         int i, num_cons;
3246         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3247
3248         num_cons = snd_hda_get_connections(codec,
3249                                 spec->smux_nids[0],
3250                                 con_lst,
3251                                 HDA_MAX_NUM_INPUTS);
3252         if (!num_cons)
3253                 return -EINVAL;
3254
3255         if (!labels)
3256                 labels = stac92xx_spdif_labels;
3257
3258         for (i = 0; i < num_cons; i++) {
3259                 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3260                 spdif_mux->items[spdif_mux->num_items].index = i;
3261                 spdif_mux->num_items++;
3262         }
3263
3264         return 0;
3265 }
3266
3267 /* labels for dmic mux inputs */
3268 static const char *stac92xx_dmic_labels[5] = {
3269         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3270         "Digital Mic 3", "Digital Mic 4"
3271 };
3272
3273 /* create playback/capture controls for input pins on dmic capable codecs */
3274 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3275                                                 const struct auto_pin_cfg *cfg)
3276 {
3277         struct sigmatel_spec *spec = codec->spec;
3278         struct hda_input_mux *dimux = &spec->private_dimux;
3279         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3280         int err, i, j;
3281         char name[32];
3282
3283         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3284         dimux->items[dimux->num_items].index = 0;
3285         dimux->num_items++;
3286
3287         for (i = 0; i < spec->num_dmics; i++) {
3288                 hda_nid_t nid;
3289                 int index;
3290                 int num_cons;
3291                 unsigned int wcaps;
3292                 unsigned int def_conf;
3293
3294                 def_conf = snd_hda_codec_read(codec,
3295                                               spec->dmic_nids[i],
3296                                               0,
3297                                               AC_VERB_GET_CONFIG_DEFAULT,
3298                                               0);
3299                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3300                         continue;
3301
3302                 nid = spec->dmic_nids[i];
3303                 num_cons = snd_hda_get_connections(codec,
3304                                 spec->dmux_nids[0],
3305                                 con_lst,
3306                                 HDA_MAX_NUM_INPUTS);
3307                 for (j = 0; j < num_cons; j++)
3308                         if (con_lst[j] == nid) {
3309                                 index = j;
3310                                 goto found;
3311                         }
3312                 continue;
3313 found:
3314                 wcaps = get_wcaps(codec, nid) &
3315                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3316
3317                 if (wcaps) {
3318                         sprintf(name, "%s Capture Volume",
3319                                 stac92xx_dmic_labels[dimux->num_items]);
3320
3321                         err = stac92xx_add_control(spec,
3322                                 STAC_CTL_WIDGET_VOL,
3323                                 name,
3324                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3325                                 (wcaps & AC_WCAP_OUT_AMP) ?
3326                                 HDA_OUTPUT : HDA_INPUT));
3327                         if (err < 0)
3328                                 return err;
3329                 }
3330
3331                 dimux->items[dimux->num_items].label =
3332                         stac92xx_dmic_labels[dimux->num_items];
3333                 dimux->items[dimux->num_items].index = index;
3334                 dimux->num_items++;
3335         }
3336
3337         return 0;
3338 }
3339
3340 /* create playback/capture controls for input pins */
3341 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3342 {
3343         struct sigmatel_spec *spec = codec->spec;
3344         struct hda_input_mux *imux = &spec->private_imux;
3345         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3346         int i, j, k;
3347
3348         for (i = 0; i < AUTO_PIN_LAST; i++) {
3349                 int index;
3350
3351                 if (!cfg->input_pins[i])
3352                         continue;
3353                 index = -1;
3354                 for (j = 0; j < spec->num_muxes; j++) {
3355                         int num_cons;
3356                         num_cons = snd_hda_get_connections(codec,
3357                                                            spec->mux_nids[j],
3358                                                            con_lst,
3359                                                            HDA_MAX_NUM_INPUTS);
3360                         for (k = 0; k < num_cons; k++)
3361                                 if (con_lst[k] == cfg->input_pins[i]) {
3362                                         index = k;
3363                                         goto found;
3364                                 }
3365                 }
3366                 continue;
3367         found:
3368                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3369                 imux->items[imux->num_items].index = index;
3370                 imux->num_items++;
3371         }
3372
3373         if (imux->num_items) {
3374                 /*
3375                  * Set the current input for the muxes.
3376                  * The STAC9221 has two input muxes with identical source
3377                  * NID lists.  Hopefully this won't get confused.
3378                  */
3379                 for (i = 0; i < spec->num_muxes; i++) {
3380                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3381                                                   AC_VERB_SET_CONNECT_SEL,
3382                                                   imux->items[0].index);
3383                 }
3384         }
3385
3386         return 0;
3387 }
3388
3389 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3390 {
3391         struct sigmatel_spec *spec = codec->spec;
3392         int i;
3393
3394         for (i = 0; i < spec->autocfg.line_outs; i++) {
3395                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3396                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3397         }
3398 }
3399
3400 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3401 {
3402         struct sigmatel_spec *spec = codec->spec;
3403         int i;
3404
3405         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3406                 hda_nid_t pin;
3407                 pin = spec->autocfg.hp_pins[i];
3408                 if (pin) /* connect to front */
3409                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3410         }
3411         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3412                 hda_nid_t pin;
3413                 pin = spec->autocfg.speaker_pins[i];
3414                 if (pin) /* connect to front */
3415                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3416         }
3417 }
3418
3419 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3420 {
3421         struct sigmatel_spec *spec = codec->spec;
3422         int err;
3423
3424         if ((err = snd_hda_parse_pin_def_config(codec,
3425                                                 &spec->autocfg,
3426                                                 spec->dmic_nids)) < 0)
3427                 return err;
3428         if (! spec->autocfg.line_outs)
3429                 return 0; /* can't find valid pin config */
3430
3431         /* If we have no real line-out pin and multiple hp-outs, HPs should
3432          * be set up as multi-channel outputs.
3433          */
3434         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3435             spec->autocfg.hp_outs > 1) {
3436                 /* Copy hp_outs to line_outs, backup line_outs in
3437                  * speaker_outs so that the following routines can handle
3438                  * HP pins as primary outputs.
3439                  */
3440                 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3441                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3442                        sizeof(spec->autocfg.line_out_pins));
3443                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3444                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3445                        sizeof(spec->autocfg.hp_pins));
3446                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3447                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3448                 spec->autocfg.hp_outs = 0;
3449         }
3450         if (spec->autocfg.mono_out_pin) {
3451                 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3452                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3453                 u32 caps = query_amp_caps(codec,
3454                                 spec->autocfg.mono_out_pin, dir);
3455                 hda_nid_t conn_list[1];
3456
3457                 /* get the mixer node and then the mono mux if it exists */
3458                 if (snd_hda_get_connections(codec,
3459                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
3460                                 snd_hda_get_connections(codec, conn_list[0],
3461                                 conn_list, 1)) {
3462
3463                                 int wcaps = get_wcaps(codec, conn_list[0]);
3464                                 int wid_type = (wcaps & AC_WCAP_TYPE)
3465                                         >> AC_WCAP_TYPE_SHIFT;
3466                                 /* LR swap check, some stac925x have a mux that
3467                                  * changes the DACs output path instead of the
3468                                  * mono-mux path.
3469                                  */
3470                                 if (wid_type == AC_WID_AUD_SEL &&
3471                                                 !(wcaps & AC_WCAP_LR_SWAP))
3472                                         spec->mono_nid = conn_list[0];
3473                 }
3474                 if (dir) {
3475                         hda_nid_t nid = spec->autocfg.mono_out_pin;
3476
3477                         /* most mono outs have a least a mute/unmute switch */
3478                         dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3479                         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3480                                 "Mono Playback Switch",
3481                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3482                         if (err < 0)
3483                                 return err;
3484                         /* check for volume support for the amp */
3485                         if ((caps & AC_AMPCAP_NUM_STEPS)
3486                                         >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3487                                 err = stac92xx_add_control(spec,
3488                                         STAC_CTL_WIDGET_VOL,
3489                                         "Mono Playback Volume",
3490                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3491                                 if (err < 0)
3492                                         return err;
3493                         }
3494                 }
3495
3496                 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3497                                          AC_PINCTL_OUT_EN);
3498         }
3499
3500         if (!spec->multiout.num_dacs) {
3501                 err = stac92xx_auto_fill_dac_nids(codec);
3502                 if (err < 0)
3503                         return err;
3504         }
3505
3506         err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
3507
3508         if (err < 0)
3509                 return err;
3510
3511         /* setup analog beep controls */
3512         if (spec->anabeep_nid > 0) {
3513                 err = stac92xx_auto_create_beep_ctls(codec,
3514                         spec->anabeep_nid);
3515                 if (err < 0)
3516                         return err;
3517         }
3518
3519         /* setup digital beep controls and input device */
3520 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3521         if (spec->digbeep_nid > 0) {
3522                 hda_nid_t nid = spec->digbeep_nid;
3523                 unsigned int caps;
3524
3525                 err = stac92xx_auto_create_beep_ctls(codec, nid);
3526                 if (err < 0)
3527                         return err;
3528                 err = snd_hda_attach_beep_device(codec, nid);
3529                 if (err < 0)
3530                         return err;
3531                 /* if no beep switch is available, make its own one */
3532                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3533                 if (codec->beep &&
3534                     !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3535                         err = stac92xx_beep_switch_ctl(codec);
3536                         if (err < 0)
3537                                 return err;
3538                 }
3539         }
3540 #endif
3541
3542         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3543
3544         if (err < 0)
3545                 return err;
3546
3547         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3548
3549         if (err < 0)
3550                 return err;
3551
3552         if (spec->mono_nid > 0) {
3553                 err = stac92xx_auto_create_mono_output_ctls(codec);
3554                 if (err < 0)
3555                         return err;
3556         }
3557         if (spec->num_amps > 0) {
3558                 err = stac92xx_auto_create_amp_output_ctls(codec);
3559                 if (err < 0)
3560                         return err;
3561         }
3562         if (spec->num_dmics > 0 && !spec->dinput_mux)
3563                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3564                                                 &spec->autocfg)) < 0)
3565                         return err;
3566         if (spec->num_muxes > 0) {
3567                 err = stac92xx_auto_create_mux_input_ctls(codec);
3568                 if (err < 0)
3569                         return err;
3570         }
3571         if (spec->num_smuxes > 0) {
3572                 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3573                 if (err < 0)
3574                         return err;
3575         }
3576
3577         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3578         if (spec->multiout.max_channels > 2)
3579                 spec->surr_switch = 1;
3580
3581         if (spec->autocfg.dig_out_pin)
3582                 spec->multiout.dig_out_nid = dig_out;
3583         if (dig_in && spec->autocfg.dig_in_pin)
3584                 spec->dig_in_nid = dig_in;
3585
3586         if (spec->kctls.list)
3587                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3588
3589         spec->input_mux = &spec->private_imux;
3590         spec->dinput_mux = &spec->private_dimux;
3591         spec->sinput_mux = &spec->private_smux;
3592         spec->mono_mux = &spec->private_mono_mux;
3593         spec->amp_mux = &spec->private_amp_mux;
3594         return 1;
3595 }
3596
3597 /* add playback controls for HP output */
3598 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3599                                         struct auto_pin_cfg *cfg)
3600 {
3601         struct sigmatel_spec *spec = codec->spec;
3602         hda_nid_t pin = cfg->hp_pins[0];
3603         unsigned int wid_caps;
3604
3605         if (! pin)
3606                 return 0;
3607
3608         wid_caps = get_wcaps(codec, pin);
3609         if (wid_caps & AC_WCAP_UNSOL_CAP)
3610                 spec->hp_detect = 1;
3611
3612         return 0;
3613 }
3614
3615 /* add playback controls for LFE output */
3616 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3617                                         struct auto_pin_cfg *cfg)
3618 {
3619         struct sigmatel_spec *spec = codec->spec;
3620         int err;
3621         hda_nid_t lfe_pin = 0x0;
3622         int i;
3623
3624         /*
3625          * search speaker outs and line outs for a mono speaker pin
3626          * with an amp.  If one is found, add LFE controls
3627          * for it.
3628          */
3629         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3630                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3631                 unsigned int wcaps = get_wcaps(codec, pin);
3632                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3633                 if (wcaps == AC_WCAP_OUT_AMP)
3634                         /* found a mono speaker with an amp, must be lfe */
3635                         lfe_pin = pin;
3636         }
3637
3638         /* if speaker_outs is 0, then speakers may be in line_outs */
3639         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3640                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3641                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
3642                         unsigned int defcfg;
3643                         defcfg = snd_hda_codec_read(codec, pin, 0,
3644                                                  AC_VERB_GET_CONFIG_DEFAULT,
3645                                                  0x00);
3646                         if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3647                                 unsigned int wcaps = get_wcaps(codec, pin);
3648                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3649                                 if (wcaps == AC_WCAP_OUT_AMP)
3650                                         /* found a mono speaker with an amp,
3651                                            must be lfe */
3652                                         lfe_pin = pin;
3653                         }
3654                 }
3655         }
3656
3657         if (lfe_pin) {
3658                 err = create_controls(spec, "LFE", lfe_pin, 1);
3659                 if (err < 0)
3660                         return err;
3661         }
3662
3663         return 0;
3664 }
3665
3666 static int stac9200_parse_auto_config(struct hda_codec *codec)
3667 {
3668         struct sigmatel_spec *spec = codec->spec;
3669         int err;
3670
3671         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3672                 return err;
3673
3674         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3675                 return err;
3676
3677         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3678                 return err;
3679
3680         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3681                 return err;
3682
3683         if (spec->num_muxes > 0) {
3684                 err = stac92xx_auto_create_mux_input_ctls(codec);
3685                 if (err < 0)
3686                         return err;
3687         }
3688
3689         if (spec->autocfg.dig_out_pin)
3690                 spec->multiout.dig_out_nid = 0x05;
3691         if (spec->autocfg.dig_in_pin)
3692                 spec->dig_in_nid = 0x04;
3693
3694         if (spec->kctls.list)
3695                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3696
3697         spec->input_mux = &spec->private_imux;
3698         spec->dinput_mux = &spec->private_dimux;
3699
3700         return 1;
3701 }
3702
3703 /*
3704  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3705  * funky external mute control using GPIO pins.
3706  */
3707
3708 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3709                           unsigned int dir_mask, unsigned int data)
3710 {
3711         unsigned int gpiostate, gpiomask, gpiodir;
3712
3713         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3714                                        AC_VERB_GET_GPIO_DATA, 0);
3715         gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3716
3717         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3718                                       AC_VERB_GET_GPIO_MASK, 0);
3719         gpiomask |= mask;
3720
3721         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3722                                      AC_VERB_GET_GPIO_DIRECTION, 0);
3723         gpiodir |= dir_mask;
3724
3725         /* Configure GPIOx as CMOS */
3726         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3727
3728         snd_hda_codec_write(codec, codec->afg, 0,
3729                             AC_VERB_SET_GPIO_MASK, gpiomask);
3730         snd_hda_codec_read(codec, codec->afg, 0,
3731                            AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3732
3733         msleep(1);
3734
3735         snd_hda_codec_read(codec, codec->afg, 0,
3736                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3737 }
3738
3739 static int stac92xx_add_jack(struct hda_codec *codec,
3740                 hda_nid_t nid, int type)
3741 {
3742 #ifdef CONFIG_SND_JACK
3743         struct sigmatel_spec *spec = codec->spec;
3744         struct sigmatel_jack *jack;
3745         int def_conf = snd_hda_codec_read(codec, nid,
3746                         0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3747         int connectivity = get_defcfg_connect(def_conf);
3748         char name[32];
3749
3750         if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3751                 return 0;
3752
3753         snd_array_init(&spec->jacks, sizeof(*jack), 32);
3754         jack = snd_array_new(&spec->jacks);
3755         if (!jack)
3756                 return -ENOMEM;
3757         jack->nid = nid;
3758         jack->type = type;
3759
3760         sprintf(name, "%s at %s %s Jack",
3761                 snd_hda_get_jack_type(def_conf),
3762                 snd_hda_get_jack_connectivity(def_conf),
3763                 snd_hda_get_jack_location(def_conf));
3764
3765         return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3766 #else
3767         return 0;
3768 #endif
3769 }
3770
3771 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3772                           unsigned char type, int data)
3773 {
3774         struct sigmatel_event *event;
3775
3776         snd_array_init(&spec->events, sizeof(*event), 32);
3777         event = snd_array_new(&spec->events);
3778         if (!event)
3779                 return -ENOMEM;
3780         event->nid = nid;
3781         event->type = type;
3782         event->tag = spec->events.used;
3783         event->data = data;
3784
3785         return event->tag;
3786 }
3787
3788 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3789                                              hda_nid_t nid, unsigned char type)
3790 {
3791         struct sigmatel_spec *spec = codec->spec;
3792         struct sigmatel_event *event = spec->events.list;
3793         int i;
3794
3795         for (i = 0; i < spec->events.used; i++, event++) {
3796                 if (event->nid == nid && event->type == type)
3797                         return event;
3798         }
3799         return NULL;
3800 }
3801
3802 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3803                                                       unsigned char tag)
3804 {
3805         struct sigmatel_spec *spec = codec->spec;
3806         struct sigmatel_event *event = spec->events.list;
3807         int i;
3808
3809         for (i = 0; i < spec->events.used; i++, event++) {
3810                 if (event->tag == tag)
3811                         return event;
3812         }
3813         return NULL;
3814 }
3815
3816 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3817                               unsigned int type)
3818 {
3819         struct sigmatel_event *event;
3820         int tag;
3821
3822         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3823                 return;
3824         event = stac_get_event(codec, nid, type);
3825         if (event)
3826                 tag = event->tag;
3827         else
3828                 tag = stac_add_event(codec->spec, nid, type, 0);
3829         if (tag < 0)
3830                 return;
3831         snd_hda_codec_write_cache(codec, nid, 0,
3832                                   AC_VERB_SET_UNSOLICITED_ENABLE,
3833                                   AC_USRSP_EN | tag);
3834 }
3835
3836 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3837 {
3838         int i;
3839         for (i = 0; i < cfg->hp_outs; i++)
3840                 if (cfg->hp_pins[i] == nid)
3841                         return 1; /* nid is a HP-Out */
3842
3843         return 0; /* nid is not a HP-Out */
3844 };
3845
3846 static void stac92xx_power_down(struct hda_codec *codec)
3847 {
3848         struct sigmatel_spec *spec = codec->spec;
3849
3850         /* power down inactive DACs */
3851         hda_nid_t *dac;
3852         for (dac = spec->dac_list; *dac; dac++)
3853                 if (!check_all_dac_nids(spec, *dac))
3854                         snd_hda_codec_write(codec, *dac, 0,
3855                                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3856 }
3857
3858 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3859                                   int enable);
3860
3861 static int stac92xx_init(struct hda_codec *codec)
3862 {
3863         struct sigmatel_spec *spec = codec->spec;
3864         struct auto_pin_cfg *cfg = &spec->autocfg;
3865         unsigned int gpio;
3866         int i;
3867
3868         snd_hda_sequence_write(codec, spec->init);
3869
3870         /* power down adcs initially */
3871         if (spec->powerdown_adcs)
3872                 for (i = 0; i < spec->num_adcs; i++)
3873                         snd_hda_codec_write(codec,
3874                                 spec->adc_nids[i], 0,
3875                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3876
3877         /* set up GPIO */
3878         gpio = spec->gpio_data;
3879         /* turn on EAPD statically when spec->eapd_switch isn't set.
3880          * otherwise, unsol event will turn it on/off dynamically
3881          */
3882         if (!spec->eapd_switch)
3883                 gpio |= spec->eapd_mask;
3884         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
3885
3886         /* set up pins */
3887         if (spec->hp_detect) {
3888                 /* Enable unsolicited responses on the HP widget */
3889                 for (i = 0; i < cfg->hp_outs; i++) {
3890                         hda_nid_t nid = cfg->hp_pins[i];
3891                         enable_pin_detect(codec, nid, STAC_HP_EVENT);
3892                 }
3893                 /* force to enable the first line-out; the others are set up
3894                  * in unsol_event
3895                  */
3896                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3897                                 AC_PINCTL_OUT_EN);
3898                 /* fake event to set up pins */
3899                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
3900                                        STAC_HP_EVENT);
3901         } else {
3902                 stac92xx_auto_init_multi_out(codec);
3903                 stac92xx_auto_init_hp_out(codec);
3904                 for (i = 0; i < cfg->hp_outs; i++)
3905                         stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
3906         }
3907         for (i = 0; i < AUTO_PIN_LAST; i++) {
3908                 hda_nid_t nid = cfg->input_pins[i];
3909                 if (nid) {
3910                         unsigned int pinctl, conf;
3911                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3912                                 /* for mic pins, force to initialize */
3913                                 pinctl = stac92xx_get_vref(codec, nid);
3914                                 pinctl |= AC_PINCTL_IN_EN;
3915                                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3916                         } else {
3917                                 pinctl = snd_hda_codec_read(codec, nid, 0,
3918                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3919                                 /* if PINCTL already set then skip */
3920                                 if (!(pinctl & AC_PINCTL_IN_EN)) {
3921                                         pinctl |= AC_PINCTL_IN_EN;
3922                                         stac92xx_auto_set_pinctl(codec, nid,
3923                                                                  pinctl);
3924                                 }
3925                         }
3926                         conf = snd_hda_codec_read(codec, nid, 0,
3927                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
3928                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
3929                                 enable_pin_detect(codec, nid,
3930                                                   STAC_INSERT_EVENT);
3931                                 stac_issue_unsol_event(codec, nid,
3932                                                        STAC_INSERT_EVENT);
3933                         }
3934                 }
3935         }
3936         for (i = 0; i < spec->num_dmics; i++)
3937                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
3938                                         AC_PINCTL_IN_EN);
3939         if (cfg->dig_out_pin)
3940                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
3941                                          AC_PINCTL_OUT_EN);
3942         if (cfg->dig_in_pin)
3943                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
3944                                          AC_PINCTL_IN_EN);
3945         for (i = 0; i < spec->num_pwrs; i++)  {
3946                 hda_nid_t nid = spec->pwr_nids[i];
3947                 int pinctl, def_conf;
3948
3949                 if (is_nid_hp_pin(cfg, nid) && spec->hp_detect)
3950                         continue; /* already has an unsol event */
3951
3952                 pinctl = snd_hda_codec_read(codec, nid, 0,
3953                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3954                 /* outputs are only ports capable of power management
3955                  * any attempts on powering down a input port cause the
3956                  * referenced VREF to act quirky.
3957                  */
3958                 if (pinctl & AC_PINCTL_IN_EN)
3959                         continue;
3960                 def_conf = snd_hda_codec_read(codec, nid, 0,
3961                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
3962                 def_conf = get_defcfg_connect(def_conf);
3963                 /* skip any ports that don't have jacks since presence
3964                  * detection is useless */
3965                 if (def_conf != AC_JACK_PORT_COMPLEX) {
3966                         if (def_conf != AC_JACK_PORT_NONE)
3967                                 stac_toggle_power_map(codec, nid, 1);
3968                         continue;
3969                 }
3970                 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
3971                         enable_pin_detect(codec, nid, STAC_PWR_EVENT);
3972                         stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
3973                 }
3974         }
3975         if (spec->dac_list)
3976                 stac92xx_power_down(codec);
3977         return 0;
3978 }
3979
3980 static void stac92xx_free_jacks(struct hda_codec *codec)
3981 {
3982 #ifdef CONFIG_SND_JACK
3983         /* free jack instances manually when clearing/reconfiguring */
3984         struct sigmatel_spec *spec = codec->spec;
3985         if (!codec->bus->shutdown && spec->jacks.list) {
3986                 struct sigmatel_jack *jacks = spec->jacks.list;
3987                 int i;
3988                 for (i = 0; i < spec->jacks.used; i++)
3989                         snd_device_free(codec->bus->card, &jacks[i].jack);
3990         }
3991         snd_array_free(&spec->jacks);
3992 #endif
3993 }
3994
3995 static void stac92xx_free_kctls(struct hda_codec *codec)
3996 {
3997         struct sigmatel_spec *spec = codec->spec;
3998
3999         if (spec->kctls.list) {
4000                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4001                 int i;
4002                 for (i = 0; i < spec->kctls.used; i++)
4003                         kfree(kctl[i].name);
4004         }
4005         snd_array_free(&spec->kctls);
4006 }
4007
4008 static void stac92xx_free(struct hda_codec *codec)
4009 {
4010         struct sigmatel_spec *spec = codec->spec;
4011
4012         if (! spec)
4013                 return;
4014
4015         kfree(spec->pin_configs);
4016         stac92xx_free_jacks(codec);
4017         snd_array_free(&spec->events);
4018
4019         kfree(spec);
4020         snd_hda_detach_beep_device(codec);
4021 }
4022
4023 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4024                                 unsigned int flag)
4025 {
4026         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4027                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4028
4029         if (pin_ctl & AC_PINCTL_IN_EN) {
4030                 /*
4031                  * we need to check the current set-up direction of
4032                  * shared input pins since they can be switched via
4033                  * "xxx as Output" mixer switch
4034                  */
4035                 struct sigmatel_spec *spec = codec->spec;
4036                 if (nid == spec->line_switch || nid == spec->mic_switch)
4037                         return;
4038         }
4039
4040         /* if setting pin direction bits, clear the current
4041            direction bits first */
4042         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4043                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4044
4045         snd_hda_codec_write_cache(codec, nid, 0,
4046                         AC_VERB_SET_PIN_WIDGET_CONTROL,
4047                         pin_ctl | flag);
4048 }
4049
4050 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4051                                   unsigned int flag)
4052 {
4053         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4054                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4055         snd_hda_codec_write_cache(codec, nid, 0,
4056                         AC_VERB_SET_PIN_WIDGET_CONTROL,
4057                         pin_ctl & ~flag);
4058 }
4059
4060 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4061 {
4062         if (!nid)
4063                 return 0;
4064         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4065             & (1 << 31))
4066                 return 1;
4067         return 0;
4068 }
4069
4070 /* return non-zero if the hp-pin of the given array index isn't
4071  * a jack-detection target
4072  */
4073 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4074 {
4075         struct auto_pin_cfg *cfg = &spec->autocfg;
4076
4077         /* ignore sensing of shared line and mic jacks */
4078         if (cfg->hp_pins[i] == spec->line_switch)
4079                 return 1;
4080         if (cfg->hp_pins[i] == spec->mic_switch)
4081                 return 1;
4082         /* ignore if the pin is set as line-out */
4083         if (cfg->hp_pins[i] == spec->hp_switch)
4084                 return 1;
4085         return 0;
4086 }
4087
4088 static void stac92xx_hp_detect(struct hda_codec *codec)
4089 {
4090         struct sigmatel_spec *spec = codec->spec;
4091         struct auto_pin_cfg *cfg = &spec->autocfg;
4092         int i, presence;
4093
4094         presence = 0;
4095         if (spec->gpio_mute)
4096                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4097                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4098
4099         for (i = 0; i < cfg->hp_outs; i++) {
4100                 if (presence)
4101                         break;
4102                 if (no_hp_sensing(spec, i))
4103                         continue;
4104                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4105                 if (presence) {
4106                         unsigned int pinctl;
4107                         pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4108                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4109                         if (pinctl & AC_PINCTL_IN_EN)
4110                                 presence = 0; /* mic- or line-input */
4111                 }
4112         }
4113
4114         if (presence) {
4115                 /* disable lineouts */
4116                 if (spec->hp_switch)
4117                         stac92xx_reset_pinctl(codec, spec->hp_switch,
4118                                               AC_PINCTL_OUT_EN);
4119                 for (i = 0; i < cfg->line_outs; i++)
4120                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4121                                                 AC_PINCTL_OUT_EN);
4122                 for (i = 0; i < cfg->speaker_outs; i++)
4123                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4124                                                 AC_PINCTL_OUT_EN);
4125                 if (spec->eapd_mask && spec->eapd_switch)
4126                         stac_gpio_set(codec, spec->gpio_mask,
4127                                 spec->gpio_dir, spec->gpio_data &
4128                                 ~spec->eapd_mask);
4129         } else {
4130                 /* enable lineouts */
4131                 if (spec->hp_switch)
4132                         stac92xx_set_pinctl(codec, spec->hp_switch,
4133                                             AC_PINCTL_OUT_EN);
4134                 for (i = 0; i < cfg->line_outs; i++)
4135                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4136                                                 AC_PINCTL_OUT_EN);
4137                 for (i = 0; i < cfg->speaker_outs; i++)
4138                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4139                                                 AC_PINCTL_OUT_EN);
4140                 if (spec->eapd_mask && spec->eapd_switch)
4141                         stac_gpio_set(codec, spec->gpio_mask,
4142                                 spec->gpio_dir, spec->gpio_data |
4143                                 spec->eapd_mask);
4144         }
4145         /* toggle hp outs */
4146         for (i = 0; i < cfg->hp_outs; i++) {
4147                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4148                 if (no_hp_sensing(spec, i))
4149                         continue;
4150                 if (presence)
4151                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4152                 else
4153                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4154         }
4155 }
4156
4157 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4158                                   int enable)
4159 {
4160         struct sigmatel_spec *spec = codec->spec;
4161         unsigned int idx, val;
4162
4163         for (idx = 0; idx < spec->num_pwrs; idx++) {
4164                 if (spec->pwr_nids[idx] == nid)
4165                         break;
4166         }
4167         if (idx >= spec->num_pwrs)
4168                 return;
4169
4170         /* several codecs have two power down bits */
4171         if (spec->pwr_mapping)
4172                 idx = spec->pwr_mapping[idx];
4173         else
4174                 idx = 1 << idx;
4175
4176         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4177         if (enable)
4178                 val &= ~idx;
4179         else
4180                 val |= idx;
4181
4182         /* power down unused output ports */
4183         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4184 }
4185
4186 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4187 {
4188         stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4189 }
4190
4191 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4192 {
4193         struct sigmatel_spec *spec = codec->spec;
4194         struct sigmatel_jack *jacks = spec->jacks.list;
4195
4196         if (jacks) {
4197                 int i;
4198                 for (i = 0; i < spec->jacks.used; i++) {
4199                         if (jacks->nid == nid) {
4200                                 unsigned int pin_ctl =
4201                                         snd_hda_codec_read(codec, nid,
4202                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4203                                          0x00);
4204                                 int type = jacks->type;
4205                                 if (type == (SND_JACK_LINEOUT
4206                                                 | SND_JACK_HEADPHONE))
4207                                         type = (pin_ctl & AC_PINCTL_HP_EN)
4208                                         ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4209                                 snd_jack_report(jacks->jack,
4210                                         get_pin_presence(codec, nid)
4211                                         ? type : 0);
4212                         }
4213                         jacks++;
4214                 }
4215         }
4216 }
4217
4218 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4219                                    unsigned char type)
4220 {
4221         struct sigmatel_event *event = stac_get_event(codec, nid, type);
4222         if (!event)
4223                 return;
4224         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4225 }
4226
4227 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4228 {
4229         struct sigmatel_spec *spec = codec->spec;
4230         struct sigmatel_event *event;
4231         int tag, data;
4232
4233         tag = (res >> 26) & 0x7f;
4234         event = stac_get_event_from_tag(codec, tag);
4235         if (!event)
4236                 return;
4237
4238         switch (event->type) {
4239         case STAC_HP_EVENT:
4240                 stac92xx_hp_detect(codec);
4241                 /* fallthru */
4242         case STAC_INSERT_EVENT:
4243         case STAC_PWR_EVENT:
4244                 if (spec->num_pwrs > 0)
4245                         stac92xx_pin_sense(codec, event->nid);
4246                 stac92xx_report_jack(codec, event->nid);
4247                 break;
4248         case STAC_VREF_EVENT:
4249                 data = snd_hda_codec_read(codec, codec->afg, 0,
4250                                           AC_VERB_GET_GPIO_DATA, 0);
4251                 /* toggle VREF state based on GPIOx status */
4252                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4253                                     !!(data & (1 << event->data)));
4254                 break;
4255         }
4256 }
4257
4258 #ifdef CONFIG_PROC_FS
4259 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4260                                struct hda_codec *codec, hda_nid_t nid)
4261 {
4262         if (nid == codec->afg)
4263                 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4264                             snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4265 }
4266
4267 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4268                                   struct hda_codec *codec,
4269                                   unsigned int verb)
4270 {
4271         snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4272                     snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4273 }
4274
4275 /* stac92hd71bxx, stac92hd73xx */
4276 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4277                                  struct hda_codec *codec, hda_nid_t nid)
4278 {
4279         stac92hd_proc_hook(buffer, codec, nid);
4280         if (nid == codec->afg)
4281                 analog_loop_proc_hook(buffer, codec, 0xfa0);
4282 }
4283
4284 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4285                                struct hda_codec *codec, hda_nid_t nid)
4286 {
4287         if (nid == codec->afg)
4288                 analog_loop_proc_hook(buffer, codec, 0xfe0);
4289 }
4290
4291 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4292                                struct hda_codec *codec, hda_nid_t nid)
4293 {
4294         if (nid == codec->afg)
4295                 analog_loop_proc_hook(buffer, codec, 0xfeb);
4296 }
4297 #else
4298 #define stac92hd_proc_hook      NULL
4299 #define stac92hd7x_proc_hook    NULL
4300 #define stac9205_proc_hook      NULL
4301 #define stac927x_proc_hook      NULL
4302 #endif
4303
4304 #ifdef SND_HDA_NEEDS_RESUME
4305 static int stac92xx_resume(struct hda_codec *codec)
4306 {
4307         struct sigmatel_spec *spec = codec->spec;
4308
4309         stac92xx_set_config_regs(codec);
4310         stac92xx_init(codec);
4311         snd_hda_codec_resume_amp(codec);
4312         snd_hda_codec_resume_cache(codec);
4313         /* fake event to set up pins again to override cached values */
4314         if (spec->hp_detect)
4315                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4316                                        STAC_HP_EVENT);
4317         return 0;
4318 }
4319
4320 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4321 {
4322         struct sigmatel_spec *spec = codec->spec;
4323         if (spec->eapd_mask)
4324                 stac_gpio_set(codec, spec->gpio_mask,
4325                                 spec->gpio_dir, spec->gpio_data &
4326                                 ~spec->eapd_mask);
4327         return 0;
4328 }
4329 #endif
4330
4331 static struct hda_codec_ops stac92xx_patch_ops = {
4332         .build_controls = stac92xx_build_controls,
4333         .build_pcms = stac92xx_build_pcms,
4334         .init = stac92xx_init,
4335         .free = stac92xx_free,
4336         .unsol_event = stac92xx_unsol_event,
4337 #ifdef SND_HDA_NEEDS_RESUME
4338         .suspend = stac92xx_suspend,
4339         .resume = stac92xx_resume,
4340 #endif
4341 };
4342
4343 static int patch_stac9200(struct hda_codec *codec)
4344 {
4345         struct sigmatel_spec *spec;
4346         int err;
4347
4348         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4349         if (spec == NULL)
4350                 return -ENOMEM;
4351
4352         codec->spec = spec;
4353         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4354         spec->pin_nids = stac9200_pin_nids;
4355         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4356                                                         stac9200_models,
4357                                                         stac9200_cfg_tbl);
4358         if (spec->board_config < 0) {
4359                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4360                 err = stac92xx_save_bios_config_regs(codec);
4361         } else
4362                 err = stac_save_pin_cfgs(codec,
4363                                          stac9200_brd_tbl[spec->board_config]);
4364         if (err < 0) {
4365                 stac92xx_free(codec);
4366                 return err;
4367         }
4368
4369         spec->multiout.max_channels = 2;
4370         spec->multiout.num_dacs = 1;
4371         spec->multiout.dac_nids = stac9200_dac_nids;
4372         spec->adc_nids = stac9200_adc_nids;
4373         spec->mux_nids = stac9200_mux_nids;
4374         spec->num_muxes = 1;
4375         spec->num_dmics = 0;
4376         spec->num_adcs = 1;
4377         spec->num_pwrs = 0;
4378
4379         if (spec->board_config == STAC_9200_GATEWAY ||
4380             spec->board_config == STAC_9200_OQO)
4381                 spec->init = stac9200_eapd_init;
4382         else
4383                 spec->init = stac9200_core_init;
4384         spec->mixer = stac9200_mixer;
4385
4386         if (spec->board_config == STAC_9200_PANASONIC) {
4387                 spec->gpio_mask = spec->gpio_dir = 0x09;
4388                 spec->gpio_data = 0x00;
4389         }
4390
4391         err = stac9200_parse_auto_config(codec);
4392         if (err < 0) {
4393                 stac92xx_free(codec);
4394                 return err;
4395         }
4396
4397         codec->patch_ops = stac92xx_patch_ops;
4398
4399         return 0;
4400 }
4401
4402 static int patch_stac925x(struct hda_codec *codec)
4403 {
4404         struct sigmatel_spec *spec;
4405         int err;
4406
4407         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4408         if (spec == NULL)
4409                 return -ENOMEM;
4410
4411         codec->spec = spec;
4412         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4413         spec->pin_nids = stac925x_pin_nids;
4414         spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
4415                                                         stac925x_models,
4416                                                         stac925x_cfg_tbl);
4417  again:
4418         if (spec->board_config < 0) {
4419                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4420                                       "using BIOS defaults\n");
4421                 err = stac92xx_save_bios_config_regs(codec);
4422         } else
4423                 err = stac_save_pin_cfgs(codec,
4424                                          stac925x_brd_tbl[spec->board_config]);
4425         if (err < 0) {
4426                 stac92xx_free(codec);
4427                 return err;
4428         }
4429
4430         spec->multiout.max_channels = 2;
4431         spec->multiout.num_dacs = 1;
4432         spec->multiout.dac_nids = stac925x_dac_nids;
4433         spec->adc_nids = stac925x_adc_nids;
4434         spec->mux_nids = stac925x_mux_nids;
4435         spec->num_muxes = 1;
4436         spec->num_adcs = 1;
4437         spec->num_pwrs = 0;
4438         switch (codec->vendor_id) {
4439         case 0x83847632: /* STAC9202  */
4440         case 0x83847633: /* STAC9202D */
4441         case 0x83847636: /* STAC9251  */
4442         case 0x83847637: /* STAC9251D */
4443                 spec->num_dmics = STAC925X_NUM_DMICS;
4444                 spec->dmic_nids = stac925x_dmic_nids;
4445                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4446                 spec->dmux_nids = stac925x_dmux_nids;
4447                 break;
4448         default:
4449                 spec->num_dmics = 0;
4450                 break;
4451         }
4452
4453         spec->init = stac925x_core_init;
4454         spec->mixer = stac925x_mixer;
4455
4456         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4457         if (!err) {
4458                 if (spec->board_config < 0) {
4459                         printk(KERN_WARNING "hda_codec: No auto-config is "
4460                                "available, default to model=ref\n");
4461                         spec->board_config = STAC_925x_REF;
4462                         goto again;
4463                 }
4464                 err = -EINVAL;
4465         }
4466         if (err < 0) {
4467                 stac92xx_free(codec);
4468                 return err;
4469         }
4470
4471         codec->patch_ops = stac92xx_patch_ops;
4472
4473         return 0;
4474 }
4475
4476 static struct hda_input_mux stac92hd73xx_dmux = {
4477         .num_items = 4,
4478         .items = {
4479                 { "Analog Inputs", 0x0b },
4480                 { "Digital Mic 1", 0x09 },
4481                 { "Digital Mic 2", 0x0a },
4482                 { "CD", 0x08 },
4483         }
4484 };
4485
4486 static int patch_stac92hd73xx(struct hda_codec *codec)
4487 {
4488         struct sigmatel_spec *spec;
4489         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4490         int err = 0;
4491         int num_dacs;
4492
4493         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4494         if (spec == NULL)
4495                 return -ENOMEM;
4496
4497         codec->spec = spec;
4498         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4499         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4500         spec->pin_nids = stac92hd73xx_pin_nids;
4501         spec->board_config = snd_hda_check_board_config(codec,
4502                                                         STAC_92HD73XX_MODELS,
4503                                                         stac92hd73xx_models,
4504                                                         stac92hd73xx_cfg_tbl);
4505 again:
4506         if (spec->board_config < 0) {
4507                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4508                         " STAC92HD73XX, using BIOS defaults\n");
4509                 err = stac92xx_save_bios_config_regs(codec);
4510         } else
4511                 err = stac_save_pin_cfgs(codec,
4512                                 stac92hd73xx_brd_tbl[spec->board_config]);
4513         if (err < 0) {
4514                 stac92xx_free(codec);
4515                 return err;
4516         }
4517
4518         num_dacs = snd_hda_get_connections(codec, 0x0a,
4519                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
4520
4521         if (num_dacs < 3 || num_dacs > 5) {
4522                 printk(KERN_WARNING "hda_codec: Could not determine "
4523                        "number of channels defaulting to DAC count\n");
4524                 num_dacs = STAC92HD73_DAC_COUNT;
4525         }
4526         switch (num_dacs) {
4527         case 0x3: /* 6 Channel */
4528                 spec->mixer = stac92hd73xx_6ch_mixer;
4529                 spec->init = stac92hd73xx_6ch_core_init;
4530                 break;
4531         case 0x4: /* 8 Channel */
4532                 spec->mixer = stac92hd73xx_8ch_mixer;
4533                 spec->init = stac92hd73xx_8ch_core_init;
4534                 break;
4535         case 0x5: /* 10 Channel */
4536                 spec->mixer = stac92hd73xx_10ch_mixer;
4537                 spec->init = stac92hd73xx_10ch_core_init;
4538         }
4539         spec->multiout.dac_nids = spec->dac_nids;
4540
4541         spec->aloopback_mask = 0x01;
4542         spec->aloopback_shift = 8;
4543
4544         spec->digbeep_nid = 0x1c;
4545         spec->mux_nids = stac92hd73xx_mux_nids;
4546         spec->adc_nids = stac92hd73xx_adc_nids;
4547         spec->dmic_nids = stac92hd73xx_dmic_nids;
4548         spec->dmux_nids = stac92hd73xx_dmux_nids;
4549         spec->smux_nids = stac92hd73xx_smux_nids;
4550         spec->amp_nids = stac92hd73xx_amp_nids;
4551         spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4552
4553         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4554         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4555         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4556         memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4557                         sizeof(stac92hd73xx_dmux));
4558
4559         switch (spec->board_config) {
4560         case STAC_DELL_EQ:
4561                 spec->init = dell_eq_core_init;
4562                 /* fallthru */
4563         case STAC_DELL_M6_AMIC:
4564         case STAC_DELL_M6_DMIC:
4565         case STAC_DELL_M6_BOTH:
4566                 spec->num_smuxes = 0;
4567                 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4568                 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4569                 spec->eapd_switch = 0;
4570                 spec->num_amps = 1;
4571
4572                 if (spec->board_config != STAC_DELL_EQ)
4573                         spec->init = dell_m6_core_init;
4574                 switch (spec->board_config) {
4575                 case STAC_DELL_M6_AMIC: /* Analog Mics */
4576                         stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4577                         spec->num_dmics = 0;
4578                         spec->private_dimux.num_items = 1;
4579                         break;
4580                 case STAC_DELL_M6_DMIC: /* Digital Mics */
4581                         stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4582                         spec->num_dmics = 1;
4583                         spec->private_dimux.num_items = 2;
4584                         break;
4585                 case STAC_DELL_M6_BOTH: /* Both */
4586                         stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4587                         stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4588                         spec->num_dmics = 1;
4589                         spec->private_dimux.num_items = 2;
4590                         break;
4591                 }
4592                 break;
4593         default:
4594                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4595                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4596                 spec->eapd_switch = 1;
4597         }
4598         if (spec->board_config > STAC_92HD73XX_REF) {
4599                 /* GPIO0 High = Enable EAPD */
4600                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4601                 spec->gpio_data = 0x01;
4602         }
4603         spec->dinput_mux = &spec->private_dimux;
4604
4605         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4606         spec->pwr_nids = stac92hd73xx_pwr_nids;
4607
4608         err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4609
4610         if (!err) {
4611                 if (spec->board_config < 0) {
4612                         printk(KERN_WARNING "hda_codec: No auto-config is "
4613                                "available, default to model=ref\n");
4614                         spec->board_config = STAC_92HD73XX_REF;
4615                         goto again;
4616                 }
4617                 err = -EINVAL;
4618         }
4619
4620         if (err < 0) {
4621                 stac92xx_free(codec);
4622                 return err;
4623         }
4624
4625         if (spec->board_config == STAC_92HD73XX_NO_JD)
4626                 spec->hp_detect = 0;
4627
4628         codec->patch_ops = stac92xx_patch_ops;
4629
4630         codec->proc_widget_hook = stac92hd7x_proc_hook;
4631
4632         return 0;
4633 }
4634
4635 static struct hda_input_mux stac92hd83xxx_dmux = {
4636         .num_items = 3,
4637         .items = {
4638                 { "Analog Inputs", 0x03 },
4639                 { "Digital Mic 1", 0x04 },
4640                 { "Digital Mic 2", 0x05 },
4641         }
4642 };
4643
4644 static int patch_stac92hd83xxx(struct hda_codec *codec)
4645 {
4646         struct sigmatel_spec *spec;
4647         int err;
4648
4649         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4650         if (spec == NULL)
4651                 return -ENOMEM;
4652
4653         codec->spec = spec;
4654         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4655         spec->mono_nid = 0x19;
4656         spec->digbeep_nid = 0x21;
4657         spec->dmic_nids = stac92hd83xxx_dmic_nids;
4658         spec->dmux_nids = stac92hd83xxx_dmux_nids;
4659         spec->adc_nids = stac92hd83xxx_adc_nids;
4660         spec->pwr_nids = stac92hd83xxx_pwr_nids;
4661         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4662         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4663         spec->multiout.dac_nids = spec->dac_nids;
4664
4665         spec->init = stac92hd83xxx_core_init;
4666         switch (codec->vendor_id) {
4667         case 0x111d7605:
4668                 break;
4669         default:
4670                 spec->num_pwrs--;
4671                 spec->init++; /* switch to config #2 */
4672         }
4673
4674         spec->mixer = stac92hd83xxx_mixer;
4675         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4676         spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4677         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4678         spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4679         spec->dinput_mux = &stac92hd83xxx_dmux;
4680         spec->pin_nids = stac92hd83xxx_pin_nids;
4681         spec->board_config = snd_hda_check_board_config(codec,
4682                                                         STAC_92HD83XXX_MODELS,
4683                                                         stac92hd83xxx_models,
4684                                                         stac92hd83xxx_cfg_tbl);
4685 again:
4686         if (spec->board_config < 0) {
4687                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4688                         " STAC92HD83XXX, using BIOS defaults\n");
4689                 err = stac92xx_save_bios_config_regs(codec);
4690         } else
4691                 err = stac_save_pin_cfgs(codec,
4692                                 stac92hd83xxx_brd_tbl[spec->board_config]);
4693         if (err < 0) {
4694                 stac92xx_free(codec);
4695                 return err;
4696         }
4697
4698         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4699         if (!err) {
4700                 if (spec->board_config < 0) {
4701                         printk(KERN_WARNING "hda_codec: No auto-config is "
4702                                "available, default to model=ref\n");
4703                         spec->board_config = STAC_92HD83XXX_REF;
4704                         goto again;
4705                 }
4706                 err = -EINVAL;
4707         }
4708
4709         if (err < 0) {
4710                 stac92xx_free(codec);
4711                 return err;
4712         }
4713
4714         codec->patch_ops = stac92xx_patch_ops;
4715
4716         codec->proc_widget_hook = stac92hd_proc_hook;
4717
4718         return 0;
4719 }
4720
4721 static struct hda_input_mux stac92hd71bxx_dmux = {
4722         .num_items = 4,
4723         .items = {
4724                 { "Analog Inputs", 0x00 },
4725                 { "Mixer", 0x01 },
4726                 { "Digital Mic 1", 0x02 },
4727                 { "Digital Mic 2", 0x03 },
4728         }
4729 };
4730
4731 static int patch_stac92hd71bxx(struct hda_codec *codec)
4732 {
4733         struct sigmatel_spec *spec;
4734         int err = 0;
4735
4736         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4737         if (spec == NULL)
4738                 return -ENOMEM;
4739
4740         codec->spec = spec;
4741         codec->patch_ops = stac92xx_patch_ops;
4742         spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4743         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4744         spec->pin_nids = stac92hd71bxx_pin_nids;
4745         memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4746                         sizeof(stac92hd71bxx_dmux));
4747         spec->board_config = snd_hda_check_board_config(codec,
4748                                                         STAC_92HD71BXX_MODELS,
4749                                                         stac92hd71bxx_models,
4750                                                         stac92hd71bxx_cfg_tbl);
4751 again:
4752         if (spec->board_config < 0) {
4753                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4754                         " STAC92HD71BXX, using BIOS defaults\n");
4755                 err = stac92xx_save_bios_config_regs(codec);
4756         } else
4757                 err = stac_save_pin_cfgs(codec,
4758                                 stac92hd71bxx_brd_tbl[spec->board_config]);
4759         if (err < 0) {
4760                 stac92xx_free(codec);
4761                 return err;
4762         }
4763
4764         if (spec->board_config > STAC_92HD71BXX_REF) {
4765                 /* GPIO0 = EAPD */
4766                 spec->gpio_mask = 0x01;
4767                 spec->gpio_dir = 0x01;
4768                 spec->gpio_data = 0x01;
4769         }
4770
4771         switch (codec->vendor_id) {
4772         case 0x111d76b6: /* 4 Port without Analog Mixer */
4773         case 0x111d76b7:
4774         case 0x111d76b4: /* 6 Port without Analog Mixer */
4775         case 0x111d76b5:
4776                 spec->mixer = stac92hd71bxx_mixer;
4777                 spec->init = stac92hd71bxx_core_init;
4778                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4779                 break;
4780         case 0x111d7608: /* 5 Port with Analog Mixer */
4781                 switch (spec->board_config) {
4782                 case STAC_HP_M4:
4783                         /* Enable VREF power saving on GPIO1 detect */
4784                         err = stac_add_event(spec, codec->afg,
4785                                              STAC_VREF_EVENT, 0x02);
4786                         if (err < 0)
4787                                 return err;
4788                         snd_hda_codec_write_cache(codec, codec->afg, 0,
4789                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4790                         snd_hda_codec_write_cache(codec, codec->afg, 0,
4791                                 AC_VERB_SET_UNSOLICITED_ENABLE,
4792                                 AC_USRSP_EN | err);
4793                         spec->gpio_mask |= 0x02;
4794                         break;
4795                 }
4796                 if ((codec->revision_id & 0xf) == 0 ||
4797                     (codec->revision_id & 0xf) == 1)
4798                         spec->stream_delay = 40; /* 40 milliseconds */
4799
4800                 /* no output amps */
4801                 spec->num_pwrs = 0;
4802                 spec->mixer = stac92hd71bxx_analog_mixer;
4803                 spec->dinput_mux = &spec->private_dimux;
4804
4805                 /* disable VSW */
4806                 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4807                 stac_change_pin_config(codec, 0xf, 0x40f000f0);
4808                 break;
4809         case 0x111d7603: /* 6 Port with Analog Mixer */
4810                 if ((codec->revision_id & 0xf) == 1)
4811                         spec->stream_delay = 40; /* 40 milliseconds */
4812
4813                 /* no output amps */
4814                 spec->num_pwrs = 0;
4815                 /* fallthru */
4816         default:
4817                 spec->dinput_mux = &spec->private_dimux;
4818                 spec->mixer = stac92hd71bxx_analog_mixer;
4819                 spec->init = stac92hd71bxx_analog_core_init;
4820                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4821         }
4822
4823         spec->aloopback_mask = 0x50;
4824         spec->aloopback_shift = 0;
4825
4826         spec->powerdown_adcs = 1;
4827         spec->digbeep_nid = 0x26;
4828         spec->mux_nids = stac92hd71bxx_mux_nids;
4829         spec->adc_nids = stac92hd71bxx_adc_nids;
4830         spec->dmic_nids = stac92hd71bxx_dmic_nids;
4831         spec->dmux_nids = stac92hd71bxx_dmux_nids;
4832         spec->smux_nids = stac92hd71bxx_smux_nids;
4833         spec->pwr_nids = stac92hd71bxx_pwr_nids;
4834
4835         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4836         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4837
4838         switch (spec->board_config) {
4839         case STAC_HP_M4:
4840                 /* enable internal microphone */
4841                 stac_change_pin_config(codec, 0x0e, 0x01813040);
4842                 stac92xx_auto_set_pinctl(codec, 0x0e,
4843                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4844                 /* fallthru */
4845         case STAC_DELL_M4_2:
4846                 spec->num_dmics = 0;
4847                 spec->num_smuxes = 0;
4848                 spec->num_dmuxes = 0;
4849                 break;
4850         case STAC_DELL_M4_1:
4851         case STAC_DELL_M4_3:
4852                 spec->num_dmics = 1;
4853                 spec->num_smuxes = 0;
4854                 spec->num_dmuxes = 0;
4855                 break;
4856         default:
4857                 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4858                 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4859                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4860         };
4861
4862         spec->multiout.dac_nids = spec->dac_nids;
4863         if (spec->dinput_mux)
4864                 spec->private_dimux.num_items +=
4865                         spec->num_dmics -
4866                                 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4867
4868         err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4869         if (!err) {
4870                 if (spec->board_config < 0) {
4871                         printk(KERN_WARNING "hda_codec: No auto-config is "
4872                                "available, default to model=ref\n");
4873                         spec->board_config = STAC_92HD71BXX_REF;
4874                         goto again;
4875                 }
4876                 err = -EINVAL;
4877         }
4878
4879         if (err < 0) {
4880                 stac92xx_free(codec);
4881                 return err;
4882         }
4883
4884         codec->proc_widget_hook = stac92hd7x_proc_hook;
4885
4886         return 0;
4887 };
4888
4889 static int patch_stac922x(struct hda_codec *codec)
4890 {
4891         struct sigmatel_spec *spec;
4892         int err;
4893
4894         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4895         if (spec == NULL)
4896                 return -ENOMEM;
4897
4898         codec->spec = spec;
4899         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
4900         spec->pin_nids = stac922x_pin_nids;
4901         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
4902                                                         stac922x_models,
4903                                                         stac922x_cfg_tbl);
4904         if (spec->board_config == STAC_INTEL_MAC_AUTO) {
4905                 spec->gpio_mask = spec->gpio_dir = 0x03;
4906                 spec->gpio_data = 0x03;
4907                 /* Intel Macs have all same PCI SSID, so we need to check
4908                  * codec SSID to distinguish the exact models
4909                  */
4910                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
4911                 switch (codec->subsystem_id) {
4912
4913                 case 0x106b0800:
4914                         spec->board_config = STAC_INTEL_MAC_V1;
4915                         break;
4916                 case 0x106b0600:
4917                 case 0x106b0700:
4918                         spec->board_config = STAC_INTEL_MAC_V2;
4919                         break;
4920                 case 0x106b0e00:
4921                 case 0x106b0f00:
4922                 case 0x106b1600:
4923                 case 0x106b1700:
4924                 case 0x106b0200:
4925                 case 0x106b1e00:
4926                         spec->board_config = STAC_INTEL_MAC_V3;
4927                         break;
4928                 case 0x106b1a00:
4929                 case 0x00000100:
4930                         spec->board_config = STAC_INTEL_MAC_V4;
4931                         break;
4932                 case 0x106b0a00:
4933                 case 0x106b2200:
4934                         spec->board_config = STAC_INTEL_MAC_V5;
4935                         break;
4936                 default:
4937                         spec->board_config = STAC_INTEL_MAC_V3;
4938                         break;
4939                 }
4940         }
4941
4942  again:
4943         if (spec->board_config < 0) {
4944                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
4945                         "using BIOS defaults\n");
4946                 err = stac92xx_save_bios_config_regs(codec);
4947         } else
4948                 err = stac_save_pin_cfgs(codec,
4949                                 stac922x_brd_tbl[spec->board_config]);
4950         if (err < 0) {
4951                 stac92xx_free(codec);
4952                 return err;
4953         }
4954
4955         spec->adc_nids = stac922x_adc_nids;
4956         spec->mux_nids = stac922x_mux_nids;
4957         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
4958         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
4959         spec->num_dmics = 0;
4960         spec->num_pwrs = 0;
4961
4962         spec->init = stac922x_core_init;
4963         spec->mixer = stac922x_mixer;
4964
4965         spec->multiout.dac_nids = spec->dac_nids;
4966
4967         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
4968         if (!err) {
4969                 if (spec->board_config < 0) {
4970                         printk(KERN_WARNING "hda_codec: No auto-config is "
4971                                "available, default to model=ref\n");
4972                         spec->board_config = STAC_D945_REF;
4973                         goto again;
4974                 }
4975                 err = -EINVAL;
4976         }
4977         if (err < 0) {
4978                 stac92xx_free(codec);
4979                 return err;
4980         }
4981
4982         codec->patch_ops = stac92xx_patch_ops;
4983
4984         /* Fix Mux capture level; max to 2 */
4985         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
4986                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
4987                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4988                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4989                                   (0 << AC_AMPCAP_MUTE_SHIFT));
4990
4991         return 0;
4992 }
4993
4994 static int patch_stac927x(struct hda_codec *codec)
4995 {
4996         struct sigmatel_spec *spec;
4997         int err;
4998
4999         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5000         if (spec == NULL)
5001                 return -ENOMEM;
5002
5003         codec->spec = spec;
5004         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5005         spec->pin_nids = stac927x_pin_nids;
5006         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5007                                                         stac927x_models,
5008                                                         stac927x_cfg_tbl);
5009  again:
5010         if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
5011                 if (spec->board_config < 0)
5012                         snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5013                                     "STAC927x, using BIOS defaults\n");
5014                 err = stac92xx_save_bios_config_regs(codec);
5015         } else
5016                 err = stac_save_pin_cfgs(codec,
5017                                 stac927x_brd_tbl[spec->board_config]);
5018         if (err < 0) {
5019                 stac92xx_free(codec);
5020                 return err;
5021         }
5022
5023         spec->digbeep_nid = 0x23;
5024         spec->adc_nids = stac927x_adc_nids;
5025         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5026         spec->mux_nids = stac927x_mux_nids;
5027         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5028         spec->smux_nids = stac927x_smux_nids;
5029         spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5030         spec->spdif_labels = stac927x_spdif_labels;
5031         spec->dac_list = stac927x_dac_nids;
5032         spec->multiout.dac_nids = spec->dac_nids;
5033
5034         switch (spec->board_config) {
5035         case STAC_D965_3ST:
5036         case STAC_D965_5ST:
5037                 /* GPIO0 High = Enable EAPD */
5038                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5039                 spec->gpio_data = 0x01;
5040                 spec->num_dmics = 0;
5041
5042                 spec->init = d965_core_init;
5043                 spec->mixer = stac927x_mixer;
5044                 break;
5045         case STAC_DELL_BIOS:
5046                 switch (codec->subsystem_id) {
5047                 case 0x10280209:
5048                 case 0x1028022e:
5049                         /* correct the device field to SPDIF out */
5050                         stac_change_pin_config(codec, 0x21, 0x01442070);
5051                         break;
5052                 };
5053                 /* configure the analog microphone on some laptops */
5054                 stac_change_pin_config(codec, 0x0c, 0x90a79130);
5055                 /* correct the front output jack as a hp out */
5056                 stac_change_pin_config(codec, 0x0f, 0x0227011f);
5057                 /* correct the front input jack as a mic */
5058                 stac_change_pin_config(codec, 0x0e, 0x02a79130);
5059                 /* fallthru */
5060         case STAC_DELL_3ST:
5061                 /* GPIO2 High = Enable EAPD */
5062                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5063                 spec->gpio_data = 0x04;
5064                 spec->dmic_nids = stac927x_dmic_nids;
5065                 spec->num_dmics = STAC927X_NUM_DMICS;
5066
5067                 spec->init = d965_core_init;
5068                 spec->mixer = stac927x_mixer;
5069                 spec->dmux_nids = stac927x_dmux_nids;
5070                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5071                 break;
5072         default:
5073                 if (spec->board_config > STAC_D965_REF) {
5074                         /* GPIO0 High = Enable EAPD */
5075                         spec->eapd_mask = spec->gpio_mask = 0x01;
5076                         spec->gpio_dir = spec->gpio_data = 0x01;
5077                 }
5078                 spec->num_dmics = 0;
5079
5080                 spec->init = stac927x_core_init;
5081                 spec->mixer = stac927x_mixer;
5082         }
5083
5084         spec->num_pwrs = 0;
5085         spec->aloopback_mask = 0x40;
5086         spec->aloopback_shift = 0;
5087         spec->eapd_switch = 1;
5088
5089         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5090         if (!err) {
5091                 if (spec->board_config < 0) {
5092                         printk(KERN_WARNING "hda_codec: No auto-config is "
5093                                "available, default to model=ref\n");
5094                         spec->board_config = STAC_D965_REF;
5095                         goto again;
5096                 }
5097                 err = -EINVAL;
5098         }
5099         if (err < 0) {
5100                 stac92xx_free(codec);
5101                 return err;
5102         }
5103
5104         codec->patch_ops = stac92xx_patch_ops;
5105
5106         codec->proc_widget_hook = stac927x_proc_hook;
5107
5108         /*
5109          * !!FIXME!!
5110          * The STAC927x seem to require fairly long delays for certain
5111          * command sequences.  With too short delays (even if the answer
5112          * is set to RIRB properly), it results in the silence output
5113          * on some hardwares like Dell.
5114          *
5115          * The below flag enables the longer delay (see get_response
5116          * in hda_intel.c).
5117          */
5118         codec->bus->needs_damn_long_delay = 1;
5119
5120         /* no jack detecion for ref-no-jd model */
5121         if (spec->board_config == STAC_D965_REF_NO_JD)
5122                 spec->hp_detect = 0;
5123
5124         return 0;
5125 }
5126
5127 static int patch_stac9205(struct hda_codec *codec)
5128 {
5129         struct sigmatel_spec *spec;
5130         int err;
5131
5132         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5133         if (spec == NULL)
5134                 return -ENOMEM;
5135
5136         codec->spec = spec;
5137         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5138         spec->pin_nids = stac9205_pin_nids;
5139         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5140                                                         stac9205_models,
5141                                                         stac9205_cfg_tbl);
5142  again:
5143         if (spec->board_config < 0) {
5144                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5145                 err = stac92xx_save_bios_config_regs(codec);
5146         } else
5147                 err = stac_save_pin_cfgs(codec,
5148                                          stac9205_brd_tbl[spec->board_config]);
5149         if (err < 0) {
5150                 stac92xx_free(codec);
5151                 return err;
5152         }
5153
5154         spec->digbeep_nid = 0x23;
5155         spec->adc_nids = stac9205_adc_nids;
5156         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5157         spec->mux_nids = stac9205_mux_nids;
5158         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5159         spec->smux_nids = stac9205_smux_nids;
5160         spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5161         spec->dmic_nids = stac9205_dmic_nids;
5162         spec->num_dmics = STAC9205_NUM_DMICS;
5163         spec->dmux_nids = stac9205_dmux_nids;
5164         spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5165         spec->num_pwrs = 0;
5166
5167         spec->init = stac9205_core_init;
5168         spec->mixer = stac9205_mixer;
5169
5170         spec->aloopback_mask = 0x40;
5171         spec->aloopback_shift = 0;
5172         spec->eapd_switch = 1;
5173         spec->multiout.dac_nids = spec->dac_nids;
5174
5175         switch (spec->board_config){
5176         case STAC_9205_DELL_M43:
5177                 /* Enable SPDIF in/out */
5178                 stac_change_pin_config(codec, 0x1f, 0x01441030);
5179                 stac_change_pin_config(codec, 0x20, 0x1c410030);
5180
5181                 /* Enable unsol response for GPIO4/Dock HP connection */
5182                 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5183                 if (err < 0)
5184                         return err;
5185                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5186                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5187                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5188                                           AC_VERB_SET_UNSOLICITED_ENABLE,
5189                                           AC_USRSP_EN | err);
5190
5191                 spec->gpio_dir = 0x0b;
5192                 spec->eapd_mask = 0x01;
5193                 spec->gpio_mask = 0x1b;
5194                 spec->gpio_mute = 0x10;
5195                 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5196                  * GPIO3 Low = DRM
5197                  */
5198                 spec->gpio_data = 0x01;
5199                 break;
5200         case STAC_9205_REF:
5201                 /* SPDIF-In enabled */
5202                 break;
5203         default:
5204                 /* GPIO0 High = EAPD */
5205                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5206                 spec->gpio_data = 0x01;
5207                 break;
5208         }
5209
5210         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5211         if (!err) {
5212                 if (spec->board_config < 0) {
5213                         printk(KERN_WARNING "hda_codec: No auto-config is "
5214                                "available, default to model=ref\n");
5215                         spec->board_config = STAC_9205_REF;
5216                         goto again;
5217                 }
5218                 err = -EINVAL;
5219         }
5220         if (err < 0) {
5221                 stac92xx_free(codec);
5222                 return err;
5223         }
5224
5225         codec->patch_ops = stac92xx_patch_ops;
5226
5227         codec->proc_widget_hook = stac9205_proc_hook;
5228
5229         return 0;
5230 }
5231
5232 /*
5233  * STAC9872 hack
5234  */
5235
5236 /* static config for Sony VAIO FE550G and Sony VAIO AR */
5237 static hda_nid_t vaio_dacs[] = { 0x2 };
5238 #define VAIO_HP_DAC     0x5
5239 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
5240 static hda_nid_t vaio_mux_nids[] = { 0x15 };
5241
5242 static struct hda_input_mux vaio_mux = {
5243         .num_items = 3,
5244         .items = {
5245                 /* { "HP", 0x0 }, */
5246                 { "Mic Jack", 0x1 },
5247                 { "Internal Mic", 0x2 },
5248                 { "PCM", 0x3 },
5249         }
5250 };
5251
5252 static struct hda_verb vaio_init[] = {
5253         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5254         {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
5255         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5256         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5257         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5258         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5259         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5260         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5261         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5262         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5263         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5264         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5265         {}
5266 };
5267
5268 static struct hda_verb vaio_ar_init[] = {
5269         {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5270         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5271         {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5272         {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5273 /*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
5274         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5275         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5276         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5277         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5278 /*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
5279         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5281         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5282         {}
5283 };
5284
5285 static struct snd_kcontrol_new vaio_mixer[] = {
5286         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5287         HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5288         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5289         HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5290         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5291         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5292         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5293         {
5294                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5295                 .name = "Capture Source",
5296                 .count = 1,
5297                 .info = stac92xx_mux_enum_info,
5298                 .get = stac92xx_mux_enum_get,
5299                 .put = stac92xx_mux_enum_put,
5300         },
5301         {}
5302 };
5303
5304 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5305         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5306         HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5307         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5308         HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5309         /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5310         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5311         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5312         /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5313         HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5314         {
5315                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5316                 .name = "Capture Source",
5317                 .count = 1,
5318                 .info = stac92xx_mux_enum_info,
5319                 .get = stac92xx_mux_enum_get,
5320                 .put = stac92xx_mux_enum_put,
5321         },
5322         {}
5323 };
5324
5325 static struct hda_codec_ops stac9872_patch_ops = {
5326         .build_controls = stac92xx_build_controls,
5327         .build_pcms = stac92xx_build_pcms,
5328         .init = stac92xx_init,
5329         .free = stac92xx_free,
5330 #ifdef SND_HDA_NEEDS_RESUME
5331         .resume = stac92xx_resume,
5332 #endif
5333 };
5334
5335 static int stac9872_vaio_init(struct hda_codec *codec)
5336 {
5337         int err;
5338
5339         err = stac92xx_init(codec);
5340         if (err < 0)
5341                 return err;
5342         if (codec->patch_ops.unsol_event)
5343                 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5344         return 0;
5345 }
5346
5347 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5348 {
5349         if (get_pin_presence(codec, 0x0a)) {
5350                 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5351                 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5352         } else {
5353                 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5354                 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5355         }
5356 }
5357
5358 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5359 {
5360         switch (res >> 26) {
5361         case STAC_HP_EVENT:
5362                 stac9872_vaio_hp_detect(codec, res);
5363                 break;
5364         }
5365 }
5366
5367 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5368         .build_controls = stac92xx_build_controls,
5369         .build_pcms = stac92xx_build_pcms,
5370         .init = stac9872_vaio_init,
5371         .free = stac92xx_free,
5372         .unsol_event = stac9872_vaio_unsol_event,
5373 #ifdef CONFIG_PM
5374         .resume = stac92xx_resume,
5375 #endif
5376 };
5377
5378 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5379        CXD9872RD_VAIO,
5380        /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5381        STAC9872AK_VAIO,
5382        /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5383        STAC9872K_VAIO,
5384        /* AR Series. id=0x83847664 and subsys=104D1300 */
5385        CXD9872AKD_VAIO,
5386        STAC_9872_MODELS,
5387 };
5388
5389 static const char *stac9872_models[STAC_9872_MODELS] = {
5390         [CXD9872RD_VAIO]        = "vaio",
5391         [CXD9872AKD_VAIO]       = "vaio-ar",
5392 };
5393
5394 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5395         SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5396         SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5397         SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5398         SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5399         {}
5400 };
5401
5402 static int patch_stac9872(struct hda_codec *codec)
5403 {
5404         struct sigmatel_spec *spec;
5405         int board_config;
5406
5407         board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5408                                                   stac9872_models,
5409                                                   stac9872_cfg_tbl);
5410         if (board_config < 0)
5411                 /* unknown config, let generic-parser do its job... */
5412                 return snd_hda_parse_generic_codec(codec);
5413
5414         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5415         if (spec == NULL)
5416                 return -ENOMEM;
5417
5418         codec->spec = spec;
5419         switch (board_config) {
5420         case CXD9872RD_VAIO:
5421         case STAC9872AK_VAIO:
5422         case STAC9872K_VAIO:
5423                 spec->mixer = vaio_mixer;
5424                 spec->init = vaio_init;
5425                 spec->multiout.max_channels = 2;
5426                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5427                 spec->multiout.dac_nids = vaio_dacs;
5428                 spec->multiout.hp_nid = VAIO_HP_DAC;
5429                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5430                 spec->adc_nids = vaio_adcs;
5431                 spec->num_pwrs = 0;
5432                 spec->input_mux = &vaio_mux;
5433                 spec->mux_nids = vaio_mux_nids;
5434                 codec->patch_ops = stac9872_vaio_patch_ops;
5435                 break;
5436
5437         case CXD9872AKD_VAIO:
5438                 spec->mixer = vaio_ar_mixer;
5439                 spec->init = vaio_ar_init;
5440                 spec->multiout.max_channels = 2;
5441                 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5442                 spec->multiout.dac_nids = vaio_dacs;
5443                 spec->multiout.hp_nid = VAIO_HP_DAC;
5444                 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5445                 spec->num_pwrs = 0;
5446                 spec->adc_nids = vaio_adcs;
5447                 spec->input_mux = &vaio_mux;
5448                 spec->mux_nids = vaio_mux_nids;
5449                 codec->patch_ops = stac9872_patch_ops;
5450                 break;
5451         }
5452
5453         return 0;
5454 }
5455
5456
5457 /*
5458  * patch entries
5459  */
5460 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5461         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5462         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5463         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5464         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5465         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5466         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5467         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5468         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5469         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5470         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5471         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5472         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5473         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5474         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5475         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5476         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5477         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5478         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5479         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5480         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5481         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5482         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5483         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5484         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
5485         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5486         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5487         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5488         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5489         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5490         { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5491         { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5492         /* The following does not take into account .id=0x83847661 when subsys =
5493          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5494          * currently not fully supported.
5495          */
5496         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5497         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5498         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5499         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5500         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5501         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5502         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5503         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5504         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5505         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5506         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5507         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5508         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5509         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5510         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5511         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5512         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5513         { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5514         { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5515         { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5516         { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5517         { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5518         { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5519         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5520         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5521         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5522         {} /* terminator */
5523 };
5524
5525 MODULE_ALIAS("snd-hda-codec-id:8384*");
5526 MODULE_ALIAS("snd-hda-codec-id:111d*");
5527
5528 MODULE_LICENSE("GPL");
5529 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5530
5531 static struct hda_codec_preset_list sigmatel_list = {
5532         .preset = snd_hda_preset_sigmatel,
5533         .owner = THIS_MODULE,
5534 };
5535
5536 static int __init patch_sigmatel_init(void)
5537 {
5538         return snd_hda_add_codec_preset(&sigmatel_list);
5539 }
5540
5541 static void __exit patch_sigmatel_exit(void)
5542 {
5543         snd_hda_delete_codec_preset(&sigmatel_list);
5544 }
5545
5546 module_init(patch_sigmatel_init)
5547 module_exit(patch_sigmatel_exit)