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