sound/pci/hda/patch_sigmatel.c

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