git.oblomov.eu Git - linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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