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_param_read(codec, nid,
2541                                                  AC_PAR_PIN_CAP);
2542         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2543         if (pincap & AC_PINCAP_VREF_100)
2544                 return AC_PINCTL_VREF_100;
2545         if (pincap & AC_PINCAP_VREF_80)
2546                 return AC_PINCTL_VREF_80;
2547         if (pincap & AC_PINCAP_VREF_50)
2548                 return AC_PINCTL_VREF_50;
2549         if (pincap & AC_PINCAP_VREF_GRD)
2550                 return AC_PINCTL_VREF_GRD;
2551         return 0;
2552 }
2553
2554 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2555
2556 {
2557         snd_hda_codec_write_cache(codec, nid, 0,
2558                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2559 }
2560
2561 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2562
2563 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2564                         struct snd_ctl_elem_value *ucontrol)
2565 {
2566         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2567         struct sigmatel_spec *spec = codec->spec;
2568
2569         ucontrol->value.integer.value[0] = !!spec->hp_switch;
2570         return 0;
2571 }
2572
2573 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2574                                    unsigned char type);
2575
2576 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2577                         struct snd_ctl_elem_value *ucontrol)
2578 {
2579         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2580         struct sigmatel_spec *spec = codec->spec;
2581         int nid = kcontrol->private_value;
2582
2583         spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2584
2585         /* check to be sure that the ports are upto date with
2586          * switch changes
2587          */
2588         stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2589
2590         return 1;
2591 }
2592
2593 #define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
2594
2595 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2596 {
2597         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2598         struct sigmatel_spec *spec = codec->spec;
2599         int io_idx = kcontrol-> private_value & 0xff;
2600
2601         ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2602         return 0;
2603 }
2604
2605 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2606 {
2607         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2608         struct sigmatel_spec *spec = codec->spec;
2609         hda_nid_t nid = kcontrol->private_value >> 8;
2610         int io_idx = kcontrol-> private_value & 0xff;
2611         unsigned short val = !!ucontrol->value.integer.value[0];
2612
2613         spec->io_switch[io_idx] = val;
2614
2615         if (val)
2616                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2617         else {
2618                 unsigned int pinctl = AC_PINCTL_IN_EN;
2619                 if (io_idx) /* set VREF for mic */
2620                         pinctl |= stac92xx_get_vref(codec, nid);
2621                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2622         }
2623
2624         /* check the auto-mute again: we need to mute/unmute the speaker
2625          * appropriately according to the pin direction
2626          */
2627         if (spec->hp_detect)
2628                 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2629
2630         return 1;
2631 }
2632
2633 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2634
2635 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2636                 struct snd_ctl_elem_value *ucontrol)
2637 {
2638         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2639         struct sigmatel_spec *spec = codec->spec;
2640
2641         ucontrol->value.integer.value[0] = spec->clfe_swap;
2642         return 0;
2643 }
2644
2645 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2646                 struct snd_ctl_elem_value *ucontrol)
2647 {
2648         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2649         struct sigmatel_spec *spec = codec->spec;
2650         hda_nid_t nid = kcontrol->private_value & 0xff;
2651         unsigned int val = !!ucontrol->value.integer.value[0];
2652
2653         if (spec->clfe_swap == val)
2654                 return 0;
2655
2656         spec->clfe_swap = val;
2657
2658         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2659                 spec->clfe_swap ? 0x4 : 0x0);
2660
2661         return 1;
2662 }
2663
2664 #define STAC_CODEC_HP_SWITCH(xname) \
2665         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2666           .name = xname, \
2667           .index = 0, \
2668           .info = stac92xx_hp_switch_info, \
2669           .get = stac92xx_hp_switch_get, \
2670           .put = stac92xx_hp_switch_put, \
2671         }
2672
2673 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2674         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2675           .name = xname, \
2676           .index = 0, \
2677           .info = stac92xx_io_switch_info, \
2678           .get = stac92xx_io_switch_get, \
2679           .put = stac92xx_io_switch_put, \
2680           .private_value = xpval, \
2681         }
2682
2683 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2684         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2685           .name = xname, \
2686           .index = 0, \
2687           .info = stac92xx_clfe_switch_info, \
2688           .get = stac92xx_clfe_switch_get, \
2689           .put = stac92xx_clfe_switch_put, \
2690           .private_value = xpval, \
2691         }
2692
2693 enum {
2694         STAC_CTL_WIDGET_VOL,
2695         STAC_CTL_WIDGET_MUTE,
2696         STAC_CTL_WIDGET_MONO_MUX,
2697         STAC_CTL_WIDGET_AMP_MUX,
2698         STAC_CTL_WIDGET_AMP_VOL,
2699         STAC_CTL_WIDGET_HP_SWITCH,
2700         STAC_CTL_WIDGET_IO_SWITCH,
2701         STAC_CTL_WIDGET_CLFE_SWITCH
2702 };
2703
2704 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2705         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2706         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2707         STAC_MONO_MUX,
2708         STAC_AMP_MUX,
2709         STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2710         STAC_CODEC_HP_SWITCH(NULL),
2711         STAC_CODEC_IO_SWITCH(NULL, 0),
2712         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2713 };
2714
2715 /* add dynamic controls */
2716 static struct snd_kcontrol_new *
2717 stac_control_new(struct sigmatel_spec *spec,
2718                  struct snd_kcontrol_new *ktemp,
2719                  const char *name)
2720 {
2721         struct snd_kcontrol_new *knew;
2722
2723         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2724         knew = snd_array_new(&spec->kctls);
2725         if (!knew)
2726                 return NULL;
2727         *knew = *ktemp;
2728         knew->name = kstrdup(name, GFP_KERNEL);
2729         if (!knew->name) {
2730                 /* roolback */
2731                 memset(knew, 0, sizeof(*knew));
2732                 spec->kctls.alloced--;
2733                 return NULL;
2734         }
2735         return knew;
2736 }
2737
2738 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2739                                      struct snd_kcontrol_new *ktemp,
2740                                      int idx, const char *name,
2741                                      unsigned long val)
2742 {
2743         struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name);
2744         if (!knew)
2745                 return -ENOMEM;
2746         knew->index = idx;
2747         knew->private_value = val;
2748         return 0;
2749 }
2750
2751 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2752                                            int type, int idx, const char *name,
2753                                            unsigned long val)
2754 {
2755         return stac92xx_add_control_temp(spec,
2756                                          &stac92xx_control_templates[type],
2757                                          idx, name, val);
2758 }
2759
2760
2761 /* add dynamic controls */
2762 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2763                                        const char *name, unsigned long val)
2764 {
2765         return stac92xx_add_control_idx(spec, type, 0, name, val);
2766 }
2767
2768 static struct snd_kcontrol_new stac_input_src_temp = {
2769         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2770         .name = "Input Source",
2771         .info = stac92xx_mux_enum_info,
2772         .get = stac92xx_mux_enum_get,
2773         .put = stac92xx_mux_enum_put,
2774 };
2775
2776 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2777 {
2778         struct snd_kcontrol_new *knew;
2779         struct hda_input_mux *imux = &spec->private_imux;
2780
2781         if (!spec->num_adcs || imux->num_items <= 1)
2782                 return 0; /* no need for input source control */
2783         knew = stac_control_new(spec, &stac_input_src_temp,
2784                                 stac_input_src_temp.name);
2785         if (!knew)
2786                 return -ENOMEM;
2787         knew->count = spec->num_adcs;
2788         return 0;
2789 }
2790
2791 /* check whether the line-input can be used as line-out */
2792 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2793 {
2794         struct sigmatel_spec *spec = codec->spec;
2795         struct auto_pin_cfg *cfg = &spec->autocfg;
2796         hda_nid_t nid;
2797         unsigned int pincap;
2798
2799         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2800                 return 0;
2801         nid = cfg->input_pins[AUTO_PIN_LINE];
2802         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2803         if (pincap & AC_PINCAP_OUT)
2804                 return nid;
2805         return 0;
2806 }
2807
2808 /* check whether the mic-input can be used as line-out */
2809 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2810 {
2811         struct sigmatel_spec *spec = codec->spec;
2812         struct auto_pin_cfg *cfg = &spec->autocfg;
2813         unsigned int def_conf, pincap;
2814         unsigned int mic_pin;
2815
2816         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2817                 return 0;
2818         mic_pin = AUTO_PIN_MIC;
2819         for (;;) {
2820                 hda_nid_t nid = cfg->input_pins[mic_pin];
2821                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2822                 /* some laptops have an internal analog microphone
2823                  * which can't be used as a output */
2824                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2825                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2826                         if (pincap & AC_PINCAP_OUT)
2827                                 return nid;
2828                 }
2829                 if (mic_pin == AUTO_PIN_MIC)
2830                         mic_pin = AUTO_PIN_FRONT_MIC;
2831                 else
2832                         break;
2833         }
2834         return 0;
2835 }
2836
2837 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2838 {
2839         int i;
2840
2841         for (i = 0; i < spec->multiout.num_dacs; i++) {
2842                 if (spec->multiout.dac_nids[i] == nid)
2843                         return 1;
2844         }
2845
2846         return 0;
2847 }
2848
2849 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2850 {
2851         int i;
2852         if (is_in_dac_nids(spec, nid))
2853                 return 1;
2854         for (i = 0; i < spec->autocfg.hp_outs; i++)
2855                 if (spec->hp_dacs[i] == nid)
2856                         return 1;
2857         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2858                 if (spec->speaker_dacs[i] == nid)
2859                         return 1;
2860         return 0;
2861 }
2862
2863 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2864 {
2865         struct sigmatel_spec *spec = codec->spec;
2866         int j, conn_len;
2867         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2868         unsigned int wcaps, wtype;
2869
2870         conn_len = snd_hda_get_connections(codec, nid, conn,
2871                                            HDA_MAX_CONNECTIONS);
2872         for (j = 0; j < conn_len; j++) {
2873                 wcaps = snd_hda_param_read(codec, conn[j],
2874                                            AC_PAR_AUDIO_WIDGET_CAP);
2875                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2876                 /* we check only analog outputs */
2877                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2878                         continue;
2879                 /* if this route has a free DAC, assign it */
2880                 if (!check_all_dac_nids(spec, conn[j])) {
2881                         if (conn_len > 1) {
2882                                 /* select this DAC in the pin's input mux */
2883                                 snd_hda_codec_write_cache(codec, nid, 0,
2884                                                   AC_VERB_SET_CONNECT_SEL, j);
2885                         }
2886                         return conn[j];
2887                 }
2888         }
2889         /* if all DACs are already assigned, connect to the primary DAC */
2890         if (conn_len > 1) {
2891                 for (j = 0; j < conn_len; j++) {
2892                         if (conn[j] == spec->multiout.dac_nids[0]) {
2893                                 snd_hda_codec_write_cache(codec, nid, 0,
2894                                                   AC_VERB_SET_CONNECT_SEL, j);
2895                                 break;
2896                         }
2897                 }
2898         }
2899         return 0;
2900 }
2901
2902 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2903 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2904
2905 /*
2906  * Fill in the dac_nids table from the parsed pin configuration
2907  * This function only works when every pin in line_out_pins[]
2908  * contains atleast one DAC in its connection list. Some 92xx
2909  * codecs are not connected directly to a DAC, such as the 9200
2910  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2911  */
2912 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2913 {
2914         struct sigmatel_spec *spec = codec->spec;
2915         struct auto_pin_cfg *cfg = &spec->autocfg;
2916         int i;
2917         hda_nid_t nid, dac;
2918
2919         for (i = 0; i < cfg->line_outs; i++) {
2920                 nid = cfg->line_out_pins[i];
2921                 dac = get_unassigned_dac(codec, nid);
2922                 if (!dac) {
2923                         if (spec->multiout.num_dacs > 0) {
2924                                 /* we have already working output pins,
2925                                  * so let's drop the broken ones again
2926                                  */
2927                                 cfg->line_outs = spec->multiout.num_dacs;
2928                                 break;
2929                         }
2930                         /* error out, no available DAC found */
2931                         snd_printk(KERN_ERR
2932                                    "%s: No available DAC for pin 0x%x\n",
2933                                    __func__, nid);
2934                         return -ENODEV;
2935                 }
2936                 add_spec_dacs(spec, dac);
2937         }
2938
2939         for (i = 0; i < cfg->hp_outs; i++) {
2940                 nid = cfg->hp_pins[i];
2941                 dac = get_unassigned_dac(codec, nid);
2942                 if (dac) {
2943                         if (!spec->multiout.hp_nid)
2944                                 spec->multiout.hp_nid = dac;
2945                         else
2946                                 add_spec_extra_dacs(spec, dac);
2947                 }
2948                 spec->hp_dacs[i] = dac;
2949         }
2950
2951         for (i = 0; i < cfg->speaker_outs; i++) {
2952                 nid = cfg->speaker_pins[i];
2953                 dac = get_unassigned_dac(codec, nid);
2954                 if (dac)
2955                         add_spec_extra_dacs(spec, dac);
2956                 spec->speaker_dacs[i] = dac;
2957         }
2958
2959         /* add line-in as output */
2960         nid = check_line_out_switch(codec);
2961         if (nid) {
2962                 dac = get_unassigned_dac(codec, nid);
2963                 if (dac) {
2964                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2965                                     nid, cfg->line_outs);
2966                         cfg->line_out_pins[cfg->line_outs] = nid;
2967                         cfg->line_outs++;
2968                         spec->line_switch = nid;
2969                         add_spec_dacs(spec, dac);
2970                 }
2971         }
2972         /* add mic as output */
2973         nid = check_mic_out_switch(codec);
2974         if (nid) {
2975                 dac = get_unassigned_dac(codec, nid);
2976                 if (dac) {
2977                         snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2978                                     nid, cfg->line_outs);
2979                         cfg->line_out_pins[cfg->line_outs] = nid;
2980                         cfg->line_outs++;
2981                         spec->mic_switch = nid;
2982                         add_spec_dacs(spec, dac);
2983                 }
2984         }
2985
2986         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2987                    spec->multiout.num_dacs,
2988                    spec->multiout.dac_nids[0],
2989                    spec->multiout.dac_nids[1],
2990                    spec->multiout.dac_nids[2],
2991                    spec->multiout.dac_nids[3],
2992                    spec->multiout.dac_nids[4]);
2993
2994         return 0;
2995 }
2996
2997 /* create volume control/switch for the given prefx type */
2998 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
2999                                int idx, hda_nid_t nid, int chs)
3000 {
3001         struct sigmatel_spec *spec = codec->spec;
3002         char name[32];
3003         int err;
3004
3005         if (!spec->check_volume_offset) {
3006                 unsigned int caps, step, nums, db_scale;
3007                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3008                 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3009                         AC_AMPCAP_STEP_SIZE_SHIFT;
3010                 step = (step + 1) * 25; /* in .01dB unit */
3011                 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3012                         AC_AMPCAP_NUM_STEPS_SHIFT;
3013                 db_scale = nums * step;
3014                 /* if dB scale is over -64dB, and finer enough,
3015                  * let's reduce it to half
3016                  */
3017                 if (db_scale > 6400 && nums >= 0x1f)
3018                         spec->volume_offset = nums / 2;
3019                 spec->check_volume_offset = 1;
3020         }
3021
3022         sprintf(name, "%s Playback Volume", pfx);
3023         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3024                 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3025                                         spec->volume_offset));
3026         if (err < 0)
3027                 return err;
3028         sprintf(name, "%s Playback Switch", pfx);
3029         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3030                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3031         if (err < 0)
3032                 return err;
3033         return 0;
3034 }
3035
3036 #define create_controls(codec, pfx, nid, chs) \
3037         create_controls_idx(codec, pfx, 0, nid, chs)
3038
3039 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3040 {
3041         if (spec->multiout.num_dacs > 4) {
3042                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3043                 return 1;
3044         } else {
3045                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3046                 spec->multiout.num_dacs++;
3047         }
3048         return 0;
3049 }
3050
3051 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3052 {
3053         int i;
3054         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3055                 if (!spec->multiout.extra_out_nid[i]) {
3056                         spec->multiout.extra_out_nid[i] = nid;
3057                         return 0;
3058                 }
3059         }
3060         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3061         return 1;
3062 }
3063
3064 /* Create output controls
3065  * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3066  */
3067 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3068                                  const hda_nid_t *pins,
3069                                  const hda_nid_t *dac_nids,
3070                                  int type)
3071 {
3072         struct sigmatel_spec *spec = codec->spec;
3073         static const char *chname[4] = {
3074                 "Front", "Surround", NULL /*CLFE*/, "Side"
3075         };
3076         hda_nid_t nid;
3077         int i, err;
3078         unsigned int wid_caps;
3079
3080         for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3081                 nid = dac_nids[i];
3082                 if (!nid)
3083                         continue;
3084                 if (type != AUTO_PIN_HP_OUT && i == 2) {
3085                         /* Center/LFE */
3086                         err = create_controls(codec, "Center", nid, 1);
3087                         if (err < 0)
3088                                 return err;
3089                         err = create_controls(codec, "LFE", nid, 2);
3090                         if (err < 0)
3091                                 return err;
3092
3093                         wid_caps = get_wcaps(codec, nid);
3094
3095                         if (wid_caps & AC_WCAP_LR_SWAP) {
3096                                 err = stac92xx_add_control(spec,
3097                                         STAC_CTL_WIDGET_CLFE_SWITCH,
3098                                         "Swap Center/LFE Playback Switch", nid);
3099
3100                                 if (err < 0)
3101                                         return err;
3102                         }
3103
3104                 } else {
3105                         const char *name;
3106                         int idx;
3107                         switch (type) {
3108                         case AUTO_PIN_HP_OUT:
3109                                 name = "Headphone";
3110                                 idx = i;
3111                                 break;
3112                         case AUTO_PIN_SPEAKER_OUT:
3113                                 name = "Speaker";
3114                                 idx = i;
3115                                 break;
3116                         default:
3117                                 name = chname[i];
3118                                 idx = 0;
3119                                 break;
3120                         }
3121                         err = create_controls_idx(codec, name, idx, nid, 3);
3122                         if (err < 0)
3123                                 return err;
3124                         if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3125                                 wid_caps = get_wcaps(codec, pins[i]);
3126                                 if (wid_caps & AC_WCAP_UNSOL_CAP)
3127                                         spec->hp_detect = 1;
3128                         }
3129                 }
3130         }
3131         return 0;
3132 }
3133
3134 /* add playback controls from the parsed DAC table */
3135 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3136                                                const struct auto_pin_cfg *cfg)
3137 {
3138         struct sigmatel_spec *spec = codec->spec;
3139         int err;
3140
3141         err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3142                                     spec->multiout.dac_nids,
3143                                     cfg->line_out_type);
3144         if (err < 0)
3145                 return err;
3146
3147         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3148                 err = stac92xx_add_control(spec,
3149                         STAC_CTL_WIDGET_HP_SWITCH,
3150                         "Headphone as Line Out Switch",
3151                         cfg->hp_pins[cfg->hp_outs - 1]);
3152                 if (err < 0)
3153                         return err;
3154         }
3155
3156         if (spec->line_switch) {
3157                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3158                                            "Line In as Output Switch",
3159                                            spec->line_switch << 8);
3160                 if (err < 0)
3161                         return err;
3162         }
3163
3164         if (spec->mic_switch) {
3165                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3166                                            "Mic as Output Switch",
3167                                            (spec->mic_switch << 8) | 1);
3168                 if (err < 0)
3169                         return err;
3170         }
3171
3172         return 0;
3173 }
3174
3175 /* add playback controls for Speaker and HP outputs */
3176 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3177                                         struct auto_pin_cfg *cfg)
3178 {
3179         struct sigmatel_spec *spec = codec->spec;
3180         int err;
3181
3182         err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3183                                     spec->hp_dacs, AUTO_PIN_HP_OUT);
3184         if (err < 0)
3185                 return err;
3186
3187         err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3188                                     spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3189         if (err < 0)
3190                 return err;
3191
3192         return 0;
3193 }
3194
3195 /* labels for mono mux outputs */
3196 static const char *stac92xx_mono_labels[4] = {
3197         "DAC0", "DAC1", "Mixer", "DAC2"
3198 };
3199
3200 /* create mono mux for mono out on capable codecs */
3201 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3202 {
3203         struct sigmatel_spec *spec = codec->spec;
3204         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3205         int i, num_cons;
3206         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3207
3208         num_cons = snd_hda_get_connections(codec,
3209                                 spec->mono_nid,
3210                                 con_lst,
3211                                 HDA_MAX_NUM_INPUTS);
3212         if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3213                 return -EINVAL;
3214
3215         for (i = 0; i < num_cons; i++) {
3216                 mono_mux->items[mono_mux->num_items].label =
3217                                         stac92xx_mono_labels[i];
3218                 mono_mux->items[mono_mux->num_items].index = i;
3219                 mono_mux->num_items++;
3220         }
3221
3222         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3223                                 "Mono Mux", spec->mono_nid);
3224 }
3225
3226 /* labels for amp mux outputs */
3227 static const char *stac92xx_amp_labels[3] = {
3228         "Front Microphone", "Microphone", "Line In",
3229 };
3230
3231 /* create amp out controls mux on capable codecs */
3232 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3233 {
3234         struct sigmatel_spec *spec = codec->spec;
3235         struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3236         int i, err;
3237
3238         for (i = 0; i < spec->num_amps; i++) {
3239                 amp_mux->items[amp_mux->num_items].label =
3240                                         stac92xx_amp_labels[i];
3241                 amp_mux->items[amp_mux->num_items].index = i;
3242                 amp_mux->num_items++;
3243         }
3244
3245         if (spec->num_amps > 1) {
3246                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3247                         "Amp Selector Capture Switch", 0);
3248                 if (err < 0)
3249                         return err;
3250         }
3251         return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3252                 "Amp Capture Volume",
3253                 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3254 }
3255
3256
3257 /* create PC beep volume controls */
3258 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3259                                                 hda_nid_t nid)
3260 {
3261         struct sigmatel_spec *spec = codec->spec;
3262         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3263         int err;
3264
3265         /* check for mute support for the the amp */
3266         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3267                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3268                         "PC Beep Playback Switch",
3269                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3270                         if (err < 0)
3271                                 return err;
3272         }
3273
3274         /* check to see if there is volume support for the amp */
3275         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3276                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3277                         "PC Beep Playback Volume",
3278                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3279                         if (err < 0)
3280                                 return err;
3281         }
3282         return 0;
3283 }
3284
3285 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3286 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3287
3288 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3289                                         struct snd_ctl_elem_value *ucontrol)
3290 {
3291         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3292         ucontrol->value.integer.value[0] = codec->beep->enabled;
3293         return 0;
3294 }
3295
3296 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3297                                         struct snd_ctl_elem_value *ucontrol)
3298 {
3299         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3300         int enabled = !!ucontrol->value.integer.value[0];
3301         if (codec->beep->enabled != enabled) {
3302                 codec->beep->enabled = enabled;
3303                 return 1;
3304         }
3305         return 0;
3306 }
3307
3308 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3309         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3310         .info = stac92xx_dig_beep_switch_info,
3311         .get = stac92xx_dig_beep_switch_get,
3312         .put = stac92xx_dig_beep_switch_put,
3313 };
3314
3315 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3316 {
3317         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3318                                          0, "PC Beep Playback Switch", 0);
3319 }
3320 #endif
3321
3322 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3323 {
3324         struct sigmatel_spec *spec = codec->spec;
3325         int wcaps, nid, i, err = 0;
3326
3327         for (i = 0; i < spec->num_muxes; i++) {
3328                 nid = spec->mux_nids[i];
3329                 wcaps = get_wcaps(codec, nid);
3330
3331                 if (wcaps & AC_WCAP_OUT_AMP) {
3332                         err = stac92xx_add_control_idx(spec,
3333                                 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3334                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3335                         if (err < 0)
3336                                 return err;
3337                 }
3338         }
3339         return 0;
3340 };
3341
3342 static const char *stac92xx_spdif_labels[3] = {
3343         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3344 };
3345
3346 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3347 {
3348         struct sigmatel_spec *spec = codec->spec;
3349         struct hda_input_mux *spdif_mux = &spec->private_smux;
3350         const char **labels = spec->spdif_labels;
3351         int i, num_cons;
3352         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3353
3354         num_cons = snd_hda_get_connections(codec,
3355                                 spec->smux_nids[0],
3356                                 con_lst,
3357                                 HDA_MAX_NUM_INPUTS);
3358         if (!num_cons)
3359                 return -EINVAL;
3360
3361         if (!labels)
3362                 labels = stac92xx_spdif_labels;
3363
3364         for (i = 0; i < num_cons; i++) {
3365                 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3366                 spdif_mux->items[spdif_mux->num_items].index = i;
3367                 spdif_mux->num_items++;
3368         }
3369
3370         return 0;
3371 }
3372
3373 /* labels for dmic mux inputs */
3374 static const char *stac92xx_dmic_labels[5] = {
3375         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3376         "Digital Mic 3", "Digital Mic 4"
3377 };
3378
3379 /* create playback/capture controls for input pins on dmic capable codecs */
3380 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3381                                                 const struct auto_pin_cfg *cfg)
3382 {
3383         struct sigmatel_spec *spec = codec->spec;
3384         struct hda_input_mux *dimux = &spec->private_dimux;
3385         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3386         int err, i, j;
3387         char name[32];
3388
3389         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3390         dimux->items[dimux->num_items].index = 0;
3391         dimux->num_items++;
3392
3393         for (i = 0; i < spec->num_dmics; i++) {
3394                 hda_nid_t nid;
3395                 int index;
3396                 int num_cons;
3397                 unsigned int wcaps;
3398                 unsigned int def_conf;
3399
3400                 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3401                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3402                         continue;
3403
3404                 nid = spec->dmic_nids[i];
3405                 num_cons = snd_hda_get_connections(codec,
3406                                 spec->dmux_nids[0],
3407                                 con_lst,
3408                                 HDA_MAX_NUM_INPUTS);
3409                 for (j = 0; j < num_cons; j++)
3410                         if (con_lst[j] == nid) {
3411                                 index = j;
3412                                 goto found;
3413                         }
3414                 continue;
3415 found:
3416                 wcaps = get_wcaps(codec, nid) &
3417                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3418
3419                 if (wcaps) {
3420                         sprintf(name, "%s Capture Volume",
3421                                 stac92xx_dmic_labels[dimux->num_items]);
3422
3423                         err = stac92xx_add_control(spec,
3424                                 STAC_CTL_WIDGET_VOL,
3425                                 name,
3426                                 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3427                                 (wcaps & AC_WCAP_OUT_AMP) ?
3428                                 HDA_OUTPUT : HDA_INPUT));
3429                         if (err < 0)
3430                                 return err;
3431                 }
3432
3433                 dimux->items[dimux->num_items].label =
3434                         stac92xx_dmic_labels[dimux->num_items];
3435                 dimux->items[dimux->num_items].index = index;
3436                 dimux->num_items++;
3437         }
3438
3439         return 0;
3440 }
3441
3442 /* create playback/capture controls for input pins */
3443 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3444 {
3445         struct sigmatel_spec *spec = codec->spec;
3446         struct hda_input_mux *imux = &spec->private_imux;
3447         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3448         int i, j, k;
3449
3450         for (i = 0; i < AUTO_PIN_LAST; i++) {
3451                 int index;
3452
3453                 if (!cfg->input_pins[i])
3454                         continue;
3455                 index = -1;
3456                 for (j = 0; j < spec->num_muxes; j++) {
3457                         int num_cons;
3458                         num_cons = snd_hda_get_connections(codec,
3459                                                            spec->mux_nids[j],
3460                                                            con_lst,
3461                                                            HDA_MAX_NUM_INPUTS);
3462                         for (k = 0; k < num_cons; k++)
3463                                 if (con_lst[k] == cfg->input_pins[i]) {
3464                                         index = k;
3465                                         goto found;
3466                                 }
3467                 }
3468                 continue;
3469         found:
3470                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3471                 imux->items[imux->num_items].index = index;
3472                 imux->num_items++;
3473         }
3474
3475         if (imux->num_items) {
3476                 /*
3477                  * Set the current input for the muxes.
3478                  * The STAC9221 has two input muxes with identical source
3479                  * NID lists.  Hopefully this won't get confused.
3480                  */
3481                 for (i = 0; i < spec->num_muxes; i++) {
3482                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3483                                                   AC_VERB_SET_CONNECT_SEL,
3484                                                   imux->items[0].index);
3485                 }
3486         }
3487
3488         return 0;
3489 }
3490
3491 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3492 {
3493         struct sigmatel_spec *spec = codec->spec;
3494         int i;
3495
3496         for (i = 0; i < spec->autocfg.line_outs; i++) {
3497                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3498                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3499         }
3500 }
3501
3502 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3503 {
3504         struct sigmatel_spec *spec = codec->spec;
3505         int i;
3506
3507         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3508                 hda_nid_t pin;
3509                 pin = spec->autocfg.hp_pins[i];
3510                 if (pin) /* connect to front */
3511                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3512         }
3513         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3514                 hda_nid_t pin;
3515                 pin = spec->autocfg.speaker_pins[i];
3516                 if (pin) /* connect to front */
3517                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3518         }
3519 }
3520
3521 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3522 {
3523         struct sigmatel_spec *spec = codec->spec;
3524         int hp_swap = 0;
3525         int err;
3526
3527         if ((err = snd_hda_parse_pin_def_config(codec,
3528                                                 &spec->autocfg,
3529                                                 spec->dmic_nids)) < 0)
3530                 return err;
3531         if (! spec->autocfg.line_outs)
3532                 return 0; /* can't find valid pin config */
3533
3534         /* If we have no real line-out pin and multiple hp-outs, HPs should
3535          * be set up as multi-channel outputs.
3536          */
3537         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3538             spec->autocfg.hp_outs > 1) {
3539                 /* Copy hp_outs to line_outs, backup line_outs in
3540                  * speaker_outs so that the following routines can handle
3541                  * HP pins as primary outputs.
3542                  */
3543                 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3544                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3545                        sizeof(spec->autocfg.line_out_pins));
3546                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3547                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3548                        sizeof(spec->autocfg.hp_pins));
3549                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3550                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3551                 spec->autocfg.hp_outs = 0;
3552                 hp_swap = 1;
3553         }
3554         if (spec->autocfg.mono_out_pin) {
3555                 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3556                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3557                 u32 caps = query_amp_caps(codec,
3558                                 spec->autocfg.mono_out_pin, dir);
3559                 hda_nid_t conn_list[1];
3560
3561                 /* get the mixer node and then the mono mux if it exists */
3562                 if (snd_hda_get_connections(codec,
3563                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
3564                                 snd_hda_get_connections(codec, conn_list[0],
3565                                 conn_list, 1)) {
3566
3567                                 int wcaps = get_wcaps(codec, conn_list[0]);
3568                                 int wid_type = (wcaps & AC_WCAP_TYPE)
3569                                         >> AC_WCAP_TYPE_SHIFT;
3570                                 /* LR swap check, some stac925x have a mux that
3571                                  * changes the DACs output path instead of the
3572                                  * mono-mux path.
3573                                  */
3574                                 if (wid_type == AC_WID_AUD_SEL &&
3575                                                 !(wcaps & AC_WCAP_LR_SWAP))
3576                                         spec->mono_nid = conn_list[0];
3577                 }
3578                 if (dir) {
3579                         hda_nid_t nid = spec->autocfg.mono_out_pin;
3580
3581                         /* most mono outs have a least a mute/unmute switch */
3582                         dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3583                         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3584                                 "Mono Playback Switch",
3585                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3586                         if (err < 0)
3587                                 return err;
3588                         /* check for volume support for the amp */
3589                         if ((caps & AC_AMPCAP_NUM_STEPS)
3590                                         >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3591                                 err = stac92xx_add_control(spec,
3592                                         STAC_CTL_WIDGET_VOL,
3593                                         "Mono Playback Volume",
3594                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3595                                 if (err < 0)
3596                                         return err;
3597                         }
3598                 }
3599
3600                 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3601                                          AC_PINCTL_OUT_EN);
3602         }
3603
3604         if (!spec->multiout.num_dacs) {
3605                 err = stac92xx_auto_fill_dac_nids(codec);
3606                 if (err < 0)
3607                         return err;
3608                 err = stac92xx_auto_create_multi_out_ctls(codec,
3609                                                           &spec->autocfg);
3610                 if (err < 0)
3611                         return err;
3612         }
3613
3614         /* setup analog beep controls */
3615         if (spec->anabeep_nid > 0) {
3616                 err = stac92xx_auto_create_beep_ctls(codec,
3617                         spec->anabeep_nid);
3618                 if (err < 0)
3619                         return err;
3620         }
3621
3622         /* setup digital beep controls and input device */
3623 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3624         if (spec->digbeep_nid > 0) {
3625                 hda_nid_t nid = spec->digbeep_nid;
3626                 unsigned int caps;
3627
3628                 err = stac92xx_auto_create_beep_ctls(codec, nid);
3629                 if (err < 0)
3630                         return err;
3631                 err = snd_hda_attach_beep_device(codec, nid);
3632                 if (err < 0)
3633                         return err;
3634                 /* if no beep switch is available, make its own one */
3635                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3636                 if (codec->beep &&
3637                     !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3638                         err = stac92xx_beep_switch_ctl(codec);
3639                         if (err < 0)
3640                                 return err;
3641                 }
3642         }
3643 #endif
3644
3645         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3646         if (err < 0)
3647                 return err;
3648
3649         /* All output parsing done, now restore the swapped hp pins */
3650         if (hp_swap) {
3651                 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3652                        sizeof(spec->autocfg.hp_pins));
3653                 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3654                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3655                 spec->autocfg.line_outs = 0;
3656         }
3657
3658         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3659         if (err < 0)
3660                 return err;
3661
3662         if (spec->mono_nid > 0) {
3663                 err = stac92xx_auto_create_mono_output_ctls(codec);
3664                 if (err < 0)
3665                         return err;
3666         }
3667         if (spec->num_amps > 0) {
3668                 err = stac92xx_auto_create_amp_output_ctls(codec);
3669                 if (err < 0)
3670                         return err;
3671         }
3672         if (spec->num_dmics > 0 && !spec->dinput_mux)
3673                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3674                                                 &spec->autocfg)) < 0)
3675                         return err;
3676         if (spec->num_muxes > 0) {
3677                 err = stac92xx_auto_create_mux_input_ctls(codec);
3678                 if (err < 0)
3679                         return err;
3680         }
3681         if (spec->num_smuxes > 0) {
3682                 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3683                 if (err < 0)
3684                         return err;
3685         }
3686
3687         err = stac92xx_add_input_source(spec);
3688         if (err < 0)
3689                 return err;
3690
3691         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3692         if (spec->multiout.max_channels > 2)
3693                 spec->surr_switch = 1;
3694
3695         if (spec->autocfg.dig_outs)
3696                 spec->multiout.dig_out_nid = dig_out;
3697         if (dig_in && spec->autocfg.dig_in_pin)
3698                 spec->dig_in_nid = dig_in;
3699
3700         if (spec->kctls.list)
3701                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3702
3703         spec->input_mux = &spec->private_imux;
3704         if (!spec->dinput_mux)
3705                 spec->dinput_mux = &spec->private_dimux;
3706         spec->sinput_mux = &spec->private_smux;
3707         spec->mono_mux = &spec->private_mono_mux;
3708         spec->amp_mux = &spec->private_amp_mux;
3709         return 1;
3710 }
3711
3712 /* add playback controls for HP output */
3713 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3714                                         struct auto_pin_cfg *cfg)
3715 {
3716         struct sigmatel_spec *spec = codec->spec;
3717         hda_nid_t pin = cfg->hp_pins[0];
3718         unsigned int wid_caps;
3719
3720         if (! pin)
3721                 return 0;
3722
3723         wid_caps = get_wcaps(codec, pin);
3724         if (wid_caps & AC_WCAP_UNSOL_CAP)
3725                 spec->hp_detect = 1;
3726
3727         return 0;
3728 }
3729
3730 /* add playback controls for LFE output */
3731 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3732                                         struct auto_pin_cfg *cfg)
3733 {
3734         struct sigmatel_spec *spec = codec->spec;
3735         int err;
3736         hda_nid_t lfe_pin = 0x0;
3737         int i;
3738
3739         /*
3740          * search speaker outs and line outs for a mono speaker pin
3741          * with an amp.  If one is found, add LFE controls
3742          * for it.
3743          */
3744         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3745                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3746                 unsigned int wcaps = get_wcaps(codec, pin);
3747                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3748                 if (wcaps == AC_WCAP_OUT_AMP)
3749                         /* found a mono speaker with an amp, must be lfe */
3750                         lfe_pin = pin;
3751         }
3752
3753         /* if speaker_outs is 0, then speakers may be in line_outs */
3754         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3755                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3756                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
3757                         unsigned int defcfg;
3758                         defcfg = snd_hda_codec_get_pincfg(codec, pin);
3759                         if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3760                                 unsigned int wcaps = get_wcaps(codec, pin);
3761                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3762                                 if (wcaps == AC_WCAP_OUT_AMP)
3763                                         /* found a mono speaker with an amp,
3764                                            must be lfe */
3765                                         lfe_pin = pin;
3766                         }
3767                 }
3768         }
3769
3770         if (lfe_pin) {
3771                 err = create_controls(codec, "LFE", lfe_pin, 1);
3772                 if (err < 0)
3773                         return err;
3774         }
3775
3776         return 0;
3777 }
3778
3779 static int stac9200_parse_auto_config(struct hda_codec *codec)
3780 {
3781         struct sigmatel_spec *spec = codec->spec;
3782         int err;
3783
3784         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3785                 return err;
3786
3787         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3788                 return err;
3789
3790         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3791                 return err;
3792
3793         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3794                 return err;
3795
3796         if (spec->num_muxes > 0) {
3797                 err = stac92xx_auto_create_mux_input_ctls(codec);
3798                 if (err < 0)
3799                         return err;
3800         }
3801
3802         err = stac92xx_add_input_source(spec);
3803         if (err < 0)
3804                 return err;
3805
3806         if (spec->autocfg.dig_outs)
3807                 spec->multiout.dig_out_nid = 0x05;
3808         if (spec->autocfg.dig_in_pin)
3809                 spec->dig_in_nid = 0x04;
3810
3811         if (spec->kctls.list)
3812                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3813
3814         spec->input_mux = &spec->private_imux;
3815         spec->dinput_mux = &spec->private_dimux;
3816
3817         return 1;
3818 }
3819
3820 /*
3821  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3822  * funky external mute control using GPIO pins.
3823  */
3824
3825 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3826                           unsigned int dir_mask, unsigned int data)
3827 {
3828         unsigned int gpiostate, gpiomask, gpiodir;
3829
3830         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3831                                        AC_VERB_GET_GPIO_DATA, 0);
3832         gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3833
3834         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3835                                       AC_VERB_GET_GPIO_MASK, 0);
3836         gpiomask |= mask;
3837
3838         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3839                                      AC_VERB_GET_GPIO_DIRECTION, 0);
3840         gpiodir |= dir_mask;
3841
3842         /* Configure GPIOx as CMOS */
3843         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3844
3845         snd_hda_codec_write(codec, codec->afg, 0,
3846                             AC_VERB_SET_GPIO_MASK, gpiomask);
3847         snd_hda_codec_read(codec, codec->afg, 0,
3848                            AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3849
3850         msleep(1);
3851
3852         snd_hda_codec_read(codec, codec->afg, 0,
3853                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3854 }
3855
3856 static int stac92xx_add_jack(struct hda_codec *codec,
3857                 hda_nid_t nid, int type)
3858 {
3859 #ifdef CONFIG_SND_JACK
3860         struct sigmatel_spec *spec = codec->spec;
3861         struct sigmatel_jack *jack;
3862         int def_conf = snd_hda_codec_get_pincfg(codec, nid);
3863         int connectivity = get_defcfg_connect(def_conf);
3864         char name[32];
3865
3866         if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3867                 return 0;
3868
3869         snd_array_init(&spec->jacks, sizeof(*jack), 32);
3870         jack = snd_array_new(&spec->jacks);
3871         if (!jack)
3872                 return -ENOMEM;
3873         jack->nid = nid;
3874         jack->type = type;
3875
3876         sprintf(name, "%s at %s %s Jack",
3877                 snd_hda_get_jack_type(def_conf),
3878                 snd_hda_get_jack_connectivity(def_conf),
3879                 snd_hda_get_jack_location(def_conf));
3880
3881         return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3882 #else
3883         return 0;
3884 #endif
3885 }
3886
3887 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3888                           unsigned char type, int data)
3889 {
3890         struct sigmatel_event *event;
3891
3892         snd_array_init(&spec->events, sizeof(*event), 32);
3893         event = snd_array_new(&spec->events);
3894         if (!event)
3895                 return -ENOMEM;
3896         event->nid = nid;
3897         event->type = type;
3898         event->tag = spec->events.used;
3899         event->data = data;
3900
3901         return event->tag;
3902 }
3903
3904 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3905                                              hda_nid_t nid, unsigned char type)
3906 {
3907         struct sigmatel_spec *spec = codec->spec;
3908         struct sigmatel_event *event = spec->events.list;
3909         int i;
3910
3911         for (i = 0; i < spec->events.used; i++, event++) {
3912                 if (event->nid == nid && event->type == type)
3913                         return event;
3914         }
3915         return NULL;
3916 }
3917
3918 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3919                                                       unsigned char tag)
3920 {
3921         struct sigmatel_spec *spec = codec->spec;
3922         struct sigmatel_event *event = spec->events.list;
3923         int i;
3924
3925         for (i = 0; i < spec->events.used; i++, event++) {
3926                 if (event->tag == tag)
3927                         return event;
3928         }
3929         return NULL;
3930 }
3931
3932 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3933                               unsigned int type)
3934 {
3935         struct sigmatel_event *event;
3936         int tag;
3937
3938         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3939                 return;
3940         event = stac_get_event(codec, nid, type);
3941         if (event)
3942                 tag = event->tag;
3943         else
3944                 tag = stac_add_event(codec->spec, nid, type, 0);
3945         if (tag < 0)
3946                 return;
3947         snd_hda_codec_write_cache(codec, nid, 0,
3948                                   AC_VERB_SET_UNSOLICITED_ENABLE,
3949                                   AC_USRSP_EN | tag);
3950 }
3951
3952 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3953 {
3954         int i;
3955         for (i = 0; i < cfg->hp_outs; i++)
3956                 if (cfg->hp_pins[i] == nid)
3957                         return 1; /* nid is a HP-Out */
3958
3959         return 0; /* nid is not a HP-Out */
3960 };
3961
3962 static void stac92xx_power_down(struct hda_codec *codec)
3963 {
3964         struct sigmatel_spec *spec = codec->spec;
3965
3966         /* power down inactive DACs */
3967         hda_nid_t *dac;
3968         for (dac = spec->dac_list; *dac; dac++)
3969                 if (!check_all_dac_nids(spec, *dac))
3970                         snd_hda_codec_write(codec, *dac, 0,
3971                                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3972 }
3973
3974 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3975                                   int enable);
3976
3977 /* override some hints from the hwdep entry */
3978 static void stac_store_hints(struct hda_codec *codec)
3979 {
3980         struct sigmatel_spec *spec = codec->spec;
3981         const char *p;
3982         int val;
3983
3984         val = snd_hda_get_bool_hint(codec, "hp_detect");
3985         if (val >= 0)
3986                 spec->hp_detect = val;
3987         p = snd_hda_get_hint(codec, "gpio_mask");
3988         if (p) {
3989                 spec->gpio_mask = simple_strtoul(p, NULL, 0);
3990                 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
3991                         spec->gpio_mask;
3992         }
3993         p = snd_hda_get_hint(codec, "gpio_dir");
3994         if (p)
3995                 spec->gpio_dir = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
3996         p = snd_hda_get_hint(codec, "gpio_data");
3997         if (p)
3998                 spec->gpio_data = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
3999         p = snd_hda_get_hint(codec, "eapd_mask");
4000         if (p)
4001                 spec->eapd_mask = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
4002         val = snd_hda_get_bool_hint(codec, "eapd_switch");
4003         if (val >= 0)
4004                 spec->eapd_switch = val;
4005 }
4006
4007 static int stac92xx_init(struct hda_codec *codec)
4008 {
4009         struct sigmatel_spec *spec = codec->spec;
4010         struct auto_pin_cfg *cfg = &spec->autocfg;
4011         unsigned int gpio;
4012         int i;
4013
4014         snd_hda_sequence_write(codec, spec->init);
4015
4016         /* power down adcs initially */
4017         if (spec->powerdown_adcs)
4018                 for (i = 0; i < spec->num_adcs; i++)
4019                         snd_hda_codec_write(codec,
4020                                 spec->adc_nids[i], 0,
4021                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4022
4023         /* override some hints */
4024         stac_store_hints(codec);
4025
4026         /* set up GPIO */
4027         gpio = spec->gpio_data;
4028         /* turn on EAPD statically when spec->eapd_switch isn't set.
4029          * otherwise, unsol event will turn it on/off dynamically
4030          */
4031         if (!spec->eapd_switch)
4032                 gpio |= spec->eapd_mask;
4033         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4034
4035         /* set up pins */
4036         if (spec->hp_detect) {
4037                 /* Enable unsolicited responses on the HP widget */
4038                 for (i = 0; i < cfg->hp_outs; i++) {
4039                         hda_nid_t nid = cfg->hp_pins[i];
4040                         enable_pin_detect(codec, nid, STAC_HP_EVENT);
4041                 }
4042                 /* force to enable the first line-out; the others are set up
4043                  * in unsol_event
4044                  */
4045                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4046                                 AC_PINCTL_OUT_EN);
4047                 /* fake event to set up pins */
4048                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4049                                        STAC_HP_EVENT);
4050         } else {
4051                 stac92xx_auto_init_multi_out(codec);
4052                 stac92xx_auto_init_hp_out(codec);
4053                 for (i = 0; i < cfg->hp_outs; i++)
4054                         stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4055         }
4056         for (i = 0; i < AUTO_PIN_LAST; i++) {
4057                 hda_nid_t nid = cfg->input_pins[i];
4058                 if (nid) {
4059                         unsigned int pinctl, conf;
4060                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4061                                 /* for mic pins, force to initialize */
4062                                 pinctl = stac92xx_get_vref(codec, nid);
4063                                 pinctl |= AC_PINCTL_IN_EN;
4064                                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4065                         } else {
4066                                 pinctl = snd_hda_codec_read(codec, nid, 0,
4067                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4068                                 /* if PINCTL already set then skip */
4069                                 if (!(pinctl & AC_PINCTL_IN_EN)) {
4070                                         pinctl |= AC_PINCTL_IN_EN;
4071                                         stac92xx_auto_set_pinctl(codec, nid,
4072                                                                  pinctl);
4073                                 }
4074                         }
4075                         conf = snd_hda_codec_get_pincfg(codec, nid);
4076                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4077                                 enable_pin_detect(codec, nid,
4078                                                   STAC_INSERT_EVENT);
4079                                 stac_issue_unsol_event(codec, nid,
4080                                                        STAC_INSERT_EVENT);
4081                         }
4082                 }
4083         }
4084         for (i = 0; i < spec->num_dmics; i++)
4085                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4086                                         AC_PINCTL_IN_EN);
4087         if (cfg->dig_out_pins[0])
4088                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4089                                          AC_PINCTL_OUT_EN);
4090         if (cfg->dig_in_pin)
4091                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4092                                          AC_PINCTL_IN_EN);
4093         for (i = 0; i < spec->num_pwrs; i++)  {
4094                 hda_nid_t nid = spec->pwr_nids[i];
4095                 int pinctl, def_conf;
4096
4097                 /* power on when no jack detection is available */
4098                 if (!spec->hp_detect) {
4099                         stac_toggle_power_map(codec, nid, 1);
4100                         continue;
4101                 }
4102
4103                 if (is_nid_hp_pin(cfg, nid))
4104                         continue; /* already has an unsol event */
4105
4106                 pinctl = snd_hda_codec_read(codec, nid, 0,
4107                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4108                 /* outputs are only ports capable of power management
4109                  * any attempts on powering down a input port cause the
4110                  * referenced VREF to act quirky.
4111                  */
4112                 if (pinctl & AC_PINCTL_IN_EN) {
4113                         stac_toggle_power_map(codec, nid, 1);
4114                         continue;
4115                 }
4116                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4117                 def_conf = get_defcfg_connect(def_conf);
4118                 /* skip any ports that don't have jacks since presence
4119                  * detection is useless */
4120                 if (def_conf != AC_JACK_PORT_COMPLEX) {
4121                         if (def_conf != AC_JACK_PORT_NONE)
4122                                 stac_toggle_power_map(codec, nid, 1);
4123                         continue;
4124                 }
4125                 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4126                         enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4127                         stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4128                 }
4129         }
4130         if (spec->dac_list)
4131                 stac92xx_power_down(codec);
4132         return 0;
4133 }
4134
4135 static void stac92xx_free_jacks(struct hda_codec *codec)
4136 {
4137 #ifdef CONFIG_SND_JACK
4138         /* free jack instances manually when clearing/reconfiguring */
4139         struct sigmatel_spec *spec = codec->spec;
4140         if (!codec->bus->shutdown && spec->jacks.list) {
4141                 struct sigmatel_jack *jacks = spec->jacks.list;
4142                 int i;
4143                 for (i = 0; i < spec->jacks.used; i++)
4144                         snd_device_free(codec->bus->card, &jacks[i].jack);
4145         }
4146         snd_array_free(&spec->jacks);
4147 #endif
4148 }
4149
4150 static void stac92xx_free_kctls(struct hda_codec *codec)
4151 {
4152         struct sigmatel_spec *spec = codec->spec;
4153
4154         if (spec->kctls.list) {
4155                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4156                 int i;
4157                 for (i = 0; i < spec->kctls.used; i++)
4158                         kfree(kctl[i].name);
4159         }
4160         snd_array_free(&spec->kctls);
4161 }
4162
4163 static void stac92xx_free(struct hda_codec *codec)
4164 {
4165         struct sigmatel_spec *spec = codec->spec;
4166
4167         if (! spec)
4168                 return;
4169
4170         stac92xx_free_jacks(codec);
4171         snd_array_free(&spec->events);
4172
4173         kfree(spec);
4174         snd_hda_detach_beep_device(codec);
4175 }
4176
4177 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4178                                 unsigned int flag)
4179 {
4180         unsigned int old_ctl, pin_ctl;
4181
4182         pin_ctl = snd_hda_codec_read(codec, nid,
4183                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4184
4185         if (pin_ctl & AC_PINCTL_IN_EN) {
4186                 /*
4187                  * we need to check the current set-up direction of
4188                  * shared input pins since they can be switched via
4189                  * "xxx as Output" mixer switch
4190                  */
4191                 struct sigmatel_spec *spec = codec->spec;
4192                 if (nid == spec->line_switch || nid == spec->mic_switch)
4193                         return;
4194         }
4195
4196         old_ctl = pin_ctl;
4197         /* if setting pin direction bits, clear the current
4198            direction bits first */
4199         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4200                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4201
4202         pin_ctl |= flag;
4203         if (old_ctl != pin_ctl)
4204                 snd_hda_codec_write_cache(codec, nid, 0,
4205                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4206                                           pin_ctl);
4207 }
4208
4209 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4210                                   unsigned int flag)
4211 {
4212         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4213                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4214         if (pin_ctl & flag)
4215                 snd_hda_codec_write_cache(codec, nid, 0,
4216                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4217                                           pin_ctl & ~flag);
4218 }
4219
4220 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4221 {
4222         if (!nid)
4223                 return 0;
4224         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4225             & (1 << 31))
4226                 return 1;
4227         return 0;
4228 }
4229
4230 /* return non-zero if the hp-pin of the given array index isn't
4231  * a jack-detection target
4232  */
4233 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4234 {
4235         struct auto_pin_cfg *cfg = &spec->autocfg;
4236
4237         /* ignore sensing of shared line and mic jacks */
4238         if (cfg->hp_pins[i] == spec->line_switch)
4239                 return 1;
4240         if (cfg->hp_pins[i] == spec->mic_switch)
4241                 return 1;
4242         /* ignore if the pin is set as line-out */
4243         if (cfg->hp_pins[i] == spec->hp_switch)
4244                 return 1;
4245         return 0;
4246 }
4247
4248 static void stac92xx_hp_detect(struct hda_codec *codec)
4249 {
4250         struct sigmatel_spec *spec = codec->spec;
4251         struct auto_pin_cfg *cfg = &spec->autocfg;
4252         int i, presence;
4253
4254         presence = 0;
4255         if (spec->gpio_mute)
4256                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4257                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4258
4259         for (i = 0; i < cfg->hp_outs; i++) {
4260                 if (presence)
4261                         break;
4262                 if (no_hp_sensing(spec, i))
4263                         continue;
4264                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4265                 if (presence) {
4266                         unsigned int pinctl;
4267                         pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4268                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4269                         if (pinctl & AC_PINCTL_IN_EN)
4270                                 presence = 0; /* mic- or line-input */
4271                 }
4272         }
4273
4274         if (presence) {
4275                 /* disable lineouts */
4276                 if (spec->hp_switch)
4277                         stac92xx_reset_pinctl(codec, spec->hp_switch,
4278                                               AC_PINCTL_OUT_EN);
4279                 for (i = 0; i < cfg->line_outs; i++)
4280                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4281                                                 AC_PINCTL_OUT_EN);
4282                 for (i = 0; i < cfg->speaker_outs; i++)
4283                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4284                                                 AC_PINCTL_OUT_EN);
4285                 if (spec->eapd_mask && spec->eapd_switch)
4286                         stac_gpio_set(codec, spec->gpio_mask,
4287                                 spec->gpio_dir, spec->gpio_data &
4288                                 ~spec->eapd_mask);
4289         } else {
4290                 /* enable lineouts */
4291                 if (spec->hp_switch)
4292                         stac92xx_set_pinctl(codec, spec->hp_switch,
4293                                             AC_PINCTL_OUT_EN);
4294                 for (i = 0; i < cfg->line_outs; i++)
4295                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4296                                                 AC_PINCTL_OUT_EN);
4297                 for (i = 0; i < cfg->speaker_outs; i++)
4298                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4299                                                 AC_PINCTL_OUT_EN);
4300                 if (spec->eapd_mask && spec->eapd_switch)
4301                         stac_gpio_set(codec, spec->gpio_mask,
4302                                 spec->gpio_dir, spec->gpio_data |
4303                                 spec->eapd_mask);
4304         }
4305         /* toggle hp outs */
4306         for (i = 0; i < cfg->hp_outs; i++) {
4307                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4308                 if (no_hp_sensing(spec, i))
4309                         continue;
4310                 if (presence)
4311                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4312 #if 0 /* FIXME */
4313 /* Resetting the pinctl like below may lead to (a sort of) regressions
4314  * on some devices since they use the HP pin actually for line/speaker
4315  * outs although the default pin config shows a different pin (that is
4316  * wrong and useless).
4317  *
4318  * So, it's basically a problem of default pin configs, likely a BIOS issue.
4319  * But, disabling the code below just works around it, and I'm too tired of
4320  * bug reports with such devices...
4321  */
4322                 else
4323                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4324 #endif /* FIXME */
4325         }
4326 }
4327
4328 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4329                                   int enable)
4330 {
4331         struct sigmatel_spec *spec = codec->spec;
4332         unsigned int idx, val;
4333
4334         for (idx = 0; idx < spec->num_pwrs; idx++) {
4335                 if (spec->pwr_nids[idx] == nid)
4336                         break;
4337         }
4338         if (idx >= spec->num_pwrs)
4339                 return;
4340
4341         /* several codecs have two power down bits */
4342         if (spec->pwr_mapping)
4343                 idx = spec->pwr_mapping[idx];
4344         else
4345                 idx = 1 << idx;
4346
4347         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4348         if (enable)
4349                 val &= ~idx;
4350         else
4351                 val |= idx;
4352
4353         /* power down unused output ports */
4354         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4355 }
4356
4357 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4358 {
4359         stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4360 }
4361
4362 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4363 {
4364         struct sigmatel_spec *spec = codec->spec;
4365         struct sigmatel_jack *jacks = spec->jacks.list;
4366
4367         if (jacks) {
4368                 int i;
4369                 for (i = 0; i < spec->jacks.used; i++) {
4370                         if (jacks->nid == nid) {
4371                                 unsigned int pin_ctl =
4372                                         snd_hda_codec_read(codec, nid,
4373                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4374                                          0x00);
4375                                 int type = jacks->type;
4376                                 if (type == (SND_JACK_LINEOUT
4377                                                 | SND_JACK_HEADPHONE))
4378                                         type = (pin_ctl & AC_PINCTL_HP_EN)
4379                                         ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4380                                 snd_jack_report(jacks->jack,
4381                                         get_pin_presence(codec, nid)
4382                                         ? type : 0);
4383                         }
4384                         jacks++;
4385                 }
4386         }
4387 }
4388
4389 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4390                                    unsigned char type)
4391 {
4392         struct sigmatel_event *event = stac_get_event(codec, nid, type);
4393         if (!event)
4394                 return;
4395         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4396 }
4397
4398 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4399 {
4400         struct sigmatel_spec *spec = codec->spec;
4401         struct sigmatel_event *event;
4402         int tag, data;
4403
4404         tag = (res >> 26) & 0x7f;
4405         event = stac_get_event_from_tag(codec, tag);
4406         if (!event)
4407                 return;
4408
4409         switch (event->type) {
4410         case STAC_HP_EVENT:
4411                 stac92xx_hp_detect(codec);
4412                 /* fallthru */
4413         case STAC_INSERT_EVENT:
4414         case STAC_PWR_EVENT:
4415                 if (spec->num_pwrs > 0)
4416                         stac92xx_pin_sense(codec, event->nid);
4417                 stac92xx_report_jack(codec, event->nid);
4418                 break;
4419         case STAC_VREF_EVENT:
4420                 data = snd_hda_codec_read(codec, codec->afg, 0,
4421                                           AC_VERB_GET_GPIO_DATA, 0);
4422                 /* toggle VREF state based on GPIOx status */
4423                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4424                                     !!(data & (1 << event->data)));
4425                 break;
4426         }
4427 }
4428
4429 #ifdef CONFIG_PROC_FS
4430 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4431                                struct hda_codec *codec, hda_nid_t nid)
4432 {
4433         if (nid == codec->afg)
4434                 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4435                             snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4436 }
4437
4438 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4439                                   struct hda_codec *codec,
4440                                   unsigned int verb)
4441 {
4442         snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4443                     snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4444 }
4445
4446 /* stac92hd71bxx, stac92hd73xx */
4447 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4448                                  struct hda_codec *codec, hda_nid_t nid)
4449 {
4450         stac92hd_proc_hook(buffer, codec, nid);
4451         if (nid == codec->afg)
4452                 analog_loop_proc_hook(buffer, codec, 0xfa0);
4453 }
4454
4455 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4456                                struct hda_codec *codec, hda_nid_t nid)
4457 {
4458         if (nid == codec->afg)
4459                 analog_loop_proc_hook(buffer, codec, 0xfe0);
4460 }
4461
4462 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4463                                struct hda_codec *codec, hda_nid_t nid)
4464 {
4465         if (nid == codec->afg)
4466                 analog_loop_proc_hook(buffer, codec, 0xfeb);
4467 }
4468 #else
4469 #define stac92hd_proc_hook      NULL
4470 #define stac92hd7x_proc_hook    NULL
4471 #define stac9205_proc_hook      NULL
4472 #define stac927x_proc_hook      NULL
4473 #endif
4474
4475 #ifdef SND_HDA_NEEDS_RESUME
4476 static int stac92xx_resume(struct hda_codec *codec)
4477 {
4478         struct sigmatel_spec *spec = codec->spec;
4479
4480         stac92xx_init(codec);
4481         snd_hda_codec_resume_amp(codec);
4482         snd_hda_codec_resume_cache(codec);
4483         /* fake event to set up pins again to override cached values */
4484         if (spec->hp_detect)
4485                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4486                                        STAC_HP_EVENT);
4487         return 0;
4488 }
4489
4490
4491 /*
4492  * using power check for controlling mute led of HP HDX notebooks
4493  * check for mute state only on Speakers (nid = 0x10)
4494  *
4495  * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4496  * the LED is NOT working properly !
4497  */
4498
4499 #ifdef CONFIG_SND_HDA_POWER_SAVE
4500 static int stac92xx_hp_hdx_check_power_status(struct hda_codec *codec,
4501                                               hda_nid_t nid)
4502 {
4503         struct sigmatel_spec *spec = codec->spec;
4504
4505         if (nid == 0x10) {
4506                 if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4507                     HDA_AMP_MUTE)
4508                         spec->gpio_data &= ~0x08;  /* orange */
4509                 else
4510                         spec->gpio_data |= 0x08;   /* white */
4511
4512                 stac_gpio_set(codec, spec->gpio_mask,
4513                               spec->gpio_dir,
4514                               spec->gpio_data);
4515         }
4516
4517         return 0;
4518 }
4519 #endif
4520
4521 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4522 {
4523         struct sigmatel_spec *spec = codec->spec;
4524         if (spec->eapd_mask)
4525                 stac_gpio_set(codec, spec->gpio_mask,
4526                                 spec->gpio_dir, spec->gpio_data &
4527                                 ~spec->eapd_mask);
4528         return 0;
4529 }
4530 #endif
4531
4532 static struct hda_codec_ops stac92xx_patch_ops = {
4533         .build_controls = stac92xx_build_controls,
4534         .build_pcms = stac92xx_build_pcms,
4535         .init = stac92xx_init,
4536         .free = stac92xx_free,
4537         .unsol_event = stac92xx_unsol_event,
4538 #ifdef SND_HDA_NEEDS_RESUME
4539         .suspend = stac92xx_suspend,
4540         .resume = stac92xx_resume,
4541 #endif
4542 };
4543
4544 static int patch_stac9200(struct hda_codec *codec)
4545 {
4546         struct sigmatel_spec *spec;
4547         int err;
4548
4549         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4550         if (spec == NULL)
4551                 return -ENOMEM;
4552
4553         codec->spec = spec;
4554         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4555         spec->pin_nids = stac9200_pin_nids;
4556         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4557                                                         stac9200_models,
4558                                                         stac9200_cfg_tbl);
4559         if (spec->board_config < 0)
4560                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4561         else
4562                 stac92xx_set_config_regs(codec,
4563                                          stac9200_brd_tbl[spec->board_config]);
4564
4565         spec->multiout.max_channels = 2;
4566         spec->multiout.num_dacs = 1;
4567         spec->multiout.dac_nids = stac9200_dac_nids;
4568         spec->adc_nids = stac9200_adc_nids;
4569         spec->mux_nids = stac9200_mux_nids;
4570         spec->num_muxes = 1;
4571         spec->num_dmics = 0;
4572         spec->num_adcs = 1;
4573         spec->num_pwrs = 0;
4574
4575         if (spec->board_config == STAC_9200_M4 ||
4576             spec->board_config == STAC_9200_M4_2 ||
4577             spec->board_config == STAC_9200_OQO)
4578                 spec->init = stac9200_eapd_init;
4579         else
4580                 spec->init = stac9200_core_init;
4581         spec->mixer = stac9200_mixer;
4582
4583         if (spec->board_config == STAC_9200_PANASONIC) {
4584                 spec->gpio_mask = spec->gpio_dir = 0x09;
4585                 spec->gpio_data = 0x00;
4586         }
4587
4588         err = stac9200_parse_auto_config(codec);
4589         if (err < 0) {
4590                 stac92xx_free(codec);
4591                 return err;
4592         }
4593
4594         /* CF-74 has no headphone detection, and the driver should *NOT*
4595          * do detection and HP/speaker toggle because the hardware does it.
4596          */
4597         if (spec->board_config == STAC_9200_PANASONIC)
4598                 spec->hp_detect = 0;
4599
4600         codec->patch_ops = stac92xx_patch_ops;
4601
4602         return 0;
4603 }
4604
4605 static int patch_stac925x(struct hda_codec *codec)
4606 {
4607         struct sigmatel_spec *spec;
4608         int err;
4609
4610         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4611         if (spec == NULL)
4612                 return -ENOMEM;
4613
4614         codec->spec = spec;
4615         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4616         spec->pin_nids = stac925x_pin_nids;
4617
4618         /* Check first for codec ID */
4619         spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4620                                                         STAC_925x_MODELS,
4621                                                         stac925x_models,
4622                                                         stac925x_codec_id_cfg_tbl);
4623
4624         /* Now checks for PCI ID, if codec ID is not found */
4625         if (spec->board_config < 0)
4626                 spec->board_config = snd_hda_check_board_config(codec,
4627                                                         STAC_925x_MODELS,
4628                                                         stac925x_models,
4629                                                         stac925x_cfg_tbl);
4630  again:
4631         if (spec->board_config < 0)
4632                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4633                                       "using BIOS defaults\n");
4634         else
4635                 stac92xx_set_config_regs(codec,
4636                                          stac925x_brd_tbl[spec->board_config]);
4637
4638         spec->multiout.max_channels = 2;
4639         spec->multiout.num_dacs = 1;
4640         spec->multiout.dac_nids = stac925x_dac_nids;
4641         spec->adc_nids = stac925x_adc_nids;
4642         spec->mux_nids = stac925x_mux_nids;
4643         spec->num_muxes = 1;
4644         spec->num_adcs = 1;
4645         spec->num_pwrs = 0;
4646         switch (codec->vendor_id) {
4647         case 0x83847632: /* STAC9202  */
4648         case 0x83847633: /* STAC9202D */
4649         case 0x83847636: /* STAC9251  */
4650         case 0x83847637: /* STAC9251D */
4651                 spec->num_dmics = STAC925X_NUM_DMICS;
4652                 spec->dmic_nids = stac925x_dmic_nids;
4653                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4654                 spec->dmux_nids = stac925x_dmux_nids;
4655                 break;
4656         default:
4657                 spec->num_dmics = 0;
4658                 break;
4659         }
4660
4661         spec->init = stac925x_core_init;
4662         spec->mixer = stac925x_mixer;
4663
4664         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4665         if (!err) {
4666                 if (spec->board_config < 0) {
4667                         printk(KERN_WARNING "hda_codec: No auto-config is "
4668                                "available, default to model=ref\n");
4669                         spec->board_config = STAC_925x_REF;
4670                         goto again;
4671                 }
4672                 err = -EINVAL;
4673         }
4674         if (err < 0) {
4675                 stac92xx_free(codec);
4676                 return err;
4677         }
4678
4679         codec->patch_ops = stac92xx_patch_ops;
4680
4681         return 0;
4682 }
4683
4684 static struct hda_input_mux stac92hd73xx_dmux = {
4685         .num_items = 4,
4686         .items = {
4687                 { "Analog Inputs", 0x0b },
4688                 { "Digital Mic 1", 0x09 },
4689                 { "Digital Mic 2", 0x0a },
4690                 { "CD", 0x08 },
4691         }
4692 };
4693
4694 static int patch_stac92hd73xx(struct hda_codec *codec)
4695 {
4696         struct sigmatel_spec *spec;
4697         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4698         int err = 0;
4699         int num_dacs;
4700
4701         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4702         if (spec == NULL)
4703                 return -ENOMEM;
4704
4705         codec->spec = spec;
4706         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4707         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4708         spec->pin_nids = stac92hd73xx_pin_nids;
4709         spec->board_config = snd_hda_check_board_config(codec,
4710                                                         STAC_92HD73XX_MODELS,
4711                                                         stac92hd73xx_models,
4712                                                         stac92hd73xx_cfg_tbl);
4713 again:
4714         if (spec->board_config < 0)
4715                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4716                         " STAC92HD73XX, using BIOS defaults\n");
4717         else
4718                 stac92xx_set_config_regs(codec,
4719                                 stac92hd73xx_brd_tbl[spec->board_config]);
4720
4721         num_dacs = snd_hda_get_connections(codec, 0x0a,
4722                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
4723
4724         if (num_dacs < 3 || num_dacs > 5) {
4725                 printk(KERN_WARNING "hda_codec: Could not determine "
4726                        "number of channels defaulting to DAC count\n");
4727                 num_dacs = STAC92HD73_DAC_COUNT;
4728         }
4729         switch (num_dacs) {
4730         case 0x3: /* 6 Channel */
4731                 spec->mixer = stac92hd73xx_6ch_mixer;
4732                 spec->init = stac92hd73xx_6ch_core_init;
4733                 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
4734                 break;
4735         case 0x4: /* 8 Channel */
4736                 spec->mixer = stac92hd73xx_8ch_mixer;
4737                 spec->init = stac92hd73xx_8ch_core_init;
4738                 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
4739                 break;
4740         case 0x5: /* 10 Channel */
4741                 spec->mixer = stac92hd73xx_10ch_mixer;
4742                 spec->init = stac92hd73xx_10ch_core_init;
4743                 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
4744                 break;
4745         }
4746         spec->multiout.dac_nids = spec->dac_nids;
4747
4748         spec->aloopback_mask = 0x01;
4749         spec->aloopback_shift = 8;
4750
4751         spec->digbeep_nid = 0x1c;
4752         spec->mux_nids = stac92hd73xx_mux_nids;
4753         spec->adc_nids = stac92hd73xx_adc_nids;
4754         spec->dmic_nids = stac92hd73xx_dmic_nids;
4755         spec->dmux_nids = stac92hd73xx_dmux_nids;
4756         spec->smux_nids = stac92hd73xx_smux_nids;
4757         spec->amp_nids = stac92hd73xx_amp_nids;
4758         spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4759
4760         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4761         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4762         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4763         memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4764                         sizeof(stac92hd73xx_dmux));
4765
4766         switch (spec->board_config) {
4767         case STAC_DELL_EQ:
4768                 spec->init = dell_eq_core_init;
4769                 /* fallthru */
4770         case STAC_DELL_M6_AMIC:
4771         case STAC_DELL_M6_DMIC:
4772         case STAC_DELL_M6_BOTH:
4773                 spec->num_smuxes = 0;
4774                 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4775                 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4776                 spec->eapd_switch = 0;
4777                 spec->num_amps = 1;
4778
4779                 if (spec->board_config != STAC_DELL_EQ)
4780                         spec->init = dell_m6_core_init;
4781                 switch (spec->board_config) {
4782                 case STAC_DELL_M6_AMIC: /* Analog Mics */
4783                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4784                         spec->num_dmics = 0;
4785                         spec->private_dimux.num_items = 1;
4786                         break;
4787                 case STAC_DELL_M6_DMIC: /* Digital Mics */
4788                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4789                         spec->num_dmics = 1;
4790                         spec->private_dimux.num_items = 2;
4791                         break;
4792                 case STAC_DELL_M6_BOTH: /* Both */
4793                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4794                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4795                         spec->num_dmics = 1;
4796                         spec->private_dimux.num_items = 2;
4797                         break;
4798                 }
4799                 break;
4800         default:
4801                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4802                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4803                 spec->eapd_switch = 1;
4804         }
4805         if (spec->board_config > STAC_92HD73XX_REF) {
4806                 /* GPIO0 High = Enable EAPD */
4807                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4808                 spec->gpio_data = 0x01;
4809         }
4810         spec->dinput_mux = &spec->private_dimux;
4811
4812         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4813         spec->pwr_nids = stac92hd73xx_pwr_nids;
4814
4815         err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4816
4817         if (!err) {
4818                 if (spec->board_config < 0) {
4819                         printk(KERN_WARNING "hda_codec: No auto-config is "
4820                                "available, default to model=ref\n");
4821                         spec->board_config = STAC_92HD73XX_REF;
4822                         goto again;
4823                 }
4824                 err = -EINVAL;
4825         }
4826
4827         if (err < 0) {
4828                 stac92xx_free(codec);
4829                 return err;
4830         }
4831
4832         if (spec->board_config == STAC_92HD73XX_NO_JD)
4833                 spec->hp_detect = 0;
4834
4835         codec->patch_ops = stac92xx_patch_ops;
4836
4837         codec->proc_widget_hook = stac92hd7x_proc_hook;
4838
4839         return 0;
4840 }
4841
4842 static struct hda_input_mux stac92hd83xxx_dmux = {
4843         .num_items = 3,
4844         .items = {
4845                 { "Analog Inputs", 0x03 },
4846                 { "Digital Mic 1", 0x04 },
4847                 { "Digital Mic 2", 0x05 },
4848         }
4849 };
4850
4851 static int patch_stac92hd83xxx(struct hda_codec *codec)
4852 {
4853         struct sigmatel_spec *spec;
4854         hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4855         int err;
4856         int num_dacs;
4857         hda_nid_t nid;
4858
4859         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4860         if (spec == NULL)
4861                 return -ENOMEM;
4862
4863         codec->spec = spec;
4864         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4865         spec->mono_nid = 0x19;
4866         spec->digbeep_nid = 0x21;
4867         spec->dmic_nids = stac92hd83xxx_dmic_nids;
4868         spec->dmux_nids = stac92hd83xxx_dmux_nids;
4869         spec->adc_nids = stac92hd83xxx_adc_nids;
4870         spec->pwr_nids = stac92hd83xxx_pwr_nids;
4871         spec->amp_nids = stac92hd83xxx_amp_nids;
4872         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4873         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4874         spec->multiout.dac_nids = spec->dac_nids;
4875
4876         spec->init = stac92hd83xxx_core_init;
4877         spec->mixer = stac92hd83xxx_mixer;
4878         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4879         spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4880         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4881         spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4882         spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4883         spec->dinput_mux = &stac92hd83xxx_dmux;
4884         spec->pin_nids = stac92hd83xxx_pin_nids;
4885         spec->board_config = snd_hda_check_board_config(codec,
4886                                                         STAC_92HD83XXX_MODELS,
4887                                                         stac92hd83xxx_models,
4888                                                         stac92hd83xxx_cfg_tbl);
4889 again:
4890         if (spec->board_config < 0)
4891                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4892                         " STAC92HD83XXX, using BIOS defaults\n");
4893         else
4894                 stac92xx_set_config_regs(codec,
4895                                 stac92hd83xxx_brd_tbl[spec->board_config]);
4896
4897         switch (codec->vendor_id) {
4898         case 0x111d7604:
4899         case 0x111d7605:
4900                 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4901                         break;
4902                 spec->num_pwrs = 0;
4903                 break;
4904         }
4905
4906         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4907         if (!err) {
4908                 if (spec->board_config < 0) {
4909                         printk(KERN_WARNING "hda_codec: No auto-config is "
4910                                "available, default to model=ref\n");
4911                         spec->board_config = STAC_92HD83XXX_REF;
4912                         goto again;
4913                 }
4914                 err = -EINVAL;
4915         }
4916
4917         if (err < 0) {
4918                 stac92xx_free(codec);
4919                 return err;
4920         }
4921
4922         switch (spec->board_config) {
4923         case STAC_DELL_S14:
4924                 nid = 0xf;
4925                 break;
4926         default:
4927                 nid = 0xe;
4928                 break;
4929         }
4930
4931         num_dacs = snd_hda_get_connections(codec, nid,
4932                                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4933
4934         /* set port X to select the last DAC
4935          */
4936         snd_hda_codec_write_cache(codec, nid, 0,
4937                         AC_VERB_SET_CONNECT_SEL, num_dacs);
4938
4939         codec->patch_ops = stac92xx_patch_ops;
4940
4941         codec->proc_widget_hook = stac92hd_proc_hook;
4942
4943         return 0;
4944 }
4945
4946 static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
4947         .num_items = 3,
4948         .items = {
4949                 { "Analog Inputs", 0x00 },
4950                 { "Digital Mic 1", 0x02 },
4951                 { "Digital Mic 2", 0x03 },
4952         }
4953 };
4954
4955 static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
4956         .num_items = 4,
4957         .items = {
4958                 { "Analog Inputs", 0x00 },
4959                 { "Mixer", 0x01 },
4960                 { "Digital Mic 1", 0x02 },
4961                 { "Digital Mic 2", 0x03 },
4962         }
4963 };
4964
4965 /* get the pin connection (fixed, none, etc) */
4966 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4967 {
4968         struct sigmatel_spec *spec = codec->spec;
4969         unsigned int cfg;
4970
4971         cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4972         return get_defcfg_connect(cfg);
4973 }
4974
4975 static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
4976                                          hda_nid_t *nids, int num_nids)
4977 {
4978         struct sigmatel_spec *spec = codec->spec;
4979         int idx, num;
4980         unsigned int def_conf;
4981
4982         for (num = 0; num < num_nids; num++) {
4983                 for (idx = 0; idx < spec->num_pins; idx++)
4984                         if (spec->pin_nids[idx] == nids[num])
4985                                 break;
4986                 if (idx >= spec->num_pins)
4987                         break;
4988                 def_conf = stac_get_defcfg_connect(codec, idx);
4989                 if (def_conf == AC_JACK_PORT_NONE)
4990                         break;
4991         }
4992         return num;
4993 }
4994
4995 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
4996                                           hda_nid_t dig0pin)
4997 {
4998         struct sigmatel_spec *spec = codec->spec;
4999         int idx;
5000
5001         for (idx = 0; idx < spec->num_pins; idx++)
5002                 if (spec->pin_nids[idx] == dig0pin)
5003                         break;
5004         if ((idx + 2) >= spec->num_pins)
5005                 return 0;
5006
5007         /* dig1pin case */
5008         if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5009                 return 2;
5010
5011         /* dig0pin + dig2pin case */
5012         if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5013                 return 2;
5014         if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5015                 return 1;
5016         else
5017                 return 0;
5018 }
5019
5020 static int patch_stac92hd71bxx(struct hda_codec *codec)
5021 {
5022         struct sigmatel_spec *spec;
5023         struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5024         int err = 0;
5025         unsigned int ndmic_nids = 0;
5026
5027         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5028         if (spec == NULL)
5029                 return -ENOMEM;
5030
5031         codec->spec = spec;
5032         codec->patch_ops = stac92xx_patch_ops;
5033         spec->num_pins = STAC92HD71BXX_NUM_PINS;
5034         switch (codec->vendor_id) {
5035         case 0x111d76b6:
5036         case 0x111d76b7:
5037                 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5038                 break;
5039         case 0x111d7603:
5040         case 0x111d7608:
5041                 /* On 92HD75Bx 0x27 isn't a pin nid */
5042                 spec->num_pins--;
5043                 /* fallthrough */
5044         default:
5045                 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5046         }
5047         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5048         spec->board_config = snd_hda_check_board_config(codec,
5049                                                         STAC_92HD71BXX_MODELS,
5050                                                         stac92hd71bxx_models,
5051                                                         stac92hd71bxx_cfg_tbl);
5052 again:
5053         if (spec->board_config < 0)
5054                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5055                         " STAC92HD71BXX, using BIOS defaults\n");
5056         else
5057                 stac92xx_set_config_regs(codec,
5058                                 stac92hd71bxx_brd_tbl[spec->board_config]);
5059
5060         if (spec->board_config > STAC_92HD71BXX_REF) {
5061                 /* GPIO0 = EAPD */
5062                 spec->gpio_mask = 0x01;
5063                 spec->gpio_dir = 0x01;
5064                 spec->gpio_data = 0x01;
5065         }
5066
5067         spec->dmic_nids = stac92hd71bxx_dmic_nids;
5068         spec->dmux_nids = stac92hd71bxx_dmux_nids;
5069
5070         switch (codec->vendor_id) {
5071         case 0x111d76b6: /* 4 Port without Analog Mixer */
5072         case 0x111d76b7:
5073                 unmute_init++;
5074                 /* fallthru */
5075         case 0x111d76b4: /* 6 Port without Analog Mixer */
5076         case 0x111d76b5:
5077                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
5078                        sizeof(stac92hd71bxx_dmux_nomixer));
5079                 spec->mixer = stac92hd71bxx_mixer;
5080                 spec->init = stac92hd71bxx_core_init;
5081                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5082                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5083                                         stac92hd71bxx_dmic_nids,
5084                                         STAC92HD71BXX_NUM_DMICS);
5085                 if (spec->num_dmics) {
5086                         spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5087                         spec->dinput_mux = &spec->private_dimux;
5088                         ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5089                 }
5090                 break;
5091         case 0x111d7608: /* 5 Port with Analog Mixer */
5092                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5093                        sizeof(stac92hd71bxx_dmux_amixer));
5094                 spec->private_dimux.num_items--;
5095                 switch (spec->board_config) {
5096                 case STAC_HP_M4:
5097                         /* Enable VREF power saving on GPIO1 detect */
5098                         err = stac_add_event(spec, codec->afg,
5099                                              STAC_VREF_EVENT, 0x02);
5100                         if (err < 0)
5101                                 return err;
5102                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5103                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5104                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5105                                 AC_VERB_SET_UNSOLICITED_ENABLE,
5106                                 AC_USRSP_EN | err);
5107                         spec->gpio_mask |= 0x02;
5108                         break;
5109                 }
5110                 if ((codec->revision_id & 0xf) == 0 ||
5111                     (codec->revision_id & 0xf) == 1)
5112                         spec->stream_delay = 40; /* 40 milliseconds */
5113
5114                 /* no output amps */
5115                 spec->num_pwrs = 0;
5116                 spec->mixer = stac92hd71bxx_analog_mixer;
5117                 spec->dinput_mux = &spec->private_dimux;
5118
5119                 /* disable VSW */
5120                 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
5121                 unmute_init++;
5122                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5123                 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5124                 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5125                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5126                                         stac92hd71bxx_dmic_nids,
5127                                         STAC92HD71BXX_NUM_DMICS - 1);
5128                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5129                 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
5130                 break;
5131         case 0x111d7603: /* 6 Port with Analog Mixer */
5132                 if ((codec->revision_id & 0xf) == 1)
5133                         spec->stream_delay = 40; /* 40 milliseconds */
5134
5135                 /* no output amps */
5136                 spec->num_pwrs = 0;
5137                 /* fallthru */
5138         default:
5139                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5140                        sizeof(stac92hd71bxx_dmux_amixer));
5141                 spec->dinput_mux = &spec->private_dimux;
5142                 spec->mixer = stac92hd71bxx_analog_mixer;
5143                 spec->init = stac92hd71bxx_analog_core_init;
5144                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5145                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5146                                         stac92hd71bxx_dmic_nids,
5147                                         STAC92HD71BXX_NUM_DMICS);
5148                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5149                 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5150         }
5151
5152         if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5153                 snd_hda_sequence_write_cache(codec, unmute_init);
5154
5155         spec->aloopback_ctl = stac92hd71bxx_loopback;
5156         spec->aloopback_mask = 0x50;
5157         spec->aloopback_shift = 0;
5158
5159         spec->powerdown_adcs = 1;
5160         spec->digbeep_nid = 0x26;
5161         spec->mux_nids = stac92hd71bxx_mux_nids;
5162         spec->adc_nids = stac92hd71bxx_adc_nids;
5163         spec->smux_nids = stac92hd71bxx_smux_nids;
5164         spec->pwr_nids = stac92hd71bxx_pwr_nids;
5165
5166         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5167         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5168         spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5169
5170         switch (spec->board_config) {
5171         case STAC_HP_M4:
5172                 /* enable internal microphone */
5173                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5174                 stac92xx_auto_set_pinctl(codec, 0x0e,
5175                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5176                 /* fallthru */
5177         case STAC_DELL_M4_2:
5178                 spec->num_dmics = 0;
5179                 spec->num_smuxes = 0;
5180                 spec->num_dmuxes = 0;
5181                 break;
5182         case STAC_DELL_M4_1:
5183         case STAC_DELL_M4_3:
5184                 spec->num_dmics = 1;
5185                 spec->num_smuxes = 0;
5186                 spec->num_dmuxes = 1;
5187                 break;
5188         case STAC_HP_DV5:
5189                 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5190                 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5191                 break;
5192         case STAC_HP_HDX:
5193                 spec->num_dmics = 1;
5194                 spec->num_dmuxes = 1;
5195                 spec->num_smuxes = 1;
5196                 /*
5197                  * For controlling MUTE LED on HP HDX16/HDX18 notebooks,
5198                  * the CONFIG_SND_HDA_POWER_SAVE is needed to be set.
5199                  */
5200 #ifdef CONFIG_SND_HDA_POWER_SAVE
5201                 /* orange/white mute led on GPIO3, orange=0, white=1 */
5202                 spec->gpio_mask |= 0x08;
5203                 spec->gpio_dir  |= 0x08;
5204                 spec->gpio_data |= 0x08;  /* set to white */
5205
5206                 /* register check_power_status callback. */
5207                 codec->patch_ops.check_power_status =
5208                     stac92xx_hp_hdx_check_power_status;
5209 #endif
5210                 break;
5211         };
5212
5213         spec->multiout.dac_nids = spec->dac_nids;
5214         if (spec->dinput_mux)
5215                 spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
5216
5217         err = stac92xx_parse_auto_config(codec, 0x21, 0);
5218         if (!err) {
5219                 if (spec->board_config < 0) {
5220                         printk(KERN_WARNING "hda_codec: No auto-config is "
5221                                "available, default to model=ref\n");
5222                         spec->board_config = STAC_92HD71BXX_REF;
5223                         goto again;
5224                 }
5225                 err = -EINVAL;
5226         }
5227
5228         if (err < 0) {
5229                 stac92xx_free(codec);
5230                 return err;
5231         }
5232
5233         codec->proc_widget_hook = stac92hd7x_proc_hook;
5234
5235         return 0;
5236 };
5237
5238 static int patch_stac922x(struct hda_codec *codec)
5239 {
5240         struct sigmatel_spec *spec;
5241         int err;
5242
5243         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5244         if (spec == NULL)
5245                 return -ENOMEM;
5246
5247         codec->spec = spec;
5248         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5249         spec->pin_nids = stac922x_pin_nids;
5250         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5251                                                         stac922x_models,
5252                                                         stac922x_cfg_tbl);
5253         if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5254                 spec->gpio_mask = spec->gpio_dir = 0x03;
5255                 spec->gpio_data = 0x03;
5256                 /* Intel Macs have all same PCI SSID, so we need to check
5257                  * codec SSID to distinguish the exact models
5258                  */
5259                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5260                 switch (codec->subsystem_id) {
5261
5262                 case 0x106b0800:
5263                         spec->board_config = STAC_INTEL_MAC_V1;
5264                         break;
5265                 case 0x106b0600:
5266                 case 0x106b0700:
5267                         spec->board_config = STAC_INTEL_MAC_V2;
5268                         break;
5269                 case 0x106b0e00:
5270                 case 0x106b0f00:
5271                 case 0x106b1600:
5272                 case 0x106b1700:
5273                 case 0x106b0200:
5274                 case 0x106b1e00:
5275                         spec->board_config = STAC_INTEL_MAC_V3;
5276                         break;
5277                 case 0x106b1a00:
5278                 case 0x00000100:
5279                         spec->board_config = STAC_INTEL_MAC_V4;
5280                         break;
5281                 case 0x106b0a00:
5282                 case 0x106b2200:
5283                         spec->board_config = STAC_INTEL_MAC_V5;
5284                         break;
5285                 default:
5286                         spec->board_config = STAC_INTEL_MAC_V3;
5287                         break;
5288                 }
5289         }
5290
5291  again:
5292         if (spec->board_config < 0)
5293                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5294                         "using BIOS defaults\n");
5295         else
5296                 stac92xx_set_config_regs(codec,
5297                                 stac922x_brd_tbl[spec->board_config]);
5298
5299         spec->adc_nids = stac922x_adc_nids;
5300         spec->mux_nids = stac922x_mux_nids;
5301         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5302         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5303         spec->num_dmics = 0;
5304         spec->num_pwrs = 0;
5305
5306         spec->init = stac922x_core_init;
5307         spec->mixer = stac922x_mixer;
5308
5309         spec->multiout.dac_nids = spec->dac_nids;
5310
5311         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5312         if (!err) {
5313                 if (spec->board_config < 0) {
5314                         printk(KERN_WARNING "hda_codec: No auto-config is "
5315                                "available, default to model=ref\n");
5316                         spec->board_config = STAC_D945_REF;
5317                         goto again;
5318                 }
5319                 err = -EINVAL;
5320         }
5321         if (err < 0) {
5322                 stac92xx_free(codec);
5323                 return err;
5324         }
5325
5326         codec->patch_ops = stac92xx_patch_ops;
5327
5328         /* Fix Mux capture level; max to 2 */
5329         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5330                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
5331                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5332                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5333                                   (0 << AC_AMPCAP_MUTE_SHIFT));
5334
5335         return 0;
5336 }
5337
5338 static int patch_stac927x(struct hda_codec *codec)
5339 {
5340         struct sigmatel_spec *spec;
5341         int err;
5342
5343         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5344         if (spec == NULL)
5345                 return -ENOMEM;
5346
5347         codec->spec = spec;
5348         codec->slave_dig_outs = stac927x_slave_dig_outs;
5349         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5350         spec->pin_nids = stac927x_pin_nids;
5351         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5352                                                         stac927x_models,
5353                                                         stac927x_cfg_tbl);
5354  again:
5355         if (spec->board_config < 0)
5356                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5357                             "STAC927x, using BIOS defaults\n");
5358         else
5359                 stac92xx_set_config_regs(codec,
5360                                 stac927x_brd_tbl[spec->board_config]);
5361
5362         spec->digbeep_nid = 0x23;
5363         spec->adc_nids = stac927x_adc_nids;
5364         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5365         spec->mux_nids = stac927x_mux_nids;
5366         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5367         spec->smux_nids = stac927x_smux_nids;
5368         spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5369         spec->spdif_labels = stac927x_spdif_labels;
5370         spec->dac_list = stac927x_dac_nids;
5371         spec->multiout.dac_nids = spec->dac_nids;
5372
5373         switch (spec->board_config) {
5374         case STAC_D965_3ST:
5375         case STAC_D965_5ST:
5376                 /* GPIO0 High = Enable EAPD */
5377                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5378                 spec->gpio_data = 0x01;
5379                 spec->num_dmics = 0;
5380
5381                 spec->init = d965_core_init;
5382                 spec->mixer = stac927x_mixer;
5383                 break;
5384         case STAC_DELL_BIOS:
5385                 switch (codec->subsystem_id) {
5386                 case 0x10280209:
5387                 case 0x1028022e:
5388                         /* correct the device field to SPDIF out */
5389                         snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5390                         break;
5391                 };
5392                 /* configure the analog microphone on some laptops */
5393                 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5394                 /* correct the front output jack as a hp out */
5395                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5396                 /* correct the front input jack as a mic */
5397                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5398                 /* fallthru */
5399         case STAC_DELL_3ST:
5400                 /* GPIO2 High = Enable EAPD */
5401                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5402                 spec->gpio_data = 0x04;
5403                 spec->dmic_nids = stac927x_dmic_nids;
5404                 spec->num_dmics = STAC927X_NUM_DMICS;
5405
5406                 spec->init = d965_core_init;
5407                 spec->mixer = stac927x_mixer;
5408                 spec->dmux_nids = stac927x_dmux_nids;
5409                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5410                 break;
5411         default:
5412                 if (spec->board_config > STAC_D965_REF) {
5413                         /* GPIO0 High = Enable EAPD */
5414                         spec->eapd_mask = spec->gpio_mask = 0x01;
5415                         spec->gpio_dir = spec->gpio_data = 0x01;
5416                 }
5417                 spec->num_dmics = 0;
5418
5419                 spec->init = stac927x_core_init;
5420                 spec->mixer = stac927x_mixer;
5421         }
5422
5423         spec->num_pwrs = 0;
5424         spec->aloopback_ctl = stac927x_loopback;
5425         spec->aloopback_mask = 0x40;
5426         spec->aloopback_shift = 0;
5427         spec->eapd_switch = 1;
5428
5429         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5430         if (!err) {
5431                 if (spec->board_config < 0) {
5432                         printk(KERN_WARNING "hda_codec: No auto-config is "
5433                                "available, default to model=ref\n");
5434                         spec->board_config = STAC_D965_REF;
5435                         goto again;
5436                 }
5437                 err = -EINVAL;
5438         }
5439         if (err < 0) {
5440                 stac92xx_free(codec);
5441                 return err;
5442         }
5443
5444         codec->patch_ops = stac92xx_patch_ops;
5445
5446         codec->proc_widget_hook = stac927x_proc_hook;
5447
5448         /*
5449          * !!FIXME!!
5450          * The STAC927x seem to require fairly long delays for certain
5451          * command sequences.  With too short delays (even if the answer
5452          * is set to RIRB properly), it results in the silence output
5453          * on some hardwares like Dell.
5454          *
5455          * The below flag enables the longer delay (see get_response
5456          * in hda_intel.c).
5457          */
5458         codec->bus->needs_damn_long_delay = 1;
5459
5460         /* no jack detecion for ref-no-jd model */
5461         if (spec->board_config == STAC_D965_REF_NO_JD)
5462                 spec->hp_detect = 0;
5463
5464         return 0;
5465 }
5466
5467 static int patch_stac9205(struct hda_codec *codec)
5468 {
5469         struct sigmatel_spec *spec;
5470         int err;
5471
5472         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5473         if (spec == NULL)
5474                 return -ENOMEM;
5475
5476         codec->spec = spec;
5477         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5478         spec->pin_nids = stac9205_pin_nids;
5479         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5480                                                         stac9205_models,
5481                                                         stac9205_cfg_tbl);
5482  again:
5483         if (spec->board_config < 0)
5484                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5485         else
5486                 stac92xx_set_config_regs(codec,
5487                                          stac9205_brd_tbl[spec->board_config]);
5488
5489         spec->digbeep_nid = 0x23;
5490         spec->adc_nids = stac9205_adc_nids;
5491         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5492         spec->mux_nids = stac9205_mux_nids;
5493         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5494         spec->smux_nids = stac9205_smux_nids;
5495         spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5496         spec->dmic_nids = stac9205_dmic_nids;
5497         spec->num_dmics = STAC9205_NUM_DMICS;
5498         spec->dmux_nids = stac9205_dmux_nids;
5499         spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5500         spec->num_pwrs = 0;
5501
5502         spec->init = stac9205_core_init;
5503         spec->mixer = stac9205_mixer;
5504         spec->aloopback_ctl = stac9205_loopback;
5505
5506         spec->aloopback_mask = 0x40;
5507         spec->aloopback_shift = 0;
5508         /* Turn on/off EAPD per HP plugging */
5509         if (spec->board_config != STAC_9205_EAPD)
5510                 spec->eapd_switch = 1;
5511         spec->multiout.dac_nids = spec->dac_nids;
5512
5513         switch (spec->board_config){
5514         case STAC_9205_DELL_M43:
5515                 /* Enable SPDIF in/out */
5516                 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
5517                 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
5518
5519                 /* Enable unsol response for GPIO4/Dock HP connection */
5520                 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5521                 if (err < 0)
5522                         return err;
5523                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5524                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5525                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5526                                           AC_VERB_SET_UNSOLICITED_ENABLE,
5527                                           AC_USRSP_EN | err);
5528
5529                 spec->gpio_dir = 0x0b;
5530                 spec->eapd_mask = 0x01;
5531                 spec->gpio_mask = 0x1b;
5532                 spec->gpio_mute = 0x10;
5533                 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5534                  * GPIO3 Low = DRM
5535                  */
5536                 spec->gpio_data = 0x01;
5537                 break;
5538         case STAC_9205_REF:
5539                 /* SPDIF-In enabled */
5540                 break;
5541         default:
5542                 /* GPIO0 High = EAPD */
5543                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5544                 spec->gpio_data = 0x01;
5545                 break;
5546         }
5547
5548         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5549         if (!err) {
5550                 if (spec->board_config < 0) {
5551                         printk(KERN_WARNING "hda_codec: No auto-config is "
5552                                "available, default to model=ref\n");
5553                         spec->board_config = STAC_9205_REF;
5554                         goto again;
5555                 }
5556                 err = -EINVAL;
5557         }
5558         if (err < 0) {
5559                 stac92xx_free(codec);
5560                 return err;
5561         }
5562
5563         codec->patch_ops = stac92xx_patch_ops;
5564
5565         codec->proc_widget_hook = stac9205_proc_hook;
5566
5567         return 0;
5568 }
5569
5570 /*
5571  * STAC9872 hack
5572  */
5573
5574 static struct hda_verb stac9872_core_init[] = {
5575         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5576         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5577         {}
5578 };
5579
5580 static struct snd_kcontrol_new stac9872_mixer[] = {
5581         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5582         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5583         { } /* end */
5584 };
5585
5586 static hda_nid_t stac9872_pin_nids[] = {
5587         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
5588         0x11, 0x13, 0x14,
5589 };
5590
5591 static hda_nid_t stac9872_adc_nids[] = {
5592         0x8 /*,0x6*/
5593 };
5594
5595 static hda_nid_t stac9872_mux_nids[] = {
5596         0x15
5597 };
5598
5599 static unsigned int stac9872_vaio_pin_configs[9] = {
5600         0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
5601         0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
5602         0x90a7013e
5603 };
5604
5605 static const char *stac9872_models[STAC_9872_MODELS] = {
5606         [STAC_9872_AUTO] = "auto",
5607         [STAC_9872_VAIO] = "vaio",
5608 };
5609
5610 static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
5611         [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
5612 };
5613
5614 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5615         {} /* terminator */
5616 };
5617
5618 static int patch_stac9872(struct hda_codec *codec)
5619 {
5620         struct sigmatel_spec *spec;
5621         int err;
5622
5623         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5624         if (spec == NULL)
5625                 return -ENOMEM;
5626         codec->spec = spec;
5627
5628         spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5629                                                         stac9872_models,
5630                                                         stac9872_cfg_tbl);
5631         if (spec->board_config < 0)
5632                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9872, "
5633                             "using BIOS defaults\n");
5634         else
5635                 stac92xx_set_config_regs(codec,
5636                                          stac9872_brd_tbl[spec->board_config]);
5637
5638         spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
5639         spec->pin_nids = stac9872_pin_nids;
5640         spec->multiout.dac_nids = spec->dac_nids;
5641         spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
5642         spec->adc_nids = stac9872_adc_nids;
5643         spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
5644         spec->mux_nids = stac9872_mux_nids;
5645         spec->mixer = stac9872_mixer;
5646         spec->init = stac9872_core_init;
5647
5648         err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
5649         if (err < 0) {
5650                 stac92xx_free(codec);
5651                 return -EINVAL;
5652         }
5653         spec->input_mux = &spec->private_imux;
5654         codec->patch_ops = stac92xx_patch_ops;
5655         return 0;
5656 }
5657
5658
5659 /*
5660  * patch entries
5661  */
5662 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5663         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5664         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5665         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5666         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5667         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5668         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5669         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5670         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5671         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5672         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5673         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5674         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5675         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5676         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5677         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5678         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5679         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5680         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5681         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5682         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5683         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5684         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5685         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5686         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
5687         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5688         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5689         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5690         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5691         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5692         { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5693         { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5694         /* The following does not take into account .id=0x83847661 when subsys =
5695          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5696          * currently not fully supported.
5697          */
5698         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5699         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5700         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5701         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5702         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5703         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5704         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5705         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5706         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5707         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5708         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5709         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5710         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5711         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5712         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5713         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5714         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5715         { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5716         { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5717         { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5718         { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5719         { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5720         { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5721         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5722         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5723         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5724         {} /* terminator */
5725 };
5726
5727 MODULE_ALIAS("snd-hda-codec-id:8384*");
5728 MODULE_ALIAS("snd-hda-codec-id:111d*");
5729
5730 MODULE_LICENSE("GPL");
5731 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5732
5733 static struct hda_codec_preset_list sigmatel_list = {
5734         .preset = snd_hda_preset_sigmatel,
5735         .owner = THIS_MODULE,
5736 };
5737
5738 static int __init patch_sigmatel_init(void)
5739 {
5740         return snd_hda_add_codec_preset(&sigmatel_list);
5741 }
5742
5743 static void __exit patch_sigmatel_exit(void)
5744 {
5745         snd_hda_delete_codec_preset(&sigmatel_list);
5746 }
5747
5748 module_init(patch_sigmatel_init)
5749 module_exit(patch_sigmatel_exit)