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