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                                 /* Also, if both INPUT and OUTPUT are set,
4083                                  * it must be a BIOS bug; need to override, too
4084                                  */
4085                                 if (!(pinctl & AC_PINCTL_IN_EN) ||
4086                                     (pinctl & AC_PINCTL_OUT_EN)) {
4087                                         pinctl &= ~AC_PINCTL_OUT_EN;
4088                                         pinctl |= AC_PINCTL_IN_EN;
4089                                         stac92xx_auto_set_pinctl(codec, nid,
4090                                                                  pinctl);
4091                                 }
4092                         }
4093                         conf = snd_hda_codec_get_pincfg(codec, nid);
4094                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4095                                 enable_pin_detect(codec, nid,
4096                                                   STAC_INSERT_EVENT);
4097                                 stac_issue_unsol_event(codec, nid,
4098                                                        STAC_INSERT_EVENT);
4099                         }
4100                 }
4101         }
4102         for (i = 0; i < spec->num_dmics; i++)
4103                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4104                                         AC_PINCTL_IN_EN);
4105         if (cfg->dig_out_pins[0])
4106                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4107                                          AC_PINCTL_OUT_EN);
4108         if (cfg->dig_in_pin)
4109                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4110                                          AC_PINCTL_IN_EN);
4111         for (i = 0; i < spec->num_pwrs; i++)  {
4112                 hda_nid_t nid = spec->pwr_nids[i];
4113                 int pinctl, def_conf;
4114
4115                 /* power on when no jack detection is available */
4116                 if (!spec->hp_detect) {
4117                         stac_toggle_power_map(codec, nid, 1);
4118                         continue;
4119                 }
4120
4121                 if (is_nid_hp_pin(cfg, nid))
4122                         continue; /* already has an unsol event */
4123
4124                 pinctl = snd_hda_codec_read(codec, nid, 0,
4125                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4126                 /* outputs are only ports capable of power management
4127                  * any attempts on powering down a input port cause the
4128                  * referenced VREF to act quirky.
4129                  */
4130                 if (pinctl & AC_PINCTL_IN_EN) {
4131                         stac_toggle_power_map(codec, nid, 1);
4132                         continue;
4133                 }
4134                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4135                 def_conf = get_defcfg_connect(def_conf);
4136                 /* skip any ports that don't have jacks since presence
4137                  * detection is useless */
4138                 if (def_conf != AC_JACK_PORT_COMPLEX) {
4139                         if (def_conf != AC_JACK_PORT_NONE)
4140                                 stac_toggle_power_map(codec, nid, 1);
4141                         continue;
4142                 }
4143                 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4144                         enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4145                         stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4146                 }
4147         }
4148         if (spec->dac_list)
4149                 stac92xx_power_down(codec);
4150         return 0;
4151 }
4152
4153 static void stac92xx_free_jacks(struct hda_codec *codec)
4154 {
4155 #ifdef CONFIG_SND_JACK
4156         /* free jack instances manually when clearing/reconfiguring */
4157         struct sigmatel_spec *spec = codec->spec;
4158         if (!codec->bus->shutdown && spec->jacks.list) {
4159                 struct sigmatel_jack *jacks = spec->jacks.list;
4160                 int i;
4161                 for (i = 0; i < spec->jacks.used; i++, jacks++) {
4162                         if (jacks->jack)
4163                                 snd_device_free(codec->bus->card, jacks->jack);
4164                 }
4165         }
4166         snd_array_free(&spec->jacks);
4167 #endif
4168 }
4169
4170 static void stac92xx_free_kctls(struct hda_codec *codec)
4171 {
4172         struct sigmatel_spec *spec = codec->spec;
4173
4174         if (spec->kctls.list) {
4175                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4176                 int i;
4177                 for (i = 0; i < spec->kctls.used; i++)
4178                         kfree(kctl[i].name);
4179         }
4180         snd_array_free(&spec->kctls);
4181 }
4182
4183 static void stac92xx_free(struct hda_codec *codec)
4184 {
4185         struct sigmatel_spec *spec = codec->spec;
4186
4187         if (! spec)
4188                 return;
4189
4190         stac92xx_free_jacks(codec);
4191         snd_array_free(&spec->events);
4192
4193         kfree(spec);
4194         snd_hda_detach_beep_device(codec);
4195 }
4196
4197 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4198                                 unsigned int flag)
4199 {
4200         unsigned int old_ctl, pin_ctl;
4201
4202         pin_ctl = snd_hda_codec_read(codec, nid,
4203                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4204
4205         if (pin_ctl & AC_PINCTL_IN_EN) {
4206                 /*
4207                  * we need to check the current set-up direction of
4208                  * shared input pins since they can be switched via
4209                  * "xxx as Output" mixer switch
4210                  */
4211                 struct sigmatel_spec *spec = codec->spec;
4212                 if (nid == spec->line_switch || nid == spec->mic_switch)
4213                         return;
4214         }
4215
4216         old_ctl = pin_ctl;
4217         /* if setting pin direction bits, clear the current
4218            direction bits first */
4219         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4220                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4221
4222         pin_ctl |= flag;
4223         if (old_ctl != pin_ctl)
4224                 snd_hda_codec_write_cache(codec, nid, 0,
4225                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4226                                           pin_ctl);
4227 }
4228
4229 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4230                                   unsigned int flag)
4231 {
4232         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4233                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4234         if (pin_ctl & flag)
4235                 snd_hda_codec_write_cache(codec, nid, 0,
4236                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4237                                           pin_ctl & ~flag);
4238 }
4239
4240 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4241 {
4242         if (!nid)
4243                 return 0;
4244         if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4245             & (1 << 31))
4246                 return 1;
4247         return 0;
4248 }
4249
4250 /* return non-zero if the hp-pin of the given array index isn't
4251  * a jack-detection target
4252  */
4253 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4254 {
4255         struct auto_pin_cfg *cfg = &spec->autocfg;
4256
4257         /* ignore sensing of shared line and mic jacks */
4258         if (cfg->hp_pins[i] == spec->line_switch)
4259                 return 1;
4260         if (cfg->hp_pins[i] == spec->mic_switch)
4261                 return 1;
4262         /* ignore if the pin is set as line-out */
4263         if (cfg->hp_pins[i] == spec->hp_switch)
4264                 return 1;
4265         return 0;
4266 }
4267
4268 static void stac92xx_hp_detect(struct hda_codec *codec)
4269 {
4270         struct sigmatel_spec *spec = codec->spec;
4271         struct auto_pin_cfg *cfg = &spec->autocfg;
4272         int i, presence;
4273
4274         presence = 0;
4275         if (spec->gpio_mute)
4276                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4277                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4278
4279         for (i = 0; i < cfg->hp_outs; i++) {
4280                 if (presence)
4281                         break;
4282                 if (no_hp_sensing(spec, i))
4283                         continue;
4284                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4285                 if (presence) {
4286                         unsigned int pinctl;
4287                         pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4288                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4289                         if (pinctl & AC_PINCTL_IN_EN)
4290                                 presence = 0; /* mic- or line-input */
4291                 }
4292         }
4293
4294         if (presence) {
4295                 /* disable lineouts */
4296                 if (spec->hp_switch)
4297                         stac92xx_reset_pinctl(codec, spec->hp_switch,
4298                                               AC_PINCTL_OUT_EN);
4299                 for (i = 0; i < cfg->line_outs; i++)
4300                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4301                                                 AC_PINCTL_OUT_EN);
4302                 for (i = 0; i < cfg->speaker_outs; i++)
4303                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4304                                                 AC_PINCTL_OUT_EN);
4305                 if (spec->eapd_mask && spec->eapd_switch)
4306                         stac_gpio_set(codec, spec->gpio_mask,
4307                                 spec->gpio_dir, spec->gpio_data &
4308                                 ~spec->eapd_mask);
4309         } else {
4310                 /* enable lineouts */
4311                 if (spec->hp_switch)
4312                         stac92xx_set_pinctl(codec, spec->hp_switch,
4313                                             AC_PINCTL_OUT_EN);
4314                 for (i = 0; i < cfg->line_outs; i++)
4315                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4316                                                 AC_PINCTL_OUT_EN);
4317                 for (i = 0; i < cfg->speaker_outs; i++)
4318                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4319                                                 AC_PINCTL_OUT_EN);
4320                 if (spec->eapd_mask && spec->eapd_switch)
4321                         stac_gpio_set(codec, spec->gpio_mask,
4322                                 spec->gpio_dir, spec->gpio_data |
4323                                 spec->eapd_mask);
4324         }
4325         /* toggle hp outs */
4326         for (i = 0; i < cfg->hp_outs; i++) {
4327                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4328                 if (no_hp_sensing(spec, i))
4329                         continue;
4330                 if (presence)
4331                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4332 #if 0 /* FIXME */
4333 /* Resetting the pinctl like below may lead to (a sort of) regressions
4334  * on some devices since they use the HP pin actually for line/speaker
4335  * outs although the default pin config shows a different pin (that is
4336  * wrong and useless).
4337  *
4338  * So, it's basically a problem of default pin configs, likely a BIOS issue.
4339  * But, disabling the code below just works around it, and I'm too tired of
4340  * bug reports with such devices...
4341  */
4342                 else
4343                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4344 #endif /* FIXME */
4345         }
4346 }
4347
4348 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4349                                   int enable)
4350 {
4351         struct sigmatel_spec *spec = codec->spec;
4352         unsigned int idx, val;
4353
4354         for (idx = 0; idx < spec->num_pwrs; idx++) {
4355                 if (spec->pwr_nids[idx] == nid)
4356                         break;
4357         }
4358         if (idx >= spec->num_pwrs)
4359                 return;
4360
4361         /* several codecs have two power down bits */
4362         if (spec->pwr_mapping)
4363                 idx = spec->pwr_mapping[idx];
4364         else
4365                 idx = 1 << idx;
4366
4367         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4368         if (enable)
4369                 val &= ~idx;
4370         else
4371                 val |= idx;
4372
4373         /* power down unused output ports */
4374         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4375 }
4376
4377 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4378 {
4379         stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4380 }
4381
4382 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4383 {
4384         struct sigmatel_spec *spec = codec->spec;
4385         struct sigmatel_jack *jacks = spec->jacks.list;
4386
4387         if (jacks) {
4388                 int i;
4389                 for (i = 0; i < spec->jacks.used; i++) {
4390                         if (jacks->nid == nid) {
4391                                 unsigned int pin_ctl =
4392                                         snd_hda_codec_read(codec, nid,
4393                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4394                                          0x00);
4395                                 int type = jacks->type;
4396                                 if (type == (SND_JACK_LINEOUT
4397                                                 | SND_JACK_HEADPHONE))
4398                                         type = (pin_ctl & AC_PINCTL_HP_EN)
4399                                         ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4400                                 snd_jack_report(jacks->jack,
4401                                         get_pin_presence(codec, nid)
4402                                         ? type : 0);
4403                         }
4404                         jacks++;
4405                 }
4406         }
4407 }
4408
4409 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4410                                    unsigned char type)
4411 {
4412         struct sigmatel_event *event = stac_get_event(codec, nid, type);
4413         if (!event)
4414                 return;
4415         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4416 }
4417
4418 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4419 {
4420         struct sigmatel_spec *spec = codec->spec;
4421         struct sigmatel_event *event;
4422         int tag, data;
4423
4424         tag = (res >> 26) & 0x7f;
4425         event = stac_get_event_from_tag(codec, tag);
4426         if (!event)
4427                 return;
4428
4429         switch (event->type) {
4430         case STAC_HP_EVENT:
4431                 stac92xx_hp_detect(codec);
4432                 /* fallthru */
4433         case STAC_INSERT_EVENT:
4434         case STAC_PWR_EVENT:
4435                 if (spec->num_pwrs > 0)
4436                         stac92xx_pin_sense(codec, event->nid);
4437                 stac92xx_report_jack(codec, event->nid);
4438
4439                 switch (codec->subsystem_id) {
4440                 case 0x103c308f:
4441                         if (event->nid == 0xb) {
4442                                 int pin = AC_PINCTL_IN_EN;
4443
4444                                 if (get_pin_presence(codec, 0xa)
4445                                                 && get_pin_presence(codec, 0xb))
4446                                         pin |= AC_PINCTL_VREF_80;
4447                                 if (!get_pin_presence(codec, 0xb))
4448                                         pin |= AC_PINCTL_VREF_80;
4449
4450                                 /* toggle VREF state based on mic + hp pin
4451                                  * status
4452                                  */
4453                                 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4454                         }
4455                 }
4456                 break;
4457         case STAC_VREF_EVENT:
4458                 data = snd_hda_codec_read(codec, codec->afg, 0,
4459                                           AC_VERB_GET_GPIO_DATA, 0);
4460                 /* toggle VREF state based on GPIOx status */
4461                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4462                                     !!(data & (1 << event->data)));
4463                 break;
4464         }
4465 }
4466
4467 #ifdef CONFIG_PROC_FS
4468 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4469                                struct hda_codec *codec, hda_nid_t nid)
4470 {
4471         if (nid == codec->afg)
4472                 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4473                             snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4474 }
4475
4476 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4477                                   struct hda_codec *codec,
4478                                   unsigned int verb)
4479 {
4480         snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4481                     snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4482 }
4483
4484 /* stac92hd71bxx, stac92hd73xx */
4485 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4486                                  struct hda_codec *codec, hda_nid_t nid)
4487 {
4488         stac92hd_proc_hook(buffer, codec, nid);
4489         if (nid == codec->afg)
4490                 analog_loop_proc_hook(buffer, codec, 0xfa0);
4491 }
4492
4493 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4494                                struct hda_codec *codec, hda_nid_t nid)
4495 {
4496         if (nid == codec->afg)
4497                 analog_loop_proc_hook(buffer, codec, 0xfe0);
4498 }
4499
4500 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4501                                struct hda_codec *codec, hda_nid_t nid)
4502 {
4503         if (nid == codec->afg)
4504                 analog_loop_proc_hook(buffer, codec, 0xfeb);
4505 }
4506 #else
4507 #define stac92hd_proc_hook      NULL
4508 #define stac92hd7x_proc_hook    NULL
4509 #define stac9205_proc_hook      NULL
4510 #define stac927x_proc_hook      NULL
4511 #endif
4512
4513 #ifdef SND_HDA_NEEDS_RESUME
4514 static int stac92xx_resume(struct hda_codec *codec)
4515 {
4516         struct sigmatel_spec *spec = codec->spec;
4517
4518         stac92xx_init(codec);
4519         snd_hda_codec_resume_amp(codec);
4520         snd_hda_codec_resume_cache(codec);
4521         /* fake event to set up pins again to override cached values */
4522         if (spec->hp_detect)
4523                 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4524                                        STAC_HP_EVENT);
4525         return 0;
4526 }
4527
4528
4529 /*
4530  * using power check for controlling mute led of HP HDX notebooks
4531  * check for mute state only on Speakers (nid = 0x10)
4532  *
4533  * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4534  * the LED is NOT working properly !
4535  */
4536
4537 #ifdef CONFIG_SND_HDA_POWER_SAVE
4538 static int stac92xx_hp_hdx_check_power_status(struct hda_codec *codec,
4539                                               hda_nid_t nid)
4540 {
4541         struct sigmatel_spec *spec = codec->spec;
4542
4543         if (nid == 0x10) {
4544                 if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4545                     HDA_AMP_MUTE)
4546                         spec->gpio_data &= ~0x08;  /* orange */
4547                 else
4548                         spec->gpio_data |= 0x08;   /* white */
4549
4550                 stac_gpio_set(codec, spec->gpio_mask,
4551                               spec->gpio_dir,
4552                               spec->gpio_data);
4553         }
4554
4555         return 0;
4556 }
4557 #endif
4558
4559 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4560 {
4561         struct sigmatel_spec *spec = codec->spec;
4562         if (spec->eapd_mask)
4563                 stac_gpio_set(codec, spec->gpio_mask,
4564                                 spec->gpio_dir, spec->gpio_data &
4565                                 ~spec->eapd_mask);
4566         return 0;
4567 }
4568 #endif
4569
4570 static struct hda_codec_ops stac92xx_patch_ops = {
4571         .build_controls = stac92xx_build_controls,
4572         .build_pcms = stac92xx_build_pcms,
4573         .init = stac92xx_init,
4574         .free = stac92xx_free,
4575         .unsol_event = stac92xx_unsol_event,
4576 #ifdef SND_HDA_NEEDS_RESUME
4577         .suspend = stac92xx_suspend,
4578         .resume = stac92xx_resume,
4579 #endif
4580 };
4581
4582 static int patch_stac9200(struct hda_codec *codec)
4583 {
4584         struct sigmatel_spec *spec;
4585         int err;
4586
4587         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4588         if (spec == NULL)
4589                 return -ENOMEM;
4590
4591         codec->spec = spec;
4592         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4593         spec->pin_nids = stac9200_pin_nids;
4594         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4595                                                         stac9200_models,
4596                                                         stac9200_cfg_tbl);
4597         if (spec->board_config < 0)
4598                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4599         else
4600                 stac92xx_set_config_regs(codec,
4601                                          stac9200_brd_tbl[spec->board_config]);
4602
4603         spec->multiout.max_channels = 2;
4604         spec->multiout.num_dacs = 1;
4605         spec->multiout.dac_nids = stac9200_dac_nids;
4606         spec->adc_nids = stac9200_adc_nids;
4607         spec->mux_nids = stac9200_mux_nids;
4608         spec->num_muxes = 1;
4609         spec->num_dmics = 0;
4610         spec->num_adcs = 1;
4611         spec->num_pwrs = 0;
4612
4613         if (spec->board_config == STAC_9200_M4 ||
4614             spec->board_config == STAC_9200_M4_2 ||
4615             spec->board_config == STAC_9200_OQO)
4616                 spec->init = stac9200_eapd_init;
4617         else
4618                 spec->init = stac9200_core_init;
4619         spec->mixer = stac9200_mixer;
4620
4621         if (spec->board_config == STAC_9200_PANASONIC) {
4622                 spec->gpio_mask = spec->gpio_dir = 0x09;
4623                 spec->gpio_data = 0x00;
4624         }
4625
4626         err = stac9200_parse_auto_config(codec);
4627         if (err < 0) {
4628                 stac92xx_free(codec);
4629                 return err;
4630         }
4631
4632         /* CF-74 has no headphone detection, and the driver should *NOT*
4633          * do detection and HP/speaker toggle because the hardware does it.
4634          */
4635         if (spec->board_config == STAC_9200_PANASONIC)
4636                 spec->hp_detect = 0;
4637
4638         codec->patch_ops = stac92xx_patch_ops;
4639
4640         return 0;
4641 }
4642
4643 static int patch_stac925x(struct hda_codec *codec)
4644 {
4645         struct sigmatel_spec *spec;
4646         int err;
4647
4648         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4649         if (spec == NULL)
4650                 return -ENOMEM;
4651
4652         codec->spec = spec;
4653         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4654         spec->pin_nids = stac925x_pin_nids;
4655
4656         /* Check first for codec ID */
4657         spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4658                                                         STAC_925x_MODELS,
4659                                                         stac925x_models,
4660                                                         stac925x_codec_id_cfg_tbl);
4661
4662         /* Now checks for PCI ID, if codec ID is not found */
4663         if (spec->board_config < 0)
4664                 spec->board_config = snd_hda_check_board_config(codec,
4665                                                         STAC_925x_MODELS,
4666                                                         stac925x_models,
4667                                                         stac925x_cfg_tbl);
4668  again:
4669         if (spec->board_config < 0)
4670                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4671                                       "using BIOS defaults\n");
4672         else
4673                 stac92xx_set_config_regs(codec,
4674                                          stac925x_brd_tbl[spec->board_config]);
4675
4676         spec->multiout.max_channels = 2;
4677         spec->multiout.num_dacs = 1;
4678         spec->multiout.dac_nids = stac925x_dac_nids;
4679         spec->adc_nids = stac925x_adc_nids;
4680         spec->mux_nids = stac925x_mux_nids;
4681         spec->num_muxes = 1;
4682         spec->num_adcs = 1;
4683         spec->num_pwrs = 0;
4684         switch (codec->vendor_id) {
4685         case 0x83847632: /* STAC9202  */
4686         case 0x83847633: /* STAC9202D */
4687         case 0x83847636: /* STAC9251  */
4688         case 0x83847637: /* STAC9251D */
4689                 spec->num_dmics = STAC925X_NUM_DMICS;
4690                 spec->dmic_nids = stac925x_dmic_nids;
4691                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4692                 spec->dmux_nids = stac925x_dmux_nids;
4693                 break;
4694         default:
4695                 spec->num_dmics = 0;
4696                 break;
4697         }
4698
4699         spec->init = stac925x_core_init;
4700         spec->mixer = stac925x_mixer;
4701
4702         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4703         if (!err) {
4704                 if (spec->board_config < 0) {
4705                         printk(KERN_WARNING "hda_codec: No auto-config is "
4706                                "available, default to model=ref\n");
4707                         spec->board_config = STAC_925x_REF;
4708                         goto again;
4709                 }
4710                 err = -EINVAL;
4711         }
4712         if (err < 0) {
4713                 stac92xx_free(codec);
4714                 return err;
4715         }
4716
4717         codec->patch_ops = stac92xx_patch_ops;
4718
4719         return 0;
4720 }
4721
4722 static struct hda_input_mux stac92hd73xx_dmux = {
4723         .num_items = 4,
4724         .items = {
4725                 { "Analog Inputs", 0x0b },
4726                 { "Digital Mic 1", 0x09 },
4727                 { "Digital Mic 2", 0x0a },
4728                 { "CD", 0x08 },
4729         }
4730 };
4731
4732 static int patch_stac92hd73xx(struct hda_codec *codec)
4733 {
4734         struct sigmatel_spec *spec;
4735         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4736         int err = 0;
4737         int num_dacs;
4738
4739         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4740         if (spec == NULL)
4741                 return -ENOMEM;
4742
4743         codec->spec = spec;
4744         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4745         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4746         spec->pin_nids = stac92hd73xx_pin_nids;
4747         spec->board_config = snd_hda_check_board_config(codec,
4748                                                         STAC_92HD73XX_MODELS,
4749                                                         stac92hd73xx_models,
4750                                                         stac92hd73xx_cfg_tbl);
4751 again:
4752         if (spec->board_config < 0)
4753                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4754                         " STAC92HD73XX, using BIOS defaults\n");
4755         else
4756                 stac92xx_set_config_regs(codec,
4757                                 stac92hd73xx_brd_tbl[spec->board_config]);
4758
4759         num_dacs = snd_hda_get_connections(codec, 0x0a,
4760                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
4761
4762         if (num_dacs < 3 || num_dacs > 5) {
4763                 printk(KERN_WARNING "hda_codec: Could not determine "
4764                        "number of channels defaulting to DAC count\n");
4765                 num_dacs = STAC92HD73_DAC_COUNT;
4766         }
4767         switch (num_dacs) {
4768         case 0x3: /* 6 Channel */
4769                 spec->mixer = stac92hd73xx_6ch_mixer;
4770                 spec->init = stac92hd73xx_6ch_core_init;
4771                 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
4772                 break;
4773         case 0x4: /* 8 Channel */
4774                 spec->mixer = stac92hd73xx_8ch_mixer;
4775                 spec->init = stac92hd73xx_8ch_core_init;
4776                 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
4777                 break;
4778         case 0x5: /* 10 Channel */
4779                 spec->mixer = stac92hd73xx_10ch_mixer;
4780                 spec->init = stac92hd73xx_10ch_core_init;
4781                 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
4782                 break;
4783         }
4784         spec->multiout.dac_nids = spec->dac_nids;
4785
4786         spec->aloopback_mask = 0x01;
4787         spec->aloopback_shift = 8;
4788
4789         spec->digbeep_nid = 0x1c;
4790         spec->mux_nids = stac92hd73xx_mux_nids;
4791         spec->adc_nids = stac92hd73xx_adc_nids;
4792         spec->dmic_nids = stac92hd73xx_dmic_nids;
4793         spec->dmux_nids = stac92hd73xx_dmux_nids;
4794         spec->smux_nids = stac92hd73xx_smux_nids;
4795         spec->amp_nids = stac92hd73xx_amp_nids;
4796         spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4797
4798         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4799         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4800         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4801         memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4802                         sizeof(stac92hd73xx_dmux));
4803
4804         switch (spec->board_config) {
4805         case STAC_DELL_EQ:
4806                 spec->init = dell_eq_core_init;
4807                 /* fallthru */
4808         case STAC_DELL_M6_AMIC:
4809         case STAC_DELL_M6_DMIC:
4810         case STAC_DELL_M6_BOTH:
4811                 spec->num_smuxes = 0;
4812                 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4813                 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4814                 spec->eapd_switch = 0;
4815                 spec->num_amps = 1;
4816
4817                 if (spec->board_config != STAC_DELL_EQ)
4818                         spec->init = dell_m6_core_init;
4819                 switch (spec->board_config) {
4820                 case STAC_DELL_M6_AMIC: /* Analog Mics */
4821                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4822                         spec->num_dmics = 0;
4823                         spec->private_dimux.num_items = 1;
4824                         break;
4825                 case STAC_DELL_M6_DMIC: /* Digital Mics */
4826                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4827                         spec->num_dmics = 1;
4828                         spec->private_dimux.num_items = 2;
4829                         break;
4830                 case STAC_DELL_M6_BOTH: /* Both */
4831                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4832                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4833                         spec->num_dmics = 1;
4834                         spec->private_dimux.num_items = 2;
4835                         break;
4836                 }
4837                 break;
4838         default:
4839                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4840                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4841                 spec->eapd_switch = 1;
4842         }
4843         if (spec->board_config > STAC_92HD73XX_REF) {
4844                 /* GPIO0 High = Enable EAPD */
4845                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4846                 spec->gpio_data = 0x01;
4847         }
4848         spec->dinput_mux = &spec->private_dimux;
4849
4850         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4851         spec->pwr_nids = stac92hd73xx_pwr_nids;
4852
4853         err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4854
4855         if (!err) {
4856                 if (spec->board_config < 0) {
4857                         printk(KERN_WARNING "hda_codec: No auto-config is "
4858                                "available, default to model=ref\n");
4859                         spec->board_config = STAC_92HD73XX_REF;
4860                         goto again;
4861                 }
4862                 err = -EINVAL;
4863         }
4864
4865         if (err < 0) {
4866                 stac92xx_free(codec);
4867                 return err;
4868         }
4869
4870         if (spec->board_config == STAC_92HD73XX_NO_JD)
4871                 spec->hp_detect = 0;
4872
4873         codec->patch_ops = stac92xx_patch_ops;
4874
4875         codec->proc_widget_hook = stac92hd7x_proc_hook;
4876
4877         return 0;
4878 }
4879
4880 static struct hda_input_mux stac92hd83xxx_dmux = {
4881         .num_items = 3,
4882         .items = {
4883                 { "Analog Inputs", 0x03 },
4884                 { "Digital Mic 1", 0x04 },
4885                 { "Digital Mic 2", 0x05 },
4886         }
4887 };
4888
4889 static int patch_stac92hd83xxx(struct hda_codec *codec)
4890 {
4891         struct sigmatel_spec *spec;
4892         hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4893         int err;
4894         int num_dacs;
4895         hda_nid_t nid;
4896
4897         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4898         if (spec == NULL)
4899                 return -ENOMEM;
4900
4901         codec->spec = spec;
4902         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4903         spec->mono_nid = 0x19;
4904         spec->digbeep_nid = 0x21;
4905         spec->dmic_nids = stac92hd83xxx_dmic_nids;
4906         spec->dmux_nids = stac92hd83xxx_dmux_nids;
4907         spec->adc_nids = stac92hd83xxx_adc_nids;
4908         spec->pwr_nids = stac92hd83xxx_pwr_nids;
4909         spec->amp_nids = stac92hd83xxx_amp_nids;
4910         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4911         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4912         spec->multiout.dac_nids = spec->dac_nids;
4913
4914         spec->init = stac92hd83xxx_core_init;
4915         spec->mixer = stac92hd83xxx_mixer;
4916         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4917         spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4918         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4919         spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4920         spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4921         spec->dinput_mux = &stac92hd83xxx_dmux;
4922         spec->pin_nids = stac92hd83xxx_pin_nids;
4923         spec->board_config = snd_hda_check_board_config(codec,
4924                                                         STAC_92HD83XXX_MODELS,
4925                                                         stac92hd83xxx_models,
4926                                                         stac92hd83xxx_cfg_tbl);
4927 again:
4928         if (spec->board_config < 0)
4929                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4930                         " STAC92HD83XXX, using BIOS defaults\n");
4931         else
4932                 stac92xx_set_config_regs(codec,
4933                                 stac92hd83xxx_brd_tbl[spec->board_config]);
4934
4935         switch (codec->vendor_id) {
4936         case 0x111d7604:
4937         case 0x111d7605:
4938         case 0x111d76d5:
4939                 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4940                         break;
4941                 spec->num_pwrs = 0;
4942                 break;
4943         }
4944
4945         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4946         if (!err) {
4947                 if (spec->board_config < 0) {
4948                         printk(KERN_WARNING "hda_codec: No auto-config is "
4949                                "available, default to model=ref\n");
4950                         spec->board_config = STAC_92HD83XXX_REF;
4951                         goto again;
4952                 }
4953                 err = -EINVAL;
4954         }
4955
4956         if (err < 0) {
4957                 stac92xx_free(codec);
4958                 return err;
4959         }
4960
4961         switch (spec->board_config) {
4962         case STAC_DELL_S14:
4963                 nid = 0xf;
4964                 break;
4965         default:
4966                 nid = 0xe;
4967                 break;
4968         }
4969
4970         num_dacs = snd_hda_get_connections(codec, nid,
4971                                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4972
4973         /* set port X to select the last DAC
4974          */
4975         snd_hda_codec_write_cache(codec, nid, 0,
4976                         AC_VERB_SET_CONNECT_SEL, num_dacs);
4977
4978         codec->patch_ops = stac92xx_patch_ops;
4979
4980         codec->proc_widget_hook = stac92hd_proc_hook;
4981
4982         return 0;
4983 }
4984
4985 static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
4986         .num_items = 3,
4987         .items = {
4988                 { "Analog Inputs", 0x00 },
4989                 { "Digital Mic 1", 0x02 },
4990                 { "Digital Mic 2", 0x03 },
4991         }
4992 };
4993
4994 static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
4995         .num_items = 4,
4996         .items = {
4997                 { "Analog Inputs", 0x00 },
4998                 { "Mixer", 0x01 },
4999                 { "Digital Mic 1", 0x02 },
5000                 { "Digital Mic 2", 0x03 },
5001         }
5002 };
5003
5004 /* get the pin connection (fixed, none, etc) */
5005 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
5006 {
5007         struct sigmatel_spec *spec = codec->spec;
5008         unsigned int cfg;
5009
5010         cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
5011         return get_defcfg_connect(cfg);
5012 }
5013
5014 static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
5015                                          hda_nid_t *nids, int num_nids)
5016 {
5017         struct sigmatel_spec *spec = codec->spec;
5018         int idx, num;
5019         unsigned int def_conf;
5020
5021         for (num = 0; num < num_nids; num++) {
5022                 for (idx = 0; idx < spec->num_pins; idx++)
5023                         if (spec->pin_nids[idx] == nids[num])
5024                                 break;
5025                 if (idx >= spec->num_pins)
5026                         break;
5027                 def_conf = stac_get_defcfg_connect(codec, idx);
5028                 if (def_conf == AC_JACK_PORT_NONE)
5029                         break;
5030         }
5031         return num;
5032 }
5033
5034 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5035                                           hda_nid_t dig0pin)
5036 {
5037         struct sigmatel_spec *spec = codec->spec;
5038         int idx;
5039
5040         for (idx = 0; idx < spec->num_pins; idx++)
5041                 if (spec->pin_nids[idx] == dig0pin)
5042                         break;
5043         if ((idx + 2) >= spec->num_pins)
5044                 return 0;
5045
5046         /* dig1pin case */
5047         if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5048                 return 2;
5049
5050         /* dig0pin + dig2pin case */
5051         if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5052                 return 2;
5053         if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5054                 return 1;
5055         else
5056                 return 0;
5057 }
5058
5059 static int patch_stac92hd71bxx(struct hda_codec *codec)
5060 {
5061         struct sigmatel_spec *spec;
5062         struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5063         int err = 0;
5064         unsigned int ndmic_nids = 0;
5065
5066         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5067         if (spec == NULL)
5068                 return -ENOMEM;
5069
5070         codec->spec = spec;
5071         codec->patch_ops = stac92xx_patch_ops;
5072         spec->num_pins = STAC92HD71BXX_NUM_PINS;
5073         switch (codec->vendor_id) {
5074         case 0x111d76b6:
5075         case 0x111d76b7:
5076                 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5077                 break;
5078         case 0x111d7603:
5079         case 0x111d7608:
5080                 /* On 92HD75Bx 0x27 isn't a pin nid */
5081                 spec->num_pins--;
5082                 /* fallthrough */
5083         default:
5084                 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5085         }
5086         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5087         spec->board_config = snd_hda_check_board_config(codec,
5088                                                         STAC_92HD71BXX_MODELS,
5089                                                         stac92hd71bxx_models,
5090                                                         stac92hd71bxx_cfg_tbl);
5091 again:
5092         if (spec->board_config < 0)
5093                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5094                         " STAC92HD71BXX, using BIOS defaults\n");
5095         else
5096                 stac92xx_set_config_regs(codec,
5097                                 stac92hd71bxx_brd_tbl[spec->board_config]);
5098
5099         if (spec->board_config > STAC_92HD71BXX_REF) {
5100                 /* GPIO0 = EAPD */
5101                 spec->gpio_mask = 0x01;
5102                 spec->gpio_dir = 0x01;
5103                 spec->gpio_data = 0x01;
5104         }
5105
5106         spec->dmic_nids = stac92hd71bxx_dmic_nids;
5107         spec->dmux_nids = stac92hd71bxx_dmux_nids;
5108
5109         switch (codec->vendor_id) {
5110         case 0x111d76b6: /* 4 Port without Analog Mixer */
5111         case 0x111d76b7:
5112                 unmute_init++;
5113                 /* fallthru */
5114         case 0x111d76b4: /* 6 Port without Analog Mixer */
5115         case 0x111d76b5:
5116                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
5117                        sizeof(stac92hd71bxx_dmux_nomixer));
5118                 spec->mixer = stac92hd71bxx_mixer;
5119                 spec->init = stac92hd71bxx_core_init;
5120                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5121                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5122                                         stac92hd71bxx_dmic_nids,
5123                                         STAC92HD71BXX_NUM_DMICS);
5124                 if (spec->num_dmics) {
5125                         spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5126                         spec->dinput_mux = &spec->private_dimux;
5127                         ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5128                 }
5129                 break;
5130         case 0x111d7608: /* 5 Port with Analog Mixer */
5131                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5132                        sizeof(stac92hd71bxx_dmux_amixer));
5133                 spec->private_dimux.num_items--;
5134                 switch (spec->board_config) {
5135                 case STAC_HP_M4:
5136                         /* Enable VREF power saving on GPIO1 detect */
5137                         err = stac_add_event(spec, codec->afg,
5138                                              STAC_VREF_EVENT, 0x02);
5139                         if (err < 0)
5140                                 return err;
5141                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5142                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5143                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5144                                 AC_VERB_SET_UNSOLICITED_ENABLE,
5145                                 AC_USRSP_EN | err);
5146                         spec->gpio_mask |= 0x02;
5147                         break;
5148                 }
5149                 if ((codec->revision_id & 0xf) == 0 ||
5150                     (codec->revision_id & 0xf) == 1)
5151                         spec->stream_delay = 40; /* 40 milliseconds */
5152
5153                 /* no output amps */
5154                 spec->num_pwrs = 0;
5155                 spec->mixer = stac92hd71bxx_analog_mixer;
5156                 spec->dinput_mux = &spec->private_dimux;
5157
5158                 /* disable VSW */
5159                 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
5160                 unmute_init++;
5161                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5162                 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5163                 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5164                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5165                                         stac92hd71bxx_dmic_nids,
5166                                         STAC92HD71BXX_NUM_DMICS - 1);
5167                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5168                 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
5169                 break;
5170         case 0x111d7603: /* 6 Port with Analog Mixer */
5171                 if ((codec->revision_id & 0xf) == 1)
5172                         spec->stream_delay = 40; /* 40 milliseconds */
5173
5174                 /* no output amps */
5175                 spec->num_pwrs = 0;
5176                 /* fallthru */
5177         default:
5178                 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5179                        sizeof(stac92hd71bxx_dmux_amixer));
5180                 spec->dinput_mux = &spec->private_dimux;
5181                 spec->mixer = stac92hd71bxx_analog_mixer;
5182                 spec->init = stac92hd71bxx_analog_core_init;
5183                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5184                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5185                                         stac92hd71bxx_dmic_nids,
5186                                         STAC92HD71BXX_NUM_DMICS);
5187                 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5188                 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5189         }
5190
5191         if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5192                 snd_hda_sequence_write_cache(codec, unmute_init);
5193
5194         spec->aloopback_ctl = stac92hd71bxx_loopback;
5195         spec->aloopback_mask = 0x50;
5196         spec->aloopback_shift = 0;
5197
5198         spec->powerdown_adcs = 1;
5199         spec->digbeep_nid = 0x26;
5200         spec->mux_nids = stac92hd71bxx_mux_nids;
5201         spec->adc_nids = stac92hd71bxx_adc_nids;
5202         spec->smux_nids = stac92hd71bxx_smux_nids;
5203         spec->pwr_nids = stac92hd71bxx_pwr_nids;
5204
5205         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5206         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5207         spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5208
5209         switch (spec->board_config) {
5210         case STAC_HP_M4:
5211                 /* enable internal microphone */
5212                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5213                 stac92xx_auto_set_pinctl(codec, 0x0e,
5214                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5215                 /* fallthru */
5216         case STAC_DELL_M4_2:
5217                 spec->num_dmics = 0;
5218                 spec->num_smuxes = 0;
5219                 spec->num_dmuxes = 0;
5220                 break;
5221         case STAC_DELL_M4_1:
5222         case STAC_DELL_M4_3:
5223                 spec->num_dmics = 1;
5224                 spec->num_smuxes = 0;
5225                 spec->num_dmuxes = 1;
5226                 break;
5227         case STAC_HP_DV5:
5228                 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5229                 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5230                 break;
5231         case STAC_HP_HDX:
5232                 spec->num_dmics = 1;
5233                 spec->num_dmuxes = 1;
5234                 spec->num_smuxes = 1;
5235                 /*
5236                  * For controlling MUTE LED on HP HDX16/HDX18 notebooks,
5237                  * the CONFIG_SND_HDA_POWER_SAVE is needed to be set.
5238                  */
5239 #ifdef CONFIG_SND_HDA_POWER_SAVE
5240                 /* orange/white mute led on GPIO3, orange=0, white=1 */
5241                 spec->gpio_mask |= 0x08;
5242                 spec->gpio_dir  |= 0x08;
5243                 spec->gpio_data |= 0x08;  /* set to white */
5244
5245                 /* register check_power_status callback. */
5246                 codec->patch_ops.check_power_status =
5247                     stac92xx_hp_hdx_check_power_status;
5248 #endif
5249                 break;
5250         };
5251
5252         spec->multiout.dac_nids = spec->dac_nids;
5253         if (spec->dinput_mux)
5254                 spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
5255
5256         err = stac92xx_parse_auto_config(codec, 0x21, 0);
5257         if (!err) {
5258                 if (spec->board_config < 0) {
5259                         printk(KERN_WARNING "hda_codec: No auto-config is "
5260                                "available, default to model=ref\n");
5261                         spec->board_config = STAC_92HD71BXX_REF;
5262                         goto again;
5263                 }
5264                 err = -EINVAL;
5265         }
5266
5267         if (err < 0) {
5268                 stac92xx_free(codec);
5269                 return err;
5270         }
5271
5272         codec->proc_widget_hook = stac92hd7x_proc_hook;
5273
5274         return 0;
5275 };
5276
5277 static int patch_stac922x(struct hda_codec *codec)
5278 {
5279         struct sigmatel_spec *spec;
5280         int err;
5281
5282         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5283         if (spec == NULL)
5284                 return -ENOMEM;
5285
5286         codec->spec = spec;
5287         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5288         spec->pin_nids = stac922x_pin_nids;
5289         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5290                                                         stac922x_models,
5291                                                         stac922x_cfg_tbl);
5292         if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5293                 spec->gpio_mask = spec->gpio_dir = 0x03;
5294                 spec->gpio_data = 0x03;
5295                 /* Intel Macs have all same PCI SSID, so we need to check
5296                  * codec SSID to distinguish the exact models
5297                  */
5298                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5299                 switch (codec->subsystem_id) {
5300
5301                 case 0x106b0800:
5302                         spec->board_config = STAC_INTEL_MAC_V1;
5303                         break;
5304                 case 0x106b0600:
5305                 case 0x106b0700:
5306                         spec->board_config = STAC_INTEL_MAC_V2;
5307                         break;
5308                 case 0x106b0e00:
5309                 case 0x106b0f00:
5310                 case 0x106b1600:
5311                 case 0x106b1700:
5312                 case 0x106b0200:
5313                 case 0x106b1e00:
5314                         spec->board_config = STAC_INTEL_MAC_V3;
5315                         break;
5316                 case 0x106b1a00:
5317                 case 0x00000100:
5318                         spec->board_config = STAC_INTEL_MAC_V4;
5319                         break;
5320                 case 0x106b0a00:
5321                 case 0x106b2200:
5322                         spec->board_config = STAC_INTEL_MAC_V5;
5323                         break;
5324                 default:
5325                         spec->board_config = STAC_INTEL_MAC_V3;
5326                         break;
5327                 }
5328         }
5329
5330  again:
5331         if (spec->board_config < 0)
5332                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5333                         "using BIOS defaults\n");
5334         else
5335                 stac92xx_set_config_regs(codec,
5336                                 stac922x_brd_tbl[spec->board_config]);
5337
5338         spec->adc_nids = stac922x_adc_nids;
5339         spec->mux_nids = stac922x_mux_nids;
5340         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5341         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5342         spec->num_dmics = 0;
5343         spec->num_pwrs = 0;
5344
5345         spec->init = stac922x_core_init;
5346         spec->mixer = stac922x_mixer;
5347
5348         spec->multiout.dac_nids = spec->dac_nids;
5349
5350         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5351         if (!err) {
5352                 if (spec->board_config < 0) {
5353                         printk(KERN_WARNING "hda_codec: No auto-config is "
5354                                "available, default to model=ref\n");
5355                         spec->board_config = STAC_D945_REF;
5356                         goto again;
5357                 }
5358                 err = -EINVAL;
5359         }
5360         if (err < 0) {
5361                 stac92xx_free(codec);
5362                 return err;
5363         }
5364
5365         codec->patch_ops = stac92xx_patch_ops;
5366
5367         /* Fix Mux capture level; max to 2 */
5368         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5369                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
5370                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5371                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5372                                   (0 << AC_AMPCAP_MUTE_SHIFT));
5373
5374         return 0;
5375 }
5376
5377 static int patch_stac927x(struct hda_codec *codec)
5378 {
5379         struct sigmatel_spec *spec;
5380         int err;
5381
5382         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5383         if (spec == NULL)
5384                 return -ENOMEM;
5385
5386         codec->spec = spec;
5387         codec->slave_dig_outs = stac927x_slave_dig_outs;
5388         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5389         spec->pin_nids = stac927x_pin_nids;
5390         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5391                                                         stac927x_models,
5392                                                         stac927x_cfg_tbl);
5393  again:
5394         if (spec->board_config < 0)
5395                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5396                             "STAC927x, using BIOS defaults\n");
5397         else
5398                 stac92xx_set_config_regs(codec,
5399                                 stac927x_brd_tbl[spec->board_config]);
5400
5401         spec->digbeep_nid = 0x23;
5402         spec->adc_nids = stac927x_adc_nids;
5403         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5404         spec->mux_nids = stac927x_mux_nids;
5405         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5406         spec->smux_nids = stac927x_smux_nids;
5407         spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5408         spec->spdif_labels = stac927x_spdif_labels;
5409         spec->dac_list = stac927x_dac_nids;
5410         spec->multiout.dac_nids = spec->dac_nids;
5411
5412         switch (spec->board_config) {
5413         case STAC_D965_3ST:
5414         case STAC_D965_5ST:
5415                 /* GPIO0 High = Enable EAPD */
5416                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5417                 spec->gpio_data = 0x01;
5418                 spec->num_dmics = 0;
5419
5420                 spec->init = d965_core_init;
5421                 spec->mixer = stac927x_mixer;
5422                 break;
5423         case STAC_DELL_BIOS:
5424                 switch (codec->subsystem_id) {
5425                 case 0x10280209:
5426                 case 0x1028022e:
5427                         /* correct the device field to SPDIF out */
5428                         snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5429                         break;
5430                 };
5431                 /* configure the analog microphone on some laptops */
5432                 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5433                 /* correct the front output jack as a hp out */
5434                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5435                 /* correct the front input jack as a mic */
5436                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5437                 /* fallthru */
5438         case STAC_DELL_3ST:
5439                 /* GPIO2 High = Enable EAPD */
5440                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5441                 spec->gpio_data = 0x04;
5442                 spec->dmic_nids = stac927x_dmic_nids;
5443                 spec->num_dmics = STAC927X_NUM_DMICS;
5444
5445                 spec->init = d965_core_init;
5446                 spec->mixer = stac927x_mixer;
5447                 spec->dmux_nids = stac927x_dmux_nids;
5448                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5449                 break;
5450         default:
5451                 if (spec->board_config > STAC_D965_REF) {
5452                         /* GPIO0 High = Enable EAPD */
5453                         spec->eapd_mask = spec->gpio_mask = 0x01;
5454                         spec->gpio_dir = spec->gpio_data = 0x01;
5455                 }
5456                 spec->num_dmics = 0;
5457
5458                 spec->init = stac927x_core_init;
5459                 spec->mixer = stac927x_mixer;
5460         }
5461
5462         spec->num_pwrs = 0;
5463         spec->aloopback_ctl = stac927x_loopback;
5464         spec->aloopback_mask = 0x40;
5465         spec->aloopback_shift = 0;
5466         spec->eapd_switch = 1;
5467
5468         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5469         if (!err) {
5470                 if (spec->board_config < 0) {
5471                         printk(KERN_WARNING "hda_codec: No auto-config is "
5472                                "available, default to model=ref\n");
5473                         spec->board_config = STAC_D965_REF;
5474                         goto again;
5475                 }
5476                 err = -EINVAL;
5477         }
5478         if (err < 0) {
5479                 stac92xx_free(codec);
5480                 return err;
5481         }
5482
5483         codec->patch_ops = stac92xx_patch_ops;
5484
5485         codec->proc_widget_hook = stac927x_proc_hook;
5486
5487         /*
5488          * !!FIXME!!
5489          * The STAC927x seem to require fairly long delays for certain
5490          * command sequences.  With too short delays (even if the answer
5491          * is set to RIRB properly), it results in the silence output
5492          * on some hardwares like Dell.
5493          *
5494          * The below flag enables the longer delay (see get_response
5495          * in hda_intel.c).
5496          */
5497         codec->bus->needs_damn_long_delay = 1;
5498
5499         /* no jack detecion for ref-no-jd model */
5500         if (spec->board_config == STAC_D965_REF_NO_JD)
5501                 spec->hp_detect = 0;
5502
5503         return 0;
5504 }
5505
5506 static int patch_stac9205(struct hda_codec *codec)
5507 {
5508         struct sigmatel_spec *spec;
5509         int err;
5510
5511         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5512         if (spec == NULL)
5513                 return -ENOMEM;
5514
5515         codec->spec = spec;
5516         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5517         spec->pin_nids = stac9205_pin_nids;
5518         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5519                                                         stac9205_models,
5520                                                         stac9205_cfg_tbl);
5521  again:
5522         if (spec->board_config < 0)
5523                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5524         else
5525                 stac92xx_set_config_regs(codec,
5526                                          stac9205_brd_tbl[spec->board_config]);
5527
5528         spec->digbeep_nid = 0x23;
5529         spec->adc_nids = stac9205_adc_nids;
5530         spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5531         spec->mux_nids = stac9205_mux_nids;
5532         spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5533         spec->smux_nids = stac9205_smux_nids;
5534         spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5535         spec->dmic_nids = stac9205_dmic_nids;
5536         spec->num_dmics = STAC9205_NUM_DMICS;
5537         spec->dmux_nids = stac9205_dmux_nids;
5538         spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5539         spec->num_pwrs = 0;
5540
5541         spec->init = stac9205_core_init;
5542         spec->mixer = stac9205_mixer;
5543         spec->aloopback_ctl = stac9205_loopback;
5544
5545         spec->aloopback_mask = 0x40;
5546         spec->aloopback_shift = 0;
5547         /* Turn on/off EAPD per HP plugging */
5548         if (spec->board_config != STAC_9205_EAPD)
5549                 spec->eapd_switch = 1;
5550         spec->multiout.dac_nids = spec->dac_nids;
5551
5552         switch (spec->board_config){
5553         case STAC_9205_DELL_M43:
5554                 /* Enable SPDIF in/out */
5555                 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
5556                 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
5557
5558                 /* Enable unsol response for GPIO4/Dock HP connection */
5559                 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5560                 if (err < 0)
5561                         return err;
5562                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5563                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5564                 snd_hda_codec_write_cache(codec, codec->afg, 0,
5565                                           AC_VERB_SET_UNSOLICITED_ENABLE,
5566                                           AC_USRSP_EN | err);
5567
5568                 spec->gpio_dir = 0x0b;
5569                 spec->eapd_mask = 0x01;
5570                 spec->gpio_mask = 0x1b;
5571                 spec->gpio_mute = 0x10;
5572                 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5573                  * GPIO3 Low = DRM
5574                  */
5575                 spec->gpio_data = 0x01;
5576                 break;
5577         case STAC_9205_REF:
5578                 /* SPDIF-In enabled */
5579                 break;
5580         default:
5581                 /* GPIO0 High = EAPD */
5582                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5583                 spec->gpio_data = 0x01;
5584                 break;
5585         }
5586
5587         err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5588         if (!err) {
5589                 if (spec->board_config < 0) {
5590                         printk(KERN_WARNING "hda_codec: No auto-config is "
5591                                "available, default to model=ref\n");
5592                         spec->board_config = STAC_9205_REF;
5593                         goto again;
5594                 }
5595                 err = -EINVAL;
5596         }
5597         if (err < 0) {
5598                 stac92xx_free(codec);
5599                 return err;
5600         }
5601
5602         codec->patch_ops = stac92xx_patch_ops;
5603
5604         codec->proc_widget_hook = stac9205_proc_hook;
5605
5606         return 0;
5607 }
5608
5609 /*
5610  * STAC9872 hack
5611  */
5612
5613 static struct hda_verb stac9872_core_init[] = {
5614         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5615         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5616         {}
5617 };
5618
5619 static struct snd_kcontrol_new stac9872_mixer[] = {
5620         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5621         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5622         { } /* end */
5623 };
5624
5625 static hda_nid_t stac9872_pin_nids[] = {
5626         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
5627         0x11, 0x13, 0x14,
5628 };
5629
5630 static hda_nid_t stac9872_adc_nids[] = {
5631         0x8 /*,0x6*/
5632 };
5633
5634 static hda_nid_t stac9872_mux_nids[] = {
5635         0x15
5636 };
5637
5638 static unsigned int stac9872_vaio_pin_configs[9] = {
5639         0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
5640         0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
5641         0x90a7013e
5642 };
5643
5644 static const char *stac9872_models[STAC_9872_MODELS] = {
5645         [STAC_9872_AUTO] = "auto",
5646         [STAC_9872_VAIO] = "vaio",
5647 };
5648
5649 static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
5650         [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
5651 };
5652
5653 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5654         {} /* terminator */
5655 };
5656
5657 static int patch_stac9872(struct hda_codec *codec)
5658 {
5659         struct sigmatel_spec *spec;
5660         int err;
5661
5662         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5663         if (spec == NULL)
5664                 return -ENOMEM;
5665         codec->spec = spec;
5666
5667         spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5668                                                         stac9872_models,
5669                                                         stac9872_cfg_tbl);
5670         if (spec->board_config < 0)
5671                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9872, "
5672                             "using BIOS defaults\n");
5673         else
5674                 stac92xx_set_config_regs(codec,
5675                                          stac9872_brd_tbl[spec->board_config]);
5676
5677         spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
5678         spec->pin_nids = stac9872_pin_nids;
5679         spec->multiout.dac_nids = spec->dac_nids;
5680         spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
5681         spec->adc_nids = stac9872_adc_nids;
5682         spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
5683         spec->mux_nids = stac9872_mux_nids;
5684         spec->mixer = stac9872_mixer;
5685         spec->init = stac9872_core_init;
5686
5687         err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
5688         if (err < 0) {
5689                 stac92xx_free(codec);
5690                 return -EINVAL;
5691         }
5692         spec->input_mux = &spec->private_imux;
5693         codec->patch_ops = stac92xx_patch_ops;
5694         return 0;
5695 }
5696
5697
5698 /*
5699  * patch entries
5700  */
5701 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5702         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5703         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5704         { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5705         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5706         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5707         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5708         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5709         { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5710         { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5711         { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5712         { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5713         { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5714         { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5715         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5716         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5717         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5718         { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5719         { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5720         { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5721         { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5722         { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5723         { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5724         { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5725         { .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
5726         { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5727         { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5728         { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5729         { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5730         { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5731         { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5732         { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5733         /* The following does not take into account .id=0x83847661 when subsys =
5734          * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5735          * currently not fully supported.
5736          */
5737         { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5738         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5739         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5740         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5741         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5742         { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5743         { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5744         { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5745         { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5746         { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5747         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5748         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5749         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5750         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5751         { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
5752         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5753         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5754         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5755         { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5756         { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5757         { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5758         { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5759         { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5760         { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5761         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5762         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5763         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5764         {} /* terminator */
5765 };
5766
5767 MODULE_ALIAS("snd-hda-codec-id:8384*");
5768 MODULE_ALIAS("snd-hda-codec-id:111d*");
5769
5770 MODULE_LICENSE("GPL");
5771 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5772
5773 static struct hda_codec_preset_list sigmatel_list = {
5774         .preset = snd_hda_preset_sigmatel,
5775         .owner = THIS_MODULE,
5776 };
5777
5778 static int __init patch_sigmatel_init(void)
5779 {
5780         return snd_hda_add_codec_preset(&sigmatel_list);
5781 }
5782
5783 static void __exit patch_sigmatel_exit(void)
5784 {
5785         snd_hda_delete_codec_preset(&sigmatel_list);
5786 }
5787
5788 module_init(patch_sigmatel_init)
5789 module_exit(patch_sigmatel_exit)