sound/pci/hda/patch_cirrus.c

   1 /*
   2  * HD audio interface patch for Cirrus Logic CS420x chip
   3  *
   4  * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
   5  *
   6  *  This driver is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This driver is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/pci.h>
  25 #include <sound/core.h>
  26 #include "hda_codec.h"
  27 #include "hda_local.h"
  28 #include <sound/tlv.h>
  29
  30 /*
  31  */
  32
  33 struct cs_spec {
  34         int board_config;
  35         struct auto_pin_cfg autocfg;
  36         struct hda_multi_out multiout;
  37         struct snd_kcontrol *vmaster_sw;
  38         struct snd_kcontrol *vmaster_vol;
  39
  40         hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS];
  41         hda_nid_t slave_dig_outs[2];
  42
  43         unsigned int input_idx[AUTO_PIN_LAST];
  44         unsigned int capsrc_idx[AUTO_PIN_LAST];
  45         hda_nid_t adc_nid[AUTO_PIN_LAST];
  46         unsigned int adc_idx[AUTO_PIN_LAST];
  47         unsigned int num_inputs;
  48         unsigned int cur_input;
  49         unsigned int automic_idx;
  50         hda_nid_t cur_adc;
  51         unsigned int cur_adc_stream_tag;
  52         unsigned int cur_adc_format;
  53         hda_nid_t dig_in;
  54
  55         const struct hda_bind_ctls *capture_bind[2];
  56
  57         unsigned int gpio_mask;
  58         unsigned int gpio_dir;
  59         unsigned int gpio_data;
  60
  61         struct hda_pcm pcm_rec[2];      /* PCM information */
  62
  63         unsigned int hp_detect:1;
  64         unsigned int mic_detect:1;
  65         /* CS421x */
  66         unsigned int spdif_detect:1;
  67         unsigned int sense_b:1;
  68         hda_nid_t vendor_nid;
  69         struct hda_input_mux input_mux;
  70         unsigned int last_input;
  71 };
  72
  73 /* available models with CS420x */
  74 enum {
  75         CS420X_MBP53,
  76         CS420X_MBP55,
  77         CS420X_IMAC27,
  78         CS420X_AUTO,
  79         CS420X_MODELS
  80 };
  81
  82 /* CS421x boards */
  83 enum {
  84         CS421X_CDB4210,
  85         CS421X_MODELS
  86 };
  87
  88 /* Vendor-specific processing widget */
  89 #define CS420X_VENDOR_NID       0x11
  90 #define CS_DIG_OUT1_PIN_NID     0x10
  91 #define CS_DIG_OUT2_PIN_NID     0x15
  92 #define CS_DMIC1_PIN_NID        0x12
  93 #define CS_DMIC2_PIN_NID        0x0e
  94
  95 /* coef indices */
  96 #define IDX_SPDIF_STAT          0x0000
  97 #define IDX_SPDIF_CTL           0x0001
  98 #define IDX_ADC_CFG             0x0002
  99 /* SZC bitmask, 4 modes below:
 100  * 0 = immediate,
 101  * 1 = digital immediate, analog zero-cross
 102  * 2 = digtail & analog soft-ramp
 103  * 3 = digital soft-ramp, analog zero-cross
 104  */
 105 #define   CS_COEF_ADC_SZC_MASK          (3 << 0)
 106 #define   CS_COEF_ADC_MIC_SZC_MODE      (3 << 0) /* SZC setup for mic */
 107 #define   CS_COEF_ADC_LI_SZC_MODE       (3 << 0) /* SZC setup for line-in */
 108 /* PGA mode: 0 = differential, 1 = signle-ended */
 109 #define   CS_COEF_ADC_MIC_PGA_MODE      (1 << 5) /* PGA setup for mic */
 110 #define   CS_COEF_ADC_LI_PGA_MODE       (1 << 6) /* PGA setup for line-in */
 111 #define IDX_DAC_CFG             0x0003
 112 /* SZC bitmask, 4 modes below:
 113  * 0 = Immediate
 114  * 1 = zero-cross
 115  * 2 = soft-ramp
 116  * 3 = soft-ramp on zero-cross
 117  */
 118 #define   CS_COEF_DAC_HP_SZC_MODE       (3 << 0) /* nid 0x02 */
 119 #define   CS_COEF_DAC_LO_SZC_MODE       (3 << 2) /* nid 0x03 */
 120 #define   CS_COEF_DAC_SPK_SZC_MODE      (3 << 4) /* nid 0x04 */
 121
 122 #define IDX_BEEP_CFG            0x0004
 123 /* 0x0008 - test reg key */
 124 /* 0x0009 - 0x0014 -> 12 test regs */
 125 /* 0x0015 - visibility reg */
 126
 127 /*
 128  * Cirrus Logic CS4210
 129  *
 130  * 1 DAC => HP(sense) / Speakers,
 131  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
 132  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
 133 */
 134 #define CS4210_DAC_NID          0x02
 135 #define CS4210_ADC_NID          0x03
 136 #define CS421X_VENDOR_NID       0x0B
 137 #define CS421X_DMIC_PIN_NID     0x09 /* Port E */
 138 #define CS421X_SPDIF_PIN_NID    0x0A /* Port H */
 139
 140 #define CS421X_IDX_DEV_CFG      0x01
 141 #define CS421X_IDX_ADC_CFG      0x02
 142 #define CS421X_IDX_DAC_CFG      0x03
 143 #define CS421X_IDX_SPK_CTL      0x04
 144
 145 #define SPDIF_EVENT             0x04
 146
 147 static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
 148 {
 149         struct cs_spec *spec = codec->spec;
 150         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 151                             AC_VERB_SET_COEF_INDEX, idx);
 152         return snd_hda_codec_read(codec, spec->vendor_nid, 0,
 153                                   AC_VERB_GET_PROC_COEF, 0);
 154 }
 155
 156 static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
 157                                       unsigned int coef)
 158 {
 159         struct cs_spec *spec = codec->spec;
 160         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 161                             AC_VERB_SET_COEF_INDEX, idx);
 162         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 163                             AC_VERB_SET_PROC_COEF, coef);
 164 }
 165
 166
 167 #define HP_EVENT        1
 168 #define MIC_EVENT       2
 169
 170 /*
 171  * PCM callbacks
 172  */
 173 static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo,
 174                                 struct hda_codec *codec,
 175                                 struct snd_pcm_substream *substream)
 176 {
 177         struct cs_spec *spec = codec->spec;
 178         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 179                                              hinfo);
 180 }
 181
 182 static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 183                                    struct hda_codec *codec,
 184                                    unsigned int stream_tag,
 185                                    unsigned int format,
 186                                    struct snd_pcm_substream *substream)
 187 {
 188         struct cs_spec *spec = codec->spec;
 189         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 190                                                 stream_tag, format, substream);
 191 }
 192
 193 static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 194                                    struct hda_codec *codec,
 195                                    struct snd_pcm_substream *substream)
 196 {
 197         struct cs_spec *spec = codec->spec;
 198         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 199 }
 200
 201 /*
 202  * Digital out
 203  */
 204 static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 205                                     struct hda_codec *codec,
 206                                     struct snd_pcm_substream *substream)
 207 {
 208         struct cs_spec *spec = codec->spec;
 209         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 210 }
 211
 212 static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 213                                      struct hda_codec *codec,
 214                                      struct snd_pcm_substream *substream)
 215 {
 216         struct cs_spec *spec = codec->spec;
 217         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 218 }
 219
 220 static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 221                                        struct hda_codec *codec,
 222                                        unsigned int stream_tag,
 223                                        unsigned int format,
 224                                        struct snd_pcm_substream *substream)
 225 {
 226         struct cs_spec *spec = codec->spec;
 227         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
 228                                              format, substream);
 229 }
 230
 231 static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 232                                        struct hda_codec *codec,
 233                                        struct snd_pcm_substream *substream)
 234 {
 235         struct cs_spec *spec = codec->spec;
 236         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
 237 }
 238
 239 /*
 240  * Analog capture
 241  */
 242 static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 243                                   struct hda_codec *codec,
 244                                   unsigned int stream_tag,
 245                                   unsigned int format,
 246                                   struct snd_pcm_substream *substream)
 247 {
 248         struct cs_spec *spec = codec->spec;
 249         spec->cur_adc = spec->adc_nid[spec->cur_input];
 250         spec->cur_adc_stream_tag = stream_tag;
 251         spec->cur_adc_format = format;
 252         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
 253         return 0;
 254 }
 255
 256 static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 257                                   struct hda_codec *codec,
 258                                   struct snd_pcm_substream *substream)
 259 {
 260         struct cs_spec *spec = codec->spec;
 261         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
 262         spec->cur_adc = 0;
 263         return 0;
 264 }
 265
 266 /*
 267  */
 268 static const struct hda_pcm_stream cs_pcm_analog_playback = {
 269         .substreams = 1,
 270         .channels_min = 2,
 271         .channels_max = 2,
 272         .ops = {
 273                 .open = cs_playback_pcm_open,
 274                 .prepare = cs_playback_pcm_prepare,
 275                 .cleanup = cs_playback_pcm_cleanup
 276         },
 277 };
 278
 279 static const struct hda_pcm_stream cs_pcm_analog_capture = {
 280         .substreams = 1,
 281         .channels_min = 2,
 282         .channels_max = 2,
 283         .ops = {
 284                 .prepare = cs_capture_pcm_prepare,
 285                 .cleanup = cs_capture_pcm_cleanup
 286         },
 287 };
 288
 289 static const struct hda_pcm_stream cs_pcm_digital_playback = {
 290         .substreams = 1,
 291         .channels_min = 2,
 292         .channels_max = 2,
 293         .ops = {
 294                 .open = cs_dig_playback_pcm_open,
 295                 .close = cs_dig_playback_pcm_close,
 296                 .prepare = cs_dig_playback_pcm_prepare,
 297                 .cleanup = cs_dig_playback_pcm_cleanup
 298         },
 299 };
 300
 301 static const struct hda_pcm_stream cs_pcm_digital_capture = {
 302         .substreams = 1,
 303         .channels_min = 2,
 304         .channels_max = 2,
 305 };
 306
 307 static int cs_build_pcms(struct hda_codec *codec)
 308 {
 309         struct cs_spec *spec = codec->spec;
 310         struct hda_pcm *info = spec->pcm_rec;
 311
 312         codec->pcm_info = info;
 313         codec->num_pcms = 0;
 314
 315         info->name = "Cirrus Analog";
 316         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback;
 317         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0];
 318         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
 319                 spec->multiout.max_channels;
 320         info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture;
 321         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
 322                 spec->adc_nid[spec->cur_input];
 323         codec->num_pcms++;
 324
 325         if (!spec->multiout.dig_out_nid && !spec->dig_in)
 326                 return 0;
 327
 328         info++;
 329         info->name = "Cirrus Digital";
 330         info->pcm_type = spec->autocfg.dig_out_type[0];
 331         if (!info->pcm_type)
 332                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
 333         if (spec->multiout.dig_out_nid) {
 334                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 335                         cs_pcm_digital_playback;
 336                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 337                         spec->multiout.dig_out_nid;
 338         }
 339         if (spec->dig_in) {
 340                 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 341                         cs_pcm_digital_capture;
 342                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
 343         }
 344         codec->num_pcms++;
 345
 346         return 0;
 347 }
 348
 349 /*
 350  * parse codec topology
 351  */
 352
 353 static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin)
 354 {
 355         hda_nid_t dac;
 356         if (!pin)
 357                 return 0;
 358         if (snd_hda_get_connections(codec, pin, &dac, 1) != 1)
 359                 return 0;
 360         return dac;
 361 }
 362
 363 static int is_ext_mic(struct hda_codec *codec, unsigned int idx)
 364 {
 365         struct cs_spec *spec = codec->spec;
 366         struct auto_pin_cfg *cfg = &spec->autocfg;
 367         hda_nid_t pin = cfg->inputs[idx].pin;
 368         unsigned int val;
 369         if (!is_jack_detectable(codec, pin))
 370                 return 0;
 371         val = snd_hda_codec_get_pincfg(codec, pin);
 372         return (snd_hda_get_input_pin_attr(val) != INPUT_PIN_ATTR_INT);
 373 }
 374
 375 static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
 376                          unsigned int *idxp)
 377 {
 378         int i, idx;
 379         hda_nid_t nid;
 380
 381         nid = codec->start_nid;
 382         for (i = 0; i < codec->num_nodes; i++, nid++) {
 383                 unsigned int type;
 384                 type = get_wcaps_type(get_wcaps(codec, nid));
 385                 if (type != AC_WID_AUD_IN)
 386                         continue;
 387                 idx = snd_hda_get_conn_index(codec, nid, pin, false);
 388                 if (idx >= 0) {
 389                         *idxp = idx;
 390                         return nid;
 391                 }
 392         }
 393         return 0;
 394 }
 395
 396 static int is_active_pin(struct hda_codec *codec, hda_nid_t nid)
 397 {
 398         unsigned int val;
 399         val = snd_hda_codec_get_pincfg(codec, nid);
 400         return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
 401 }
 402
 403 static int parse_output(struct hda_codec *codec)
 404 {
 405         struct cs_spec *spec = codec->spec;
 406         struct auto_pin_cfg *cfg = &spec->autocfg;
 407         int i, extra_nids;
 408         hda_nid_t dac;
 409
 410         for (i = 0; i < cfg->line_outs; i++) {
 411                 dac = get_dac(codec, cfg->line_out_pins[i]);
 412                 if (!dac)
 413                         break;
 414                 spec->dac_nid[i] = dac;
 415         }
 416         spec->multiout.num_dacs = i;
 417         spec->multiout.dac_nids = spec->dac_nid;
 418         spec->multiout.max_channels = i * 2;
 419
 420         /* add HP and speakers */
 421         extra_nids = 0;
 422         for (i = 0; i < cfg->hp_outs; i++) {
 423                 dac = get_dac(codec, cfg->hp_pins[i]);
 424                 if (!dac)
 425                         break;
 426                 if (!i)
 427                         spec->multiout.hp_nid = dac;
 428                 else
 429                         spec->multiout.extra_out_nid[extra_nids++] = dac;
 430         }
 431         for (i = 0; i < cfg->speaker_outs; i++) {
 432                 dac = get_dac(codec, cfg->speaker_pins[i]);
 433                 if (!dac)
 434                         break;
 435                 spec->multiout.extra_out_nid[extra_nids++] = dac;
 436         }
 437
 438         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
 439                 cfg->speaker_outs = cfg->line_outs;
 440                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
 441                        sizeof(cfg->speaker_pins));
 442                 cfg->line_outs = 0;
 443         }
 444
 445         return 0;
 446 }
 447
 448 static int parse_input(struct hda_codec *codec)
 449 {
 450         struct cs_spec *spec = codec->spec;
 451         struct auto_pin_cfg *cfg = &spec->autocfg;
 452         int i;
 453
 454         for (i = 0; i < cfg->num_inputs; i++) {
 455                 hda_nid_t pin = cfg->inputs[i].pin;
 456                 spec->input_idx[spec->num_inputs] = i;
 457                 spec->capsrc_idx[i] = spec->num_inputs++;
 458                 spec->cur_input = i;
 459                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
 460         }
 461         if (!spec->num_inputs)
 462                 return 0;
 463
 464         /* check whether the automatic mic switch is available */
 465         if (spec->num_inputs == 2 &&
 466             cfg->inputs[0].type == AUTO_PIN_MIC &&
 467             cfg->inputs[1].type == AUTO_PIN_MIC) {
 468                 if (is_ext_mic(codec, cfg->inputs[0].pin)) {
 469                         if (!is_ext_mic(codec, cfg->inputs[1].pin)) {
 470                                 spec->mic_detect = 1;
 471                                 spec->automic_idx = 0;
 472                         }
 473                 } else {
 474                         if (is_ext_mic(codec, cfg->inputs[1].pin)) {
 475                                 spec->mic_detect = 1;
 476                                 spec->automic_idx = 1;
 477                         }
 478                 }
 479         }
 480         return 0;
 481 }
 482
 483
 484 static int parse_digital_output(struct hda_codec *codec)
 485 {
 486         struct cs_spec *spec = codec->spec;
 487         struct auto_pin_cfg *cfg = &spec->autocfg;
 488         hda_nid_t nid;
 489
 490         if (!cfg->dig_outs)
 491                 return 0;
 492         if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1)
 493                 return 0;
 494         spec->multiout.dig_out_nid = nid;
 495         spec->multiout.share_spdif = 1;
 496         if (cfg->dig_outs > 1 &&
 497             snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) {
 498                 spec->slave_dig_outs[0] = nid;
 499                 codec->slave_dig_outs = spec->slave_dig_outs;
 500         }
 501         return 0;
 502 }
 503
 504 static int parse_digital_input(struct hda_codec *codec)
 505 {
 506         struct cs_spec *spec = codec->spec;
 507         struct auto_pin_cfg *cfg = &spec->autocfg;
 508         int idx;
 509
 510         if (cfg->dig_in_pin)
 511                 spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx);
 512         return 0;
 513 }
 514
 515 /*
 516  * create mixer controls
 517  */
 518
 519 static const char * const dir_sfx[2] = { "Playback", "Capture" };
 520
 521 static int add_mute(struct hda_codec *codec, const char *name, int index,
 522                     unsigned int pval, int dir, struct snd_kcontrol **kctlp)
 523 {
 524         char tmp[44];
 525         struct snd_kcontrol_new knew =
 526                 HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT);
 527         knew.private_value = pval;
 528         snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]);
 529         *kctlp = snd_ctl_new1(&knew, codec);
 530         (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
 531         return snd_hda_ctl_add(codec, 0, *kctlp);
 532 }
 533
 534 static int add_volume(struct hda_codec *codec, const char *name,
 535                       int index, unsigned int pval, int dir,
 536                       struct snd_kcontrol **kctlp)
 537 {
 538         char tmp[44];
 539         struct snd_kcontrol_new knew =
 540                 HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT);
 541         knew.private_value = pval;
 542         snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]);
 543         *kctlp = snd_ctl_new1(&knew, codec);
 544         (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
 545         return snd_hda_ctl_add(codec, 0, *kctlp);
 546 }
 547
 548 static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
 549 {
 550         unsigned int caps;
 551
 552         /* set the upper-limit for mixer amp to 0dB */
 553         caps = query_amp_caps(codec, dac, HDA_OUTPUT);
 554         caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
 555         caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
 556                 << AC_AMPCAP_NUM_STEPS_SHIFT;
 557         snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
 558 }
 559
 560 static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
 561 {
 562         struct cs_spec *spec = codec->spec;
 563         unsigned int tlv[4];
 564         int err;
 565
 566         spec->vmaster_sw =
 567                 snd_ctl_make_virtual_master("Master Playback Switch", NULL);
 568         err = snd_hda_ctl_add(codec, dac, spec->vmaster_sw);
 569         if (err < 0)
 570                 return err;
 571
 572         snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv);
 573         spec->vmaster_vol =
 574                 snd_ctl_make_virtual_master("Master Playback Volume", tlv);
 575         err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol);
 576         if (err < 0)
 577                 return err;
 578         return 0;
 579 }
 580
 581 static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx,
 582                       int num_ctls, int type)
 583 {
 584         struct cs_spec *spec = codec->spec;
 585         const char *name;
 586         int err, index;
 587         struct snd_kcontrol *kctl;
 588         static const char * const speakers[] = {
 589                 "Front Speaker", "Surround Speaker", "Bass Speaker"
 590         };
 591         static const char * const line_outs[] = {
 592                 "Front Line-Out", "Surround Line-Out", "Bass Line-Out"
 593         };
 594
 595         fix_volume_caps(codec, dac);
 596         if (!spec->vmaster_sw) {
 597                 err = add_vmaster(codec, dac);
 598                 if (err < 0)
 599                         return err;
 600         }
 601
 602         index = 0;
 603         switch (type) {
 604         case AUTO_PIN_HP_OUT:
 605                 name = "Headphone";
 606                 index = idx;
 607                 break;
 608         case AUTO_PIN_SPEAKER_OUT:
 609                 if (num_ctls > 1)
 610                         name = speakers[idx];
 611                 else
 612                         name = "Speaker";
 613                 break;
 614         default:
 615                 if (num_ctls > 1)
 616                         name = line_outs[idx];
 617                 else
 618                         name = "Line-Out";
 619                 break;
 620         }
 621
 622         err = add_mute(codec, name, index,
 623                        HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
 624         if (err < 0)
 625                 return err;
 626         err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
 627         if (err < 0)
 628                 return err;
 629
 630         err = add_volume(codec, name, index,
 631                          HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
 632         if (err < 0)
 633                 return err;
 634         err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
 635         if (err < 0)
 636                 return err;
 637
 638         return 0;
 639 }
 640
 641 static int build_output(struct hda_codec *codec)
 642 {
 643         struct cs_spec *spec = codec->spec;
 644         struct auto_pin_cfg *cfg = &spec->autocfg;
 645         int i, err;
 646
 647         for (i = 0; i < cfg->line_outs; i++) {
 648                 err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]),
 649                                  i, cfg->line_outs, cfg->line_out_type);
 650                 if (err < 0)
 651                         return err;
 652         }
 653         for (i = 0; i < cfg->hp_outs; i++) {
 654                 err = add_output(codec, get_dac(codec, cfg->hp_pins[i]),
 655                                  i, cfg->hp_outs, AUTO_PIN_HP_OUT);
 656                 if (err < 0)
 657                         return err;
 658         }
 659         for (i = 0; i < cfg->speaker_outs; i++) {
 660                 err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]),
 661                                  i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT);
 662                 if (err < 0)
 663                         return err;
 664         }
 665         return 0;
 666 }
 667
 668 /*
 669  */
 670
 671 static const struct snd_kcontrol_new cs_capture_ctls[] = {
 672         HDA_BIND_SW("Capture Switch", 0),
 673         HDA_BIND_VOL("Capture Volume", 0),
 674 };
 675
 676 static int change_cur_input(struct hda_codec *codec, unsigned int idx,
 677                             int force)
 678 {
 679         struct cs_spec *spec = codec->spec;
 680
 681         if (spec->cur_input == idx && !force)
 682                 return 0;
 683         if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
 684                 /* stream is running, let's swap the current ADC */
 685                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
 686                 spec->cur_adc = spec->adc_nid[idx];
 687                 snd_hda_codec_setup_stream(codec, spec->cur_adc,
 688                                            spec->cur_adc_stream_tag, 0,
 689                                            spec->cur_adc_format);
 690         }
 691         snd_hda_codec_write(codec, spec->cur_adc, 0,
 692                             AC_VERB_SET_CONNECT_SEL,
 693                             spec->adc_idx[idx]);
 694         spec->cur_input = idx;
 695         return 1;
 696 }
 697
 698 static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
 699                                   struct snd_ctl_elem_info *uinfo)
 700 {
 701         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 702         struct cs_spec *spec = codec->spec;
 703         struct auto_pin_cfg *cfg = &spec->autocfg;
 704         unsigned int idx;
 705
 706         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 707         uinfo->count = 1;
 708         uinfo->value.enumerated.items = spec->num_inputs;
 709         if (uinfo->value.enumerated.item >= spec->num_inputs)
 710                 uinfo->value.enumerated.item = spec->num_inputs - 1;
 711         idx = spec->input_idx[uinfo->value.enumerated.item];
 712         strcpy(uinfo->value.enumerated.name,
 713                hda_get_input_pin_label(codec, cfg->inputs[idx].pin, 1));
 714         return 0;
 715 }
 716
 717 static int cs_capture_source_get(struct snd_kcontrol *kcontrol,
 718                                  struct snd_ctl_elem_value *ucontrol)
 719 {
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         struct cs_spec *spec = codec->spec;
 722         ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input];
 723         return 0;
 724 }
 725
 726 static int cs_capture_source_put(struct snd_kcontrol *kcontrol,
 727                                  struct snd_ctl_elem_value *ucontrol)
 728 {
 729         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 730         struct cs_spec *spec = codec->spec;
 731         unsigned int idx = ucontrol->value.enumerated.item[0];
 732
 733         if (idx >= spec->num_inputs)
 734                 return -EINVAL;
 735         idx = spec->input_idx[idx];
 736         return change_cur_input(codec, idx, 0);
 737 }
 738
 739 static const struct snd_kcontrol_new cs_capture_source = {
 740         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 741         .name = "Capture Source",
 742         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 743         .info = cs_capture_source_info,
 744         .get = cs_capture_source_get,
 745         .put = cs_capture_source_put,
 746 };
 747
 748 static const struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec,
 749                                                struct hda_ctl_ops *ops)
 750 {
 751         struct cs_spec *spec = codec->spec;
 752         struct hda_bind_ctls *bind;
 753         int i, n;
 754
 755         bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1),
 756                        GFP_KERNEL);
 757         if (!bind)
 758                 return NULL;
 759         bind->ops = ops;
 760         n = 0;
 761         for (i = 0; i < AUTO_PIN_LAST; i++) {
 762                 if (!spec->adc_nid[i])
 763                         continue;
 764                 bind->values[n++] =
 765                         HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3,
 766                                             spec->adc_idx[i], HDA_INPUT);
 767         }
 768         return bind;
 769 }
 770
 771 /* add a (input-boost) volume control to the given input pin */
 772 static int add_input_volume_control(struct hda_codec *codec,
 773                                     struct auto_pin_cfg *cfg,
 774                                     int item)
 775 {
 776         hda_nid_t pin = cfg->inputs[item].pin;
 777         u32 caps;
 778         const char *label;
 779         struct snd_kcontrol *kctl;
 780
 781         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
 782                 return 0;
 783         caps = query_amp_caps(codec, pin, HDA_INPUT);
 784         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
 785         if (caps <= 1)
 786                 return 0;
 787         label = hda_get_autocfg_input_label(codec, cfg, item);
 788         return add_volume(codec, label, 0,
 789                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
 790 }
 791
 792 static int build_input(struct hda_codec *codec)
 793 {
 794         struct cs_spec *spec = codec->spec;
 795         int i, err;
 796
 797         if (!spec->num_inputs)
 798                 return 0;
 799
 800         /* make bind-capture */
 801         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
 802         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
 803         for (i = 0; i < 2; i++) {
 804                 struct snd_kcontrol *kctl;
 805                 int n;
 806                 if (!spec->capture_bind[i])
 807                         return -ENOMEM;
 808                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
 809                 if (!kctl)
 810                         return -ENOMEM;
 811                 kctl->private_value = (long)spec->capture_bind[i];
 812                 err = snd_hda_ctl_add(codec, 0, kctl);
 813                 if (err < 0)
 814                         return err;
 815                 for (n = 0; n < AUTO_PIN_LAST; n++) {
 816                         if (!spec->adc_nid[n])
 817                                 continue;
 818                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
 819                         if (err < 0)
 820                                 return err;
 821                 }
 822         }
 823
 824         if (spec->num_inputs > 1 && !spec->mic_detect) {
 825                 err = snd_hda_ctl_add(codec, 0,
 826                                       snd_ctl_new1(&cs_capture_source, codec));
 827                 if (err < 0)
 828                         return err;
 829         }
 830
 831         for (i = 0; i < spec->num_inputs; i++) {
 832                 err = add_input_volume_control(codec, &spec->autocfg, i);
 833                 if (err < 0)
 834                         return err;
 835         }
 836
 837         return 0;
 838 }
 839
 840 /*
 841  */
 842
 843 static int build_digital_output(struct hda_codec *codec)
 844 {
 845         struct cs_spec *spec = codec->spec;
 846         int err;
 847
 848         if (!spec->multiout.dig_out_nid)
 849                 return 0;
 850
 851         err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid,
 852                                             spec->multiout.dig_out_nid);
 853         if (err < 0)
 854                 return err;
 855         err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
 856         if (err < 0)
 857                 return err;
 858         return 0;
 859 }
 860
 861 static int build_digital_input(struct hda_codec *codec)
 862 {
 863         struct cs_spec *spec = codec->spec;
 864         if (spec->dig_in)
 865                 return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
 866         return 0;
 867 }
 868
 869 /*
 870  * auto-mute and auto-mic switching
 871  * CS421x auto-output redirecting
 872  * HP/SPK/SPDIF
 873  */
 874
 875 static void cs_automute(struct hda_codec *codec)
 876 {
 877         struct cs_spec *spec = codec->spec;
 878         struct auto_pin_cfg *cfg = &spec->autocfg;
 879         unsigned int hp_present;
 880         unsigned int spdif_present;
 881         hda_nid_t nid;
 882         int i;
 883
 884         spdif_present = 0;
 885         if (cfg->dig_outs) {
 886                 nid = cfg->dig_out_pins[0];
 887                 if (is_jack_detectable(codec, nid)) {
 888                         /*
 889                         TODO: SPDIF output redirect when SENSE_B is enabled.
 890                         Shared (SENSE_A) jack (e.g HP/mini-TOSLINK)
 891                         assumed.
 892                         */
 893                         if (snd_hda_jack_detect(codec, nid)
 894                                 /* && spec->sense_b */)
 895                                 spdif_present = 1;
 896                 }
 897         }
 898
 899         hp_present = 0;
 900         for (i = 0; i < cfg->hp_outs; i++) {
 901                 nid = cfg->hp_pins[i];
 902                 if (!is_jack_detectable(codec, nid))
 903                         continue;
 904                 hp_present = snd_hda_jack_detect(codec, nid);
 905                 if (hp_present)
 906                         break;
 907         }
 908
 909         /* mute speakers if spdif or hp jack is plugged in */
 910         for (i = 0; i < cfg->speaker_outs; i++) {
 911                 nid = cfg->speaker_pins[i];
 912                 snd_hda_codec_write(codec, nid, 0,
 913                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 914                                     hp_present ? 0 : PIN_OUT);
 915                 /* detect on spdif is specific to CS421x */
 916                 if (spec->vendor_nid == CS421X_VENDOR_NID) {
 917                         snd_hda_codec_write(codec, nid, 0,
 918                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
 919                                         spdif_present ? 0 : PIN_OUT);
 920                 }
 921         }
 922         if (spec->board_config == CS420X_MBP53 ||
 923             spec->board_config == CS420X_MBP55 ||
 924             spec->board_config == CS420X_IMAC27) {
 925                 unsigned int gpio = hp_present ? 0x02 : 0x08;
 926                 snd_hda_codec_write(codec, 0x01, 0,
 927                                     AC_VERB_SET_GPIO_DATA, gpio);
 928         }
 929
 930         /* specific to CS421x */
 931         if (spec->vendor_nid == CS421X_VENDOR_NID) {
 932                 /* mute HPs if spdif jack (SENSE_B) is present */
 933                 for (i = 0; i < cfg->hp_outs; i++) {
 934                         nid = cfg->hp_pins[i];
 935                         snd_hda_codec_write(codec, nid, 0,
 936                                 AC_VERB_SET_PIN_WIDGET_CONTROL,
 937                                 (spdif_present && spec->sense_b) ? 0 : PIN_HP);
 938                 }
 939
 940                 /* SPDIF TX on/off */
 941                 if (cfg->dig_outs) {
 942                         nid = cfg->dig_out_pins[0];
 943                         snd_hda_codec_write(codec, nid, 0,
 944                                 AC_VERB_SET_PIN_WIDGET_CONTROL,
 945                                 spdif_present ? PIN_OUT : 0);
 946
 947                 }
 948                 /* Update board GPIOs if neccessary ... */
 949         }
 950 }
 951
 952 /*
 953  * Auto-input redirect for CS421x
 954  * Switch max 3 inputs of a single ADC (nid 3)
 955 */
 956
 957 static void cs_automic(struct hda_codec *codec)
 958 {
 959         struct cs_spec *spec = codec->spec;
 960         struct auto_pin_cfg *cfg = &spec->autocfg;
 961         hda_nid_t nid;
 962         unsigned int present;
 963
 964         nid = cfg->inputs[spec->automic_idx].pin;
 965         present = snd_hda_jack_detect(codec, nid);
 966
 967         /* specific to CS421x, single ADC */
 968         if (spec->vendor_nid == CS421X_VENDOR_NID) {
 969                 if (present) {
 970                         spec->last_input = spec->cur_input;
 971                         spec->cur_input = spec->automic_idx;
 972                 } else  {
 973                         spec->cur_input = spec->last_input;
 974                 }
 975
 976                 snd_hda_codec_write_cache(codec, spec->cur_adc, 0,
 977                                         AC_VERB_SET_CONNECT_SEL,
 978                                         spec->adc_idx[spec->cur_input]);
 979         } else {
 980                 if (present)
 981                         change_cur_input(codec, spec->automic_idx, 0);
 982                 else
 983                         change_cur_input(codec, !spec->automic_idx, 0);
 984         }
 985 }
 986
 987 /*
 988  */
 989
 990 static void init_output(struct hda_codec *codec)
 991 {
 992         struct cs_spec *spec = codec->spec;
 993         struct auto_pin_cfg *cfg = &spec->autocfg;
 994         int i;
 995
 996         /* mute first */
 997         for (i = 0; i < spec->multiout.num_dacs; i++)
 998                 snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
 999                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1000         if (spec->multiout.hp_nid)
1001                 snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
1002                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1003         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
1004                 if (!spec->multiout.extra_out_nid[i])
1005                         break;
1006                 snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
1007                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1008         }
1009
1010         /* set appropriate pin controls */
1011         for (i = 0; i < cfg->line_outs; i++)
1012                 snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
1013                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1014         /* HP */
1015         for (i = 0; i < cfg->hp_outs; i++) {
1016                 hda_nid_t nid = cfg->hp_pins[i];
1017                 snd_hda_codec_write(codec, nid, 0,
1018                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
1019                 if (!cfg->speaker_outs)
1020                         continue;
1021                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1022                         snd_hda_codec_write(codec, nid, 0,
1023                                             AC_VERB_SET_UNSOLICITED_ENABLE,
1024                                             AC_USRSP_EN | HP_EVENT);
1025                         spec->hp_detect = 1;
1026                 }
1027         }
1028
1029         /* Speaker */
1030         for (i = 0; i < cfg->speaker_outs; i++)
1031                 snd_hda_codec_write(codec, cfg->speaker_pins[i], 0,
1032                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1033
1034         /* SPDIF is enabled on presence detect for CS421x */
1035         if (spec->hp_detect || spec->spdif_detect)
1036                 cs_automute(codec);
1037 }
1038
1039 static void init_input(struct hda_codec *codec)
1040 {
1041         struct cs_spec *spec = codec->spec;
1042         struct auto_pin_cfg *cfg = &spec->autocfg;
1043         unsigned int coef;
1044         int i;
1045
1046         for (i = 0; i < cfg->num_inputs; i++) {
1047                 unsigned int ctl;
1048                 hda_nid_t pin = cfg->inputs[i].pin;
1049                 if (!spec->adc_nid[i])
1050                         continue;
1051                 /* set appropriate pin control and mute first */
1052                 ctl = PIN_IN;
1053                 if (cfg->inputs[i].type == AUTO_PIN_MIC) {
1054                         unsigned int caps = snd_hda_query_pin_caps(codec, pin);
1055                         caps >>= AC_PINCAP_VREF_SHIFT;
1056                         if (caps & AC_PINCAP_VREF_80)
1057                                 ctl = PIN_VREF80;
1058                 }
1059                 snd_hda_codec_write(codec, pin, 0,
1060                                     AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
1061                 snd_hda_codec_write(codec, spec->adc_nid[i], 0,
1062                                     AC_VERB_SET_AMP_GAIN_MUTE,
1063                                     AMP_IN_MUTE(spec->adc_idx[i]));
1064                 if (spec->mic_detect && spec->automic_idx == i)
1065                         snd_hda_codec_write(codec, pin, 0,
1066                                             AC_VERB_SET_UNSOLICITED_ENABLE,
1067                                             AC_USRSP_EN | MIC_EVENT);
1068         }
1069         /* specific to CS421x */
1070         if (spec->vendor_nid == CS421X_VENDOR_NID) {
1071                 if (spec->mic_detect)
1072                         cs_automic(codec);
1073                 else  {
1074                         spec->cur_adc = spec->adc_nid[spec->cur_input];
1075                         snd_hda_codec_write(codec, spec->cur_adc, 0,
1076                                         AC_VERB_SET_CONNECT_SEL,
1077                                         spec->adc_idx[spec->cur_input]);
1078                 }
1079         } else {
1080                 change_cur_input(codec, spec->cur_input, 1);
1081                 if (spec->mic_detect)
1082                         cs_automic(codec);
1083
1084                 coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
1085                 if (is_active_pin(codec, CS_DMIC2_PIN_NID))
1086                         coef |= 0x0500; /* DMIC2 2 chan on, GPIO1 off */
1087                 if (is_active_pin(codec, CS_DMIC1_PIN_NID))
1088                         coef |= 0x1800; /* DMIC1 2 chan on, GPIO0 off
1089                                          * No effect if SPDIF_OUT2 is
1090                                          * selected in IDX_SPDIF_CTL.
1091                                         */
1092                 cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
1093         }
1094 }
1095
1096 static const struct hda_verb cs_coef_init_verbs[] = {
1097         {0x11, AC_VERB_SET_PROC_STATE, 1},
1098         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1099         {0x11, AC_VERB_SET_PROC_COEF,
1100          (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
1101           | 0x0040 /* Mute DACs on FIFO error */
1102           | 0x1000 /* Enable DACs High Pass Filter */
1103           | 0x0400 /* Disable Coefficient Auto increment */
1104           )},
1105         /* Beep */
1106         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1107         {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
1108
1109         {} /* terminator */
1110 };
1111
1112 /* Errata: CS4207 rev C0/C1/C2 Silicon
1113  *
1114  * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
1115  *
1116  * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
1117  * may be excessive (up to an additional 200 μA), which is most easily
1118  * observed while the part is being held in reset (RESET# active low).
1119  *
1120  * Root Cause: At initial powerup of the device, the logic that drives
1121  * the clock and write enable to the S/PDIF SRC RAMs is not properly
1122  * initialized.
1123  * Certain random patterns will cause a steady leakage current in those
1124  * RAM cells. The issue will resolve once the SRCs are used (turned on).
1125  *
1126  * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
1127  * blocks, which will alleviate the issue.
1128  */
1129
1130 static const struct hda_verb cs_errata_init_verbs[] = {
1131         {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
1132         {0x11, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1133
1134         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1135         {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
1136         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1137         {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
1138         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1139         {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
1140
1141         {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
1142         {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
1143
1144         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1145         {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
1146         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1147         {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
1148         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1149         {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
1150         {0x11, AC_VERB_SET_PROC_STATE, 0x00},
1151
1152 #if 0 /* Don't to set to D3 as we are in power-up sequence */
1153         {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
1154         {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
1155         /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
1156 #endif
1157
1158         {} /* terminator */
1159 };
1160
1161 /* SPDIF setup */
1162 static void init_digital(struct hda_codec *codec)
1163 {
1164         unsigned int coef;
1165
1166         coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
1167         coef |= 0x0008; /* Replace with mute on error */
1168         if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
1169                 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
1170                                  * SPDIF_OUT2 is shared with GPIO1 and
1171                                  * DMIC_SDA2.
1172                                  */
1173         cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
1174 }
1175
1176 static int cs_init(struct hda_codec *codec)
1177 {
1178         struct cs_spec *spec = codec->spec;
1179
1180         /* init_verb sequence for C0/C1/C2 errata*/
1181         snd_hda_sequence_write(codec, cs_errata_init_verbs);
1182
1183         snd_hda_sequence_write(codec, cs_coef_init_verbs);
1184
1185         if (spec->gpio_mask) {
1186                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1187                                     spec->gpio_mask);
1188                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1189                                     spec->gpio_dir);
1190                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1191                                     spec->gpio_data);
1192         }
1193
1194         init_output(codec);
1195         init_input(codec);
1196         init_digital(codec);
1197         return 0;
1198 }
1199
1200 static int cs_build_controls(struct hda_codec *codec)
1201 {
1202         int err;
1203
1204         err = build_output(codec);
1205         if (err < 0)
1206                 return err;
1207         err = build_input(codec);
1208         if (err < 0)
1209                 return err;
1210         err = build_digital_output(codec);
1211         if (err < 0)
1212                 return err;
1213         err = build_digital_input(codec);
1214         if (err < 0)
1215                 return err;
1216         return cs_init(codec);
1217 }
1218
1219 static void cs_free(struct hda_codec *codec)
1220 {
1221         struct cs_spec *spec = codec->spec;
1222         kfree(spec->capture_bind[0]);
1223         kfree(spec->capture_bind[1]);
1224         kfree(codec->spec);
1225 }
1226
1227 static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
1228 {
1229         switch ((res >> 26) & 0x7f) {
1230         case HP_EVENT:
1231                 cs_automute(codec);
1232                 break;
1233         case MIC_EVENT:
1234                 cs_automic(codec);
1235                 break;
1236         }
1237 }
1238
1239 static const struct hda_codec_ops cs_patch_ops = {
1240         .build_controls = cs_build_controls,
1241         .build_pcms = cs_build_pcms,
1242         .init = cs_init,
1243         .free = cs_free,
1244         .unsol_event = cs_unsol_event,
1245 };
1246
1247 static int cs_parse_auto_config(struct hda_codec *codec)
1248 {
1249         struct cs_spec *spec = codec->spec;
1250         int err;
1251
1252         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1253         if (err < 0)
1254                 return err;
1255
1256         err = parse_output(codec);
1257         if (err < 0)
1258                 return err;
1259         err = parse_input(codec);
1260         if (err < 0)
1261                 return err;
1262         err = parse_digital_output(codec);
1263         if (err < 0)
1264                 return err;
1265         err = parse_digital_input(codec);
1266         if (err < 0)
1267                 return err;
1268         return 0;
1269 }
1270
1271 static const char * const cs420x_models[CS420X_MODELS] = {
1272         [CS420X_MBP53] = "mbp53",
1273         [CS420X_MBP55] = "mbp55",
1274         [CS420X_IMAC27] = "imac27",
1275         [CS420X_AUTO] = "auto",
1276 };
1277
1278
1279 static const struct snd_pci_quirk cs420x_cfg_tbl[] = {
1280         SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
1281         SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
1282         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1283         SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
1284         SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),
1285         {} /* terminator */
1286 };
1287
1288 struct cs_pincfg {
1289         hda_nid_t nid;
1290         u32 val;
1291 };
1292
1293 static const struct cs_pincfg mbp53_pincfgs[] = {
1294         { 0x09, 0x012b4050 },
1295         { 0x0a, 0x90100141 },
1296         { 0x0b, 0x90100140 },
1297         { 0x0c, 0x018b3020 },
1298         { 0x0d, 0x90a00110 },
1299         { 0x0e, 0x400000f0 },
1300         { 0x0f, 0x01cbe030 },
1301         { 0x10, 0x014be060 },
1302         { 0x12, 0x400000f0 },
1303         { 0x15, 0x400000f0 },
1304         {} /* terminator */
1305 };
1306
1307 static const struct cs_pincfg mbp55_pincfgs[] = {
1308         { 0x09, 0x012b4030 },
1309         { 0x0a, 0x90100121 },
1310         { 0x0b, 0x90100120 },
1311         { 0x0c, 0x400000f0 },
1312         { 0x0d, 0x90a00110 },
1313         { 0x0e, 0x400000f0 },
1314         { 0x0f, 0x400000f0 },
1315         { 0x10, 0x014be040 },
1316         { 0x12, 0x400000f0 },
1317         { 0x15, 0x400000f0 },
1318         {} /* terminator */
1319 };
1320
1321 static const struct cs_pincfg imac27_pincfgs[] = {
1322         { 0x09, 0x012b4050 },
1323         { 0x0a, 0x90100140 },
1324         { 0x0b, 0x90100142 },
1325         { 0x0c, 0x018b3020 },
1326         { 0x0d, 0x90a00110 },
1327         { 0x0e, 0x400000f0 },
1328         { 0x0f, 0x01cbe030 },
1329         { 0x10, 0x014be060 },
1330         { 0x12, 0x01ab9070 },
1331         { 0x15, 0x400000f0 },
1332         {} /* terminator */
1333 };
1334
1335 static const struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = {
1336         [CS420X_MBP53] = mbp53_pincfgs,
1337         [CS420X_MBP55] = mbp55_pincfgs,
1338         [CS420X_IMAC27] = imac27_pincfgs,
1339 };
1340
1341 static void fix_pincfg(struct hda_codec *codec, int model,
1342                        const struct cs_pincfg **pin_configs)
1343 {
1344         const struct cs_pincfg *cfg = pin_configs[model];
1345         if (!cfg)
1346                 return;
1347         for (; cfg->nid; cfg++)
1348                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1349 }
1350
1351 static int patch_cs420x(struct hda_codec *codec)
1352 {
1353         struct cs_spec *spec;
1354         int err;
1355
1356         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1357         if (!spec)
1358                 return -ENOMEM;
1359         codec->spec = spec;
1360
1361         spec->vendor_nid = CS420X_VENDOR_NID;
1362
1363         spec->board_config =
1364                 snd_hda_check_board_config(codec, CS420X_MODELS,
1365                                            cs420x_models, cs420x_cfg_tbl);
1366         if (spec->board_config >= 0)
1367                 fix_pincfg(codec, spec->board_config, cs_pincfgs);
1368
1369         switch (spec->board_config) {
1370         case CS420X_IMAC27:
1371         case CS420X_MBP53:
1372         case CS420X_MBP55:
1373                 /* GPIO1 = headphones */
1374                 /* GPIO3 = speakers */
1375                 spec->gpio_mask = 0x0a;
1376                 spec->gpio_dir = 0x0a;
1377                 break;
1378         }
1379
1380         err = cs_parse_auto_config(codec);
1381         if (err < 0)
1382                 goto error;
1383
1384         codec->patch_ops = cs_patch_ops;
1385
1386         return 0;
1387
1388  error:
1389         kfree(codec->spec);
1390         codec->spec = NULL;
1391         return err;
1392 }
1393
1394 /*
1395  * Cirrus Logic CS4210
1396  *
1397  * 1 DAC => HP(sense) / Speakers,
1398  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
1399  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
1400 */
1401
1402 /* CS4210 board names */
1403 static const char *cs421x_models[CS421X_MODELS] = {
1404         [CS421X_CDB4210] = "cdb4210",
1405 };
1406
1407 static const struct snd_pci_quirk cs421x_cfg_tbl[] = {
1408         /* Test Intel board + CDB2410  */
1409         SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
1410         {} /* terminator */
1411 };
1412
1413 /* CS4210 board pinconfigs */
1414 /* Default CS4210 (CDB4210)*/
1415 static const struct cs_pincfg cdb4210_pincfgs[] = {
1416         { 0x05, 0x0321401f },
1417         { 0x06, 0x90170010 },
1418         { 0x07, 0x03813031 },
1419         { 0x08, 0xb7a70037 },
1420         { 0x09, 0xb7a6003e },
1421         { 0x0a, 0x034510f0 },
1422         {} /* terminator */
1423 };
1424
1425 static const struct cs_pincfg *cs421x_pincfgs[CS421X_MODELS] = {
1426         [CS421X_CDB4210] = cdb4210_pincfgs,
1427 };
1428
1429 static const struct hda_verb cs421x_coef_init_verbs[] = {
1430         {0x0B, AC_VERB_SET_PROC_STATE, 1},
1431         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
1432         /*
1433             Disable Coefficient Index Auto-Increment(DAI)=1,
1434             PDREF=0
1435         */
1436         {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
1437
1438         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
1439         /* ADC SZCMode = Digital Soft Ramp */
1440         {0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
1441
1442         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
1443         {0x0B, AC_VERB_SET_PROC_COEF,
1444          (0x0002 /* DAC SZCMode = Digital Soft Ramp */
1445           | 0x0004 /* Mute DAC on FIFO error */
1446           | 0x0008 /* Enable DAC High Pass Filter */
1447           )},
1448         {} /* terminator */
1449 };
1450
1451 /* Errata: CS4210 rev A1 Silicon
1452  *
1453  * http://www.cirrus.com/en/pubs/errata/
1454  *
1455  * Description:
1456  * 1. Performance degredation is present in the ADC.
1457  * 2. Speaker output is not completely muted upon HP detect.
1458  * 3. Noise is present when clipping occurs on the amplified
1459  *    speaker outputs.
1460  *
1461  * Workaround:
1462  * The following verb sequence written to the registers during
1463  * initialization will correct the issues listed above.
1464  */
1465
1466 static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
1467         {0x0B, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1468
1469         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
1470         {0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
1471
1472         {0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
1473         {0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
1474
1475         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
1476         {0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
1477
1478         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
1479         {0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
1480
1481         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
1482         {0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
1483
1484         {} /* terminator */
1485 };
1486
1487 /* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
1488 static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
1489
1490 static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
1491                                 struct snd_ctl_elem_info *uinfo)
1492 {
1493         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1494         uinfo->count = 1;
1495         uinfo->value.integer.min = 0;
1496         uinfo->value.integer.max = 3;
1497         return 0;
1498 }
1499
1500 static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
1501                                 struct snd_ctl_elem_value *ucontrol)
1502 {
1503         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1504
1505         ucontrol->value.integer.value[0] =
1506                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
1507         return 0;
1508 }
1509
1510 static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
1511                                 struct snd_ctl_elem_value *ucontrol)
1512 {
1513         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1514
1515         unsigned int vol = ucontrol->value.integer.value[0];
1516         unsigned int coef =
1517                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
1518         unsigned int original_coef = coef;
1519
1520         coef &= ~0x0003;
1521         coef |= (vol & 0x0003);
1522         if (original_coef == coef)
1523                 return 0;
1524         else {
1525                 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
1526                 return 1;
1527         }
1528 }
1529
1530 static const struct snd_kcontrol_new cs421x_speaker_bost_ctl = {
1531
1532         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1533         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1534                         SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1535         .name = "Speaker Boost Playback Volume",
1536         .info = cs421x_boost_vol_info,
1537         .get = cs421x_boost_vol_get,
1538         .put = cs421x_boost_vol_put,
1539         .tlv = { .p = cs421x_speaker_boost_db_scale },
1540 };
1541
1542 static void cs421x_pinmux_init(struct hda_codec *codec)
1543 {
1544         struct cs_spec *spec = codec->spec;
1545         unsigned int def_conf, coef;
1546
1547         /* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
1548         coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1549
1550         if (spec->gpio_mask)
1551                 coef |= 0x0008; /* B1,B2 are GPIOs */
1552         else
1553                 coef &= ~0x0008;
1554
1555         if (spec->sense_b)
1556                 coef |= 0x0010; /* B2 is SENSE_B, not inverted  */
1557         else
1558                 coef &= ~0x0010;
1559
1560         cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1561
1562         if ((spec->gpio_mask || spec->sense_b) &&
1563             is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
1564
1565                 /*
1566                     GPIO or SENSE_B forced - disconnect the DMIC pin.
1567                 */
1568                 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
1569                 def_conf &= ~AC_DEFCFG_PORT_CONN;
1570                 def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
1571                 snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
1572         }
1573 }
1574
1575 static void init_cs421x_digital(struct hda_codec *codec)
1576 {
1577         struct cs_spec *spec = codec->spec;
1578         struct auto_pin_cfg *cfg = &spec->autocfg;
1579         int i;
1580
1581
1582         for (i = 0; i < cfg->dig_outs; i++) {
1583                 hda_nid_t nid = cfg->dig_out_pins[i];
1584                 if (!cfg->speaker_outs)
1585                         continue;
1586                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1587
1588                         snd_hda_codec_write(codec, nid, 0,
1589                                     AC_VERB_SET_UNSOLICITED_ENABLE,
1590                                     AC_USRSP_EN | SPDIF_EVENT);
1591                         spec->spdif_detect = 1;
1592                 }
1593         }
1594 }
1595
1596 static int cs421x_init(struct hda_codec *codec)
1597 {
1598         struct cs_spec *spec = codec->spec;
1599
1600         snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
1601         snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
1602
1603         cs421x_pinmux_init(codec);
1604
1605         if (spec->gpio_mask) {
1606                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1607                                     spec->gpio_mask);
1608                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1609                                     spec->gpio_dir);
1610                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1611                                     spec->gpio_data);
1612         }
1613
1614         init_output(codec);
1615         init_input(codec);
1616         init_cs421x_digital(codec);
1617
1618         return 0;
1619 }
1620
1621 /*
1622  * CS4210 Input MUX (1 ADC)
1623  */
1624 static int cs421x_mux_enum_info(struct snd_kcontrol *kcontrol,
1625                                         struct snd_ctl_elem_info *uinfo)
1626 {
1627         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1628         struct cs_spec *spec = codec->spec;
1629
1630         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
1631 }
1632
1633 static int cs421x_mux_enum_get(struct snd_kcontrol *kcontrol,
1634                                         struct snd_ctl_elem_value *ucontrol)
1635 {
1636         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1637         struct cs_spec *spec = codec->spec;
1638
1639         ucontrol->value.enumerated.item[0] = spec->cur_input;
1640         return 0;
1641 }
1642
1643 static int cs421x_mux_enum_put(struct snd_kcontrol *kcontrol,
1644                                         struct snd_ctl_elem_value *ucontrol)
1645 {
1646         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1647         struct cs_spec *spec = codec->spec;
1648
1649         return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
1650                                 spec->adc_nid[0], &spec->cur_input);
1651
1652 }
1653
1654 static struct snd_kcontrol_new cs421x_capture_source = {
1655
1656         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1657         .name = "Capture Source",
1658         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1659         .info = cs421x_mux_enum_info,
1660         .get = cs421x_mux_enum_get,
1661         .put = cs421x_mux_enum_put,
1662 };
1663
1664 static int cs421x_add_input_volume_control(struct hda_codec *codec, int item)
1665 {
1666         struct cs_spec *spec = codec->spec;
1667         struct auto_pin_cfg *cfg = &spec->autocfg;
1668         const struct hda_input_mux *imux = &spec->input_mux;
1669         hda_nid_t pin = cfg->inputs[item].pin;
1670         struct snd_kcontrol *kctl;
1671         u32 caps;
1672
1673         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
1674                 return 0;
1675
1676         caps = query_amp_caps(codec, pin, HDA_INPUT);
1677         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1678         if (caps <= 1)
1679                 return 0;
1680
1681         return add_volume(codec,  imux->items[item].label, 0,
1682                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
1683 }
1684
1685 /* add a (input-boost) volume control to the given input pin */
1686 static int build_cs421x_input(struct hda_codec *codec)
1687 {
1688         struct cs_spec *spec = codec->spec;
1689         struct auto_pin_cfg *cfg = &spec->autocfg;
1690         struct hda_input_mux *imux = &spec->input_mux;
1691         int i, err, type_idx;
1692         const char *label;
1693
1694         if (!spec->num_inputs)
1695                 return 0;
1696
1697         /* make bind-capture */
1698         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
1699         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
1700         for (i = 0; i < 2; i++) {
1701                 struct snd_kcontrol *kctl;
1702                 int n;
1703                 if (!spec->capture_bind[i])
1704                         return -ENOMEM;
1705                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
1706                 if (!kctl)
1707                         return -ENOMEM;
1708                 kctl->private_value = (long)spec->capture_bind[i];
1709                 err = snd_hda_ctl_add(codec, 0, kctl);
1710                 if (err < 0)
1711                         return err;
1712                 for (n = 0; n < AUTO_PIN_LAST; n++) {
1713                         if (!spec->adc_nid[n])
1714                                 continue;
1715                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
1716                         if (err < 0)
1717                                 return err;
1718                 }
1719         }
1720
1721         /* Add Input MUX Items + Capture Volume/Switch */
1722         for (i = 0; i < spec->num_inputs; i++) {
1723                 label = hda_get_autocfg_input_label(codec, cfg, i);
1724                 snd_hda_add_imux_item(imux, label, spec->adc_idx[i], &type_idx);
1725
1726                 err = cs421x_add_input_volume_control(codec, i);
1727                 if (err < 0)
1728                         return err;
1729         }
1730
1731         /*
1732             Add 'Capture Source' Switch if
1733                 * 2 inputs and no mic detec
1734                 * 3 inputs
1735         */
1736         if ((spec->num_inputs == 2 && !spec->mic_detect) ||
1737             (spec->num_inputs == 3)) {
1738
1739                 err = snd_hda_ctl_add(codec, spec->adc_nid[0],
1740                               snd_ctl_new1(&cs421x_capture_source, codec));
1741                 if (err < 0)
1742                         return err;
1743         }
1744
1745         return 0;
1746 }
1747
1748 /* Single DAC (Mute/Gain) */
1749 static int build_cs421x_output(struct hda_codec *codec)
1750 {
1751         hda_nid_t dac = CS4210_DAC_NID;
1752         struct cs_spec *spec = codec->spec;
1753         struct auto_pin_cfg *cfg = &spec->autocfg;
1754         struct snd_kcontrol *kctl;
1755         int err;
1756         char *name = "HP/Speakers";
1757
1758         fix_volume_caps(codec, dac);
1759         if (!spec->vmaster_sw) {
1760                 err = add_vmaster(codec, dac);
1761                 if (err < 0)
1762                         return err;
1763         }
1764
1765         err = add_mute(codec, name, 0,
1766                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1767         if (err < 0)
1768                 return err;
1769         err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
1770         if (err < 0)
1771                 return err;
1772
1773         err = add_volume(codec, name, 0,
1774                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1775         if (err < 0)
1776                 return err;
1777         err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
1778         if (err < 0)
1779                 return err;
1780
1781         if (cfg->speaker_outs) {
1782                 err = snd_hda_ctl_add(codec, 0,
1783                         snd_ctl_new1(&cs421x_speaker_bost_ctl, codec));
1784                 if (err < 0)
1785                         return err;
1786         }
1787         return err;
1788 }
1789
1790 static int cs421x_build_controls(struct hda_codec *codec)
1791 {
1792         int err;
1793
1794         err = build_cs421x_output(codec);
1795         if (err < 0)
1796                 return err;
1797         err = build_cs421x_input(codec);
1798         if (err < 0)
1799                 return err;
1800         err = build_digital_output(codec);
1801         if (err < 0)
1802                 return err;
1803         return cs421x_init(codec);
1804 }
1805
1806 static void cs421x_unsol_event(struct hda_codec *codec, unsigned int res)
1807 {
1808         switch ((res >> 26) & 0x3f) {
1809         case HP_EVENT:
1810         case SPDIF_EVENT:
1811                 cs_automute(codec);
1812                 break;
1813
1814         case MIC_EVENT:
1815                 cs_automic(codec);
1816                 break;
1817         }
1818 }
1819
1820 static int parse_cs421x_input(struct hda_codec *codec)
1821 {
1822         struct cs_spec *spec = codec->spec;
1823         struct auto_pin_cfg *cfg = &spec->autocfg;
1824         int i;
1825
1826         for (i = 0; i < cfg->num_inputs; i++) {
1827                 hda_nid_t pin = cfg->inputs[i].pin;
1828                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
1829                 spec->cur_input = spec->last_input = i;
1830                 spec->num_inputs++;
1831
1832                 /* check whether the automatic mic switch is available */
1833                 if (is_ext_mic(codec, i) && cfg->num_inputs >= 2) {
1834                         spec->mic_detect = 1;
1835                         spec->automic_idx = i;
1836                 }
1837         }
1838         return 0;
1839 }
1840
1841 static int cs421x_parse_auto_config(struct hda_codec *codec)
1842 {
1843         struct cs_spec *spec = codec->spec;
1844         int err;
1845
1846         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1847         if (err < 0)
1848                 return err;
1849         err = parse_output(codec);
1850         if (err < 0)
1851                 return err;
1852         err = parse_cs421x_input(codec);
1853         if (err < 0)
1854                 return err;
1855         err = parse_digital_output(codec);
1856         if (err < 0)
1857                 return err;
1858         return 0;
1859 }
1860
1861 #ifdef CONFIG_PM
1862 /*
1863         Manage PDREF, when transitioning to D3hot
1864         (DAC,ADC) -> D3, PDREF=1, AFG->D3
1865 */
1866 static int cs421x_suspend(struct hda_codec *codec, pm_message_t state)
1867 {
1868         unsigned int coef;
1869
1870         snd_hda_shutup_pins(codec);
1871
1872         snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
1873                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1874         snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
1875                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1876
1877         coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1878         coef |= 0x0004; /* PDREF */
1879         cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1880
1881         return 0;
1882 }
1883 #endif
1884
1885 static struct hda_codec_ops cs4210_patch_ops = {
1886         .build_controls = cs421x_build_controls,
1887         .build_pcms = cs_build_pcms,
1888         .init = cs421x_init,
1889         .free = cs_free,
1890         .unsol_event = cs421x_unsol_event,
1891 #ifdef CONFIG_PM
1892         .suspend = cs421x_suspend,
1893 #endif
1894 };
1895
1896 static int patch_cs421x(struct hda_codec *codec)
1897 {
1898         struct cs_spec *spec;
1899         int err;
1900
1901         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1902         if (!spec)
1903                 return -ENOMEM;
1904         codec->spec = spec;
1905
1906         spec->vendor_nid = CS421X_VENDOR_NID;
1907
1908         spec->board_config =
1909                 snd_hda_check_board_config(codec, CS421X_MODELS,
1910                                            cs421x_models, cs421x_cfg_tbl);
1911         if (spec->board_config >= 0)
1912                 fix_pincfg(codec, spec->board_config, cs421x_pincfgs);
1913         /*
1914             Setup GPIO/SENSE for each board (if used)
1915         */
1916         switch (spec->board_config) {
1917         case CS421X_CDB4210:
1918                 snd_printd("CS4210 board: %s\n",
1919                         cs421x_models[spec->board_config]);
1920 /*              spec->gpio_mask = 3;
1921                 spec->gpio_dir = 3;
1922                 spec->gpio_data = 3;
1923 */
1924                 spec->sense_b = 1;
1925
1926                 break;
1927         }
1928
1929         /*
1930             Update the GPIO/DMIC/SENSE_B pinmux before the configuration
1931             is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
1932             is disabled.
1933         */
1934         cs421x_pinmux_init(codec);
1935
1936         err = cs421x_parse_auto_config(codec);
1937         if (err < 0)
1938                 goto error;
1939
1940         codec->patch_ops = cs4210_patch_ops;
1941
1942         return 0;
1943
1944  error:
1945         kfree(codec->spec);
1946         codec->spec = NULL;
1947         return err;
1948 }
1949
1950
1951 /*
1952  * patch entries
1953  */
1954 static const struct hda_codec_preset snd_hda_preset_cirrus[] = {
1955         { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
1956         { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
1957         { .id = 0x10134210, .name = "CS4210", .patch = patch_cs421x },
1958         {} /* terminator */
1959 };
1960
1961 MODULE_ALIAS("snd-hda-codec-id:10134206");
1962 MODULE_ALIAS("snd-hda-codec-id:10134207");
1963 MODULE_ALIAS("snd-hda-codec-id:10134210");
1964
1965 MODULE_LICENSE("GPL");
1966 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
1967
1968 static struct hda_codec_preset_list cirrus_list = {
1969         .preset = snd_hda_preset_cirrus,
1970         .owner = THIS_MODULE,
1971 };
1972
1973 static int __init patch_cirrus_init(void)
1974 {
1975         return snd_hda_add_codec_preset(&cirrus_list);
1976 }
1977
1978 static void __exit patch_cirrus_exit(void)
1979 {
1980         snd_hda_delete_codec_preset(&cirrus_list);
1981 }
1982
1983 module_init(patch_cirrus_init)
1984 module_exit(patch_cirrus_exit)