SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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