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        0x12
 105 #define CS_DMIC2_PIN_NID        0x0e
 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)
 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)
 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(codec, nid, HP_EVENT);
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);
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(codec, pin, MIC_EVENT);
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);
1080
1081                 coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
1082                 if (is_active_pin(codec, CS_DMIC2_PIN_NID))
1083                         coef |= 0x0500; /* DMIC2 2 chan on, GPIO1 off */
1084                 if (is_active_pin(codec, CS_DMIC1_PIN_NID))
1085                         coef |= 0x1800; /* DMIC1 2 chan on, GPIO0 off
1086                                          * No effect if SPDIF_OUT2 is
1087                                          * selected in IDX_SPDIF_CTL.
1088                                         */
1089                 cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
1090         } else {
1091                 if (spec->mic_detect)
1092                         cs_automic(codec);
1093                 else  {
1094                         spec->cur_adc = spec->adc_nid[spec->cur_input];
1095                         cs_update_input_select(codec);
1096                 }
1097         }
1098 }
1099
1100 static const struct hda_verb cs_coef_init_verbs[] = {
1101         {0x11, AC_VERB_SET_PROC_STATE, 1},
1102         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1103         {0x11, AC_VERB_SET_PROC_COEF,
1104          (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
1105           | 0x0040 /* Mute DACs on FIFO error */
1106           | 0x1000 /* Enable DACs High Pass Filter */
1107           | 0x0400 /* Disable Coefficient Auto increment */
1108           )},
1109         /* Beep */
1110         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1111         {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
1112
1113         {} /* terminator */
1114 };
1115
1116 /* Errata: CS4207 rev C0/C1/C2 Silicon
1117  *
1118  * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
1119  *
1120  * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
1121  * may be excessive (up to an additional 200 μA), which is most easily
1122  * observed while the part is being held in reset (RESET# active low).
1123  *
1124  * Root Cause: At initial powerup of the device, the logic that drives
1125  * the clock and write enable to the S/PDIF SRC RAMs is not properly
1126  * initialized.
1127  * Certain random patterns will cause a steady leakage current in those
1128  * RAM cells. The issue will resolve once the SRCs are used (turned on).
1129  *
1130  * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
1131  * blocks, which will alleviate the issue.
1132  */
1133
1134 static const struct hda_verb cs_errata_init_verbs[] = {
1135         {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
1136         {0x11, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1137
1138         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1139         {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
1140         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1141         {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
1142         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1143         {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
1144
1145         {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
1146         {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
1147
1148         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1149         {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
1150         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1151         {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
1152         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1153         {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
1154         {0x11, AC_VERB_SET_PROC_STATE, 0x00},
1155
1156 #if 0 /* Don't to set to D3 as we are in power-up sequence */
1157         {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
1158         {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
1159         /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
1160 #endif
1161
1162         {} /* terminator */
1163 };
1164
1165 static const struct hda_verb mbp101_init_verbs[] = {
1166         {0x11, AC_VERB_SET_COEF_INDEX, 0x0002},
1167         {0x11, AC_VERB_SET_PROC_COEF, 0x100a},
1168         {0x11, AC_VERB_SET_COEF_INDEX, 0x0004},
1169         {0x11, AC_VERB_SET_PROC_COEF, 0x000f},
1170         {}
1171 };
1172
1173 /* SPDIF setup */
1174 static void init_digital(struct hda_codec *codec)
1175 {
1176         unsigned int coef;
1177
1178         coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
1179         coef |= 0x0008; /* Replace with mute on error */
1180         if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
1181                 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
1182                                  * SPDIF_OUT2 is shared with GPIO1 and
1183                                  * DMIC_SDA2.
1184                                  */
1185         cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
1186 }
1187
1188 static int cs_init(struct hda_codec *codec)
1189 {
1190         struct cs_spec *spec = codec->spec;
1191
1192         /* init_verb sequence for C0/C1/C2 errata*/
1193         snd_hda_sequence_write(codec, cs_errata_init_verbs);
1194
1195         snd_hda_sequence_write(codec, cs_coef_init_verbs);
1196
1197         if (spec->gpio_mask) {
1198                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1199                                     spec->gpio_mask);
1200                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1201                                     spec->gpio_dir);
1202                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1203                                     spec->gpio_data);
1204         }
1205
1206         init_output(codec);
1207         init_input(codec);
1208         init_digital(codec);
1209
1210         return 0;
1211 }
1212
1213 static int cs_build_controls(struct hda_codec *codec)
1214 {
1215         struct cs_spec *spec = codec->spec;
1216         int err;
1217
1218         err = build_output(codec);
1219         if (err < 0)
1220                 return err;
1221         err = build_input(codec);
1222         if (err < 0)
1223                 return err;
1224         err = build_digital_output(codec);
1225         if (err < 0)
1226                 return err;
1227         err = build_digital_input(codec);
1228         if (err < 0)
1229                 return err;
1230         err = cs_init(codec);
1231         if (err < 0)
1232                 return err;
1233
1234         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1235         if (err < 0)
1236                 return err;
1237
1238         return 0;
1239 }
1240
1241 static void cs_free(struct hda_codec *codec)
1242 {
1243         struct cs_spec *spec = codec->spec;
1244         kfree(spec->capture_bind[0]);
1245         kfree(spec->capture_bind[1]);
1246         kfree(codec->spec);
1247 }
1248
1249 static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
1250 {
1251         switch (snd_hda_jack_get_action(codec, res >> 26)) {
1252         case HP_EVENT:
1253                 cs_automute(codec);
1254                 break;
1255         case MIC_EVENT:
1256                 cs_automic(codec);
1257                 break;
1258         }
1259         snd_hda_jack_report_sync(codec);
1260 }
1261
1262 static const struct hda_codec_ops cs_patch_ops = {
1263         .build_controls = cs_build_controls,
1264         .build_pcms = cs_build_pcms,
1265         .init = cs_init,
1266         .free = cs_free,
1267         .unsol_event = cs_unsol_event,
1268 };
1269
1270 static int cs_parse_auto_config(struct hda_codec *codec)
1271 {
1272         struct cs_spec *spec = codec->spec;
1273         int err;
1274
1275         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1276         if (err < 0)
1277                 return err;
1278
1279         err = parse_output(codec);
1280         if (err < 0)
1281                 return err;
1282         err = parse_input(codec);
1283         if (err < 0)
1284                 return err;
1285         err = parse_digital_output(codec);
1286         if (err < 0)
1287                 return err;
1288         err = parse_digital_input(codec);
1289         if (err < 0)
1290                 return err;
1291         return 0;
1292 }
1293
1294 static const struct hda_model_fixup cs420x_models[] = {
1295         { .id = CS420X_MBP53, .name = "mbp53" },
1296         { .id = CS420X_MBP55, .name = "mbp55" },
1297         { .id = CS420X_IMAC27, .name = "imac27" },
1298         { .id = CS420X_IMAC27_122, .name = "imac27_122" },
1299         { .id = CS420X_APPLE, .name = "apple" },
1300         { .id = CS420X_MBP101, .name = "mbp101" },
1301         {}
1302 };
1303
1304 static const struct snd_pci_quirk cs420x_fixup_tbl[] = {
1305         SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
1306         SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
1307         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1308         SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
1309         /* this conflicts with too many other models */
1310         /*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
1311
1312         /* codec SSID */
1313         SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),
1314         SND_PCI_QUIRK(0x106b, 0x2800, "MacBookPro 10,1", CS420X_MBP101),
1315         SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
1316         {} /* terminator */
1317 };
1318
1319 static const struct hda_pintbl mbp53_pincfgs[] = {
1320         { 0x09, 0x012b4050 },
1321         { 0x0a, 0x90100141 },
1322         { 0x0b, 0x90100140 },
1323         { 0x0c, 0x018b3020 },
1324         { 0x0d, 0x90a00110 },
1325         { 0x0e, 0x400000f0 },
1326         { 0x0f, 0x01cbe030 },
1327         { 0x10, 0x014be060 },
1328         { 0x12, 0x400000f0 },
1329         { 0x15, 0x400000f0 },
1330         {} /* terminator */
1331 };
1332
1333 static const struct hda_pintbl mbp55_pincfgs[] = {
1334         { 0x09, 0x012b4030 },
1335         { 0x0a, 0x90100121 },
1336         { 0x0b, 0x90100120 },
1337         { 0x0c, 0x400000f0 },
1338         { 0x0d, 0x90a00110 },
1339         { 0x0e, 0x400000f0 },
1340         { 0x0f, 0x400000f0 },
1341         { 0x10, 0x014be040 },
1342         { 0x12, 0x400000f0 },
1343         { 0x15, 0x400000f0 },
1344         {} /* terminator */
1345 };
1346
1347 static const struct hda_pintbl imac27_pincfgs[] = {
1348         { 0x09, 0x012b4050 },
1349         { 0x0a, 0x90100140 },
1350         { 0x0b, 0x90100142 },
1351         { 0x0c, 0x018b3020 },
1352         { 0x0d, 0x90a00110 },
1353         { 0x0e, 0x400000f0 },
1354         { 0x0f, 0x01cbe030 },
1355         { 0x10, 0x014be060 },
1356         { 0x12, 0x01ab9070 },
1357         { 0x15, 0x400000f0 },
1358         {} /* terminator */
1359 };
1360
1361 static const struct hda_pintbl mbp101_pincfgs[] = {
1362         { 0x0d, 0x40ab90f0 },
1363         { 0x0e, 0x90a600f0 },
1364         { 0x12, 0x50a600f0 },
1365         {} /* terminator */
1366 };
1367
1368 static void cs420x_fixup_gpio_13(struct hda_codec *codec,
1369                                  const struct hda_fixup *fix, int action)
1370 {
1371         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1372                 struct cs_spec *spec = codec->spec;
1373                 spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
1374                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1375                 spec->gpio_mask = spec->gpio_dir =
1376                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1377         }
1378 }
1379
1380 static void cs420x_fixup_gpio_23(struct hda_codec *codec,
1381                                  const struct hda_fixup *fix, int action)
1382 {
1383         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1384                 struct cs_spec *spec = codec->spec;
1385                 spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
1386                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1387                 spec->gpio_mask = spec->gpio_dir =
1388                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1389         }
1390 }
1391
1392 static const struct hda_fixup cs420x_fixups[] = {
1393         [CS420X_MBP53] = {
1394                 .type = HDA_FIXUP_PINS,
1395                 .v.pins = mbp53_pincfgs,
1396                 .chained = true,
1397                 .chain_id = CS420X_APPLE,
1398         },
1399         [CS420X_MBP55] = {
1400                 .type = HDA_FIXUP_PINS,
1401                 .v.pins = mbp55_pincfgs,
1402                 .chained = true,
1403                 .chain_id = CS420X_GPIO_13,
1404         },
1405         [CS420X_IMAC27] = {
1406                 .type = HDA_FIXUP_PINS,
1407                 .v.pins = imac27_pincfgs,
1408                 .chained = true,
1409                 .chain_id = CS420X_GPIO_13,
1410         },
1411         [CS420X_GPIO_13] = {
1412                 .type = HDA_FIXUP_FUNC,
1413                 .v.func = cs420x_fixup_gpio_13,
1414         },
1415         [CS420X_GPIO_23] = {
1416                 .type = HDA_FIXUP_FUNC,
1417                 .v.func = cs420x_fixup_gpio_23,
1418         },
1419         [CS420X_MBP101] = {
1420                 .type = HDA_FIXUP_PINS,
1421                 .v.pins = mbp101_pincfgs,
1422                 .chained = true,
1423                 .chain_id = CS420X_MBP101_COEF,
1424         },
1425         [CS420X_MBP101_COEF] = {
1426                 .type = HDA_FIXUP_VERBS,
1427                 .v.verbs = mbp101_init_verbs,
1428                 .chained = true,
1429                 .chain_id = CS420X_GPIO_13,
1430         },
1431 };
1432
1433 static int patch_cs420x(struct hda_codec *codec)
1434 {
1435         struct cs_spec *spec;
1436         int err;
1437
1438         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1439         if (!spec)
1440                 return -ENOMEM;
1441         codec->spec = spec;
1442
1443         spec->vendor_nid = CS420X_VENDOR_NID;
1444
1445         snd_hda_pick_fixup(codec, cs420x_models, cs420x_fixup_tbl,
1446                            cs420x_fixups);
1447         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1448
1449         err = cs_parse_auto_config(codec);
1450         if (err < 0)
1451                 goto error;
1452
1453         codec->patch_ops = cs_patch_ops;
1454
1455         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1456
1457         return 0;
1458
1459  error:
1460         kfree(codec->spec);
1461         codec->spec = NULL;
1462         return err;
1463 }
1464
1465 /*
1466  * Cirrus Logic CS4210
1467  *
1468  * 1 DAC => HP(sense) / Speakers,
1469  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
1470  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
1471 */
1472
1473 /* CS4210 board names */
1474 static const struct hda_model_fixup cs421x_models[] = {
1475         { .id = CS421X_CDB4210, .name = "cdb4210" },
1476         {}
1477 };
1478
1479 static const struct snd_pci_quirk cs421x_fixup_tbl[] = {
1480         /* Test Intel board + CDB2410  */
1481         SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
1482         {} /* terminator */
1483 };
1484
1485 /* CS4210 board pinconfigs */
1486 /* Default CS4210 (CDB4210)*/
1487 static const struct hda_pintbl cdb4210_pincfgs[] = {
1488         { 0x05, 0x0321401f },
1489         { 0x06, 0x90170010 },
1490         { 0x07, 0x03813031 },
1491         { 0x08, 0xb7a70037 },
1492         { 0x09, 0xb7a6003e },
1493         { 0x0a, 0x034510f0 },
1494         {} /* terminator */
1495 };
1496
1497 /* Setup GPIO/SENSE for each board (if used) */
1498 static void cs421x_fixup_sense_b(struct hda_codec *codec,
1499                                  const struct hda_fixup *fix, int action)
1500 {
1501         struct cs_spec *spec = codec->spec;
1502         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1503                 spec->sense_b = 1;
1504 }
1505
1506 static const struct hda_fixup cs421x_fixups[] = {
1507         [CS421X_CDB4210] = {
1508                 .type = HDA_FIXUP_PINS,
1509                 .v.pins = cdb4210_pincfgs,
1510                 .chained = true,
1511                 .chain_id = CS421X_SENSE_B,
1512         },
1513         [CS421X_SENSE_B] = {
1514                 .type = HDA_FIXUP_FUNC,
1515                 .v.func = cs421x_fixup_sense_b,
1516         }
1517 };
1518
1519 static const struct hda_verb cs421x_coef_init_verbs[] = {
1520         {0x0B, AC_VERB_SET_PROC_STATE, 1},
1521         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
1522         /*
1523             Disable Coefficient Index Auto-Increment(DAI)=1,
1524             PDREF=0
1525         */
1526         {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
1527
1528         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
1529         /* ADC SZCMode = Digital Soft Ramp */
1530         {0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
1531
1532         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
1533         {0x0B, AC_VERB_SET_PROC_COEF,
1534          (0x0002 /* DAC SZCMode = Digital Soft Ramp */
1535           | 0x0004 /* Mute DAC on FIFO error */
1536           | 0x0008 /* Enable DAC High Pass Filter */
1537           )},
1538         {} /* terminator */
1539 };
1540
1541 /* Errata: CS4210 rev A1 Silicon
1542  *
1543  * http://www.cirrus.com/en/pubs/errata/
1544  *
1545  * Description:
1546  * 1. Performance degredation is present in the ADC.
1547  * 2. Speaker output is not completely muted upon HP detect.
1548  * 3. Noise is present when clipping occurs on the amplified
1549  *    speaker outputs.
1550  *
1551  * Workaround:
1552  * The following verb sequence written to the registers during
1553  * initialization will correct the issues listed above.
1554  */
1555
1556 static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
1557         {0x0B, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1558
1559         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
1560         {0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
1561
1562         {0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
1563         {0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
1564
1565         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
1566         {0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
1567
1568         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
1569         {0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
1570
1571         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
1572         {0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
1573
1574         {} /* terminator */
1575 };
1576
1577 /* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
1578 static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
1579
1580 static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
1581                                 struct snd_ctl_elem_info *uinfo)
1582 {
1583         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1584         uinfo->count = 1;
1585         uinfo->value.integer.min = 0;
1586         uinfo->value.integer.max = 3;
1587         return 0;
1588 }
1589
1590 static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
1591                                 struct snd_ctl_elem_value *ucontrol)
1592 {
1593         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1594
1595         ucontrol->value.integer.value[0] =
1596                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
1597         return 0;
1598 }
1599
1600 static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
1601                                 struct snd_ctl_elem_value *ucontrol)
1602 {
1603         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1604
1605         unsigned int vol = ucontrol->value.integer.value[0];
1606         unsigned int coef =
1607                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
1608         unsigned int original_coef = coef;
1609
1610         coef &= ~0x0003;
1611         coef |= (vol & 0x0003);
1612         if (original_coef == coef)
1613                 return 0;
1614         else {
1615                 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
1616                 return 1;
1617         }
1618 }
1619
1620 static const struct snd_kcontrol_new cs421x_speaker_bost_ctl = {
1621
1622         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1623         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1624                         SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1625         .name = "Speaker Boost Playback Volume",
1626         .info = cs421x_boost_vol_info,
1627         .get = cs421x_boost_vol_get,
1628         .put = cs421x_boost_vol_put,
1629         .tlv = { .p = cs421x_speaker_boost_db_scale },
1630 };
1631
1632 static void cs4210_pinmux_init(struct hda_codec *codec)
1633 {
1634         struct cs_spec *spec = codec->spec;
1635         unsigned int def_conf, coef;
1636
1637         /* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
1638         coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1639
1640         if (spec->gpio_mask)
1641                 coef |= 0x0008; /* B1,B2 are GPIOs */
1642         else
1643                 coef &= ~0x0008;
1644
1645         if (spec->sense_b)
1646                 coef |= 0x0010; /* B2 is SENSE_B, not inverted  */
1647         else
1648                 coef &= ~0x0010;
1649
1650         cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1651
1652         if ((spec->gpio_mask || spec->sense_b) &&
1653             is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
1654
1655                 /*
1656                     GPIO or SENSE_B forced - disconnect the DMIC pin.
1657                 */
1658                 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
1659                 def_conf &= ~AC_DEFCFG_PORT_CONN;
1660                 def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
1661                 snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
1662         }
1663 }
1664
1665 static void init_cs421x_digital(struct hda_codec *codec)
1666 {
1667         struct cs_spec *spec = codec->spec;
1668         struct auto_pin_cfg *cfg = &spec->autocfg;
1669         int i;
1670
1671
1672         for (i = 0; i < cfg->dig_outs; i++) {
1673                 hda_nid_t nid = cfg->dig_out_pins[i];
1674                 if (!cfg->speaker_outs)
1675                         continue;
1676                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1677                         snd_hda_jack_detect_enable(codec, nid, SPDIF_EVENT);
1678                         spec->spdif_detect = 1;
1679                 }
1680         }
1681 }
1682
1683 static int cs421x_init(struct hda_codec *codec)
1684 {
1685         struct cs_spec *spec = codec->spec;
1686
1687         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1688                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
1689                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
1690                 cs4210_pinmux_init(codec);
1691         }
1692
1693         if (spec->gpio_mask) {
1694                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1695                                     spec->gpio_mask);
1696                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1697                                     spec->gpio_dir);
1698                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1699                                     spec->gpio_data);
1700         }
1701
1702         init_output(codec);
1703         init_input(codec);
1704         init_cs421x_digital(codec);
1705
1706         return 0;
1707 }
1708
1709 /*
1710  * CS4210 Input MUX (1 ADC)
1711  */
1712 static int cs421x_mux_enum_info(struct snd_kcontrol *kcontrol,
1713                                         struct snd_ctl_elem_info *uinfo)
1714 {
1715         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1716         struct cs_spec *spec = codec->spec;
1717
1718         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
1719 }
1720
1721 static int cs421x_mux_enum_get(struct snd_kcontrol *kcontrol,
1722                                         struct snd_ctl_elem_value *ucontrol)
1723 {
1724         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1725         struct cs_spec *spec = codec->spec;
1726
1727         ucontrol->value.enumerated.item[0] = spec->cur_input;
1728         return 0;
1729 }
1730
1731 static int cs421x_mux_enum_put(struct snd_kcontrol *kcontrol,
1732                                         struct snd_ctl_elem_value *ucontrol)
1733 {
1734         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1735         struct cs_spec *spec = codec->spec;
1736
1737         return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
1738                                 spec->adc_nid[0], &spec->cur_input);
1739
1740 }
1741
1742 static struct snd_kcontrol_new cs421x_capture_source = {
1743
1744         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1745         .name = "Capture Source",
1746         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1747         .info = cs421x_mux_enum_info,
1748         .get = cs421x_mux_enum_get,
1749         .put = cs421x_mux_enum_put,
1750 };
1751
1752 static int cs421x_add_input_volume_control(struct hda_codec *codec, int item)
1753 {
1754         struct cs_spec *spec = codec->spec;
1755         struct auto_pin_cfg *cfg = &spec->autocfg;
1756         const struct hda_input_mux *imux = &spec->input_mux;
1757         hda_nid_t pin = cfg->inputs[item].pin;
1758         struct snd_kcontrol *kctl;
1759         u32 caps;
1760
1761         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
1762                 return 0;
1763
1764         caps = query_amp_caps(codec, pin, HDA_INPUT);
1765         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1766         if (caps <= 1)
1767                 return 0;
1768
1769         return add_volume(codec,  imux->items[item].label, 0,
1770                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
1771 }
1772
1773 /* add a (input-boost) volume control to the given input pin */
1774 static int build_cs421x_input(struct hda_codec *codec)
1775 {
1776         struct cs_spec *spec = codec->spec;
1777         struct auto_pin_cfg *cfg = &spec->autocfg;
1778         struct hda_input_mux *imux = &spec->input_mux;
1779         int i, err, type_idx;
1780         const char *label;
1781
1782         if (!spec->num_inputs)
1783                 return 0;
1784
1785         /* make bind-capture */
1786         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
1787         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
1788         for (i = 0; i < 2; i++) {
1789                 struct snd_kcontrol *kctl;
1790                 int n;
1791                 if (!spec->capture_bind[i])
1792                         return -ENOMEM;
1793                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
1794                 if (!kctl)
1795                         return -ENOMEM;
1796                 kctl->private_value = (long)spec->capture_bind[i];
1797                 err = snd_hda_ctl_add(codec, 0, kctl);
1798                 if (err < 0)
1799                         return err;
1800                 for (n = 0; n < AUTO_PIN_LAST; n++) {
1801                         if (!spec->adc_nid[n])
1802                                 continue;
1803                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
1804                         if (err < 0)
1805                                 return err;
1806                 }
1807         }
1808
1809         /* Add Input MUX Items + Capture Volume/Switch */
1810         for (i = 0; i < spec->num_inputs; i++) {
1811                 label = hda_get_autocfg_input_label(codec, cfg, i);
1812                 snd_hda_add_imux_item(imux, label, spec->adc_idx[i], &type_idx);
1813
1814                 err = cs421x_add_input_volume_control(codec, i);
1815                 if (err < 0)
1816                         return err;
1817         }
1818
1819         /*
1820             Add 'Capture Source' Switch if
1821                 * 2 inputs and no mic detec
1822                 * 3 inputs
1823         */
1824         if ((spec->num_inputs == 2 && !spec->mic_detect) ||
1825             (spec->num_inputs == 3)) {
1826
1827                 err = snd_hda_ctl_add(codec, spec->adc_nid[0],
1828                               snd_ctl_new1(&cs421x_capture_source, codec));
1829                 if (err < 0)
1830                         return err;
1831         }
1832
1833         return 0;
1834 }
1835
1836 /* Single DAC (Mute/Gain) */
1837 static int build_cs421x_output(struct hda_codec *codec)
1838 {
1839         hda_nid_t dac = CS4210_DAC_NID;
1840         struct cs_spec *spec = codec->spec;
1841         struct auto_pin_cfg *cfg = &spec->autocfg;
1842         struct snd_kcontrol *kctl;
1843         int err;
1844         char *name = "Master";
1845
1846         fix_volume_caps(codec, dac);
1847
1848         err = add_mute(codec, name, 0,
1849                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1850         if (err < 0)
1851                 return err;
1852
1853         err = add_volume(codec, name, 0,
1854                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1855         if (err < 0)
1856                 return err;
1857
1858         if (cfg->speaker_outs && (spec->vendor_nid == CS4210_VENDOR_NID)) {
1859                 err = snd_hda_ctl_add(codec, 0,
1860                         snd_ctl_new1(&cs421x_speaker_bost_ctl, codec));
1861                 if (err < 0)
1862                         return err;
1863         }
1864         return err;
1865 }
1866
1867 static int cs421x_build_controls(struct hda_codec *codec)
1868 {
1869         struct cs_spec *spec = codec->spec;
1870         int err;
1871
1872         err = build_cs421x_output(codec);
1873         if (err < 0)
1874                 return err;
1875         err = build_cs421x_input(codec);
1876         if (err < 0)
1877                 return err;
1878         err = build_digital_output(codec);
1879         if (err < 0)
1880                 return err;
1881         err =  cs421x_init(codec);
1882         if (err < 0)
1883                 return err;
1884
1885         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1886         if (err < 0)
1887                 return err;
1888
1889         return 0;
1890 }
1891
1892 static void cs421x_unsol_event(struct hda_codec *codec, unsigned int res)
1893 {
1894         switch (snd_hda_jack_get_action(codec, res >> 26)) {
1895         case HP_EVENT:
1896         case SPDIF_EVENT:
1897                 cs_automute(codec);
1898                 break;
1899
1900         case MIC_EVENT:
1901                 cs_automic(codec);
1902                 break;
1903         }
1904         snd_hda_jack_report_sync(codec);
1905 }
1906
1907 static int parse_cs421x_input(struct hda_codec *codec)
1908 {
1909         struct cs_spec *spec = codec->spec;
1910         struct auto_pin_cfg *cfg = &spec->autocfg;
1911         int i;
1912
1913         for (i = 0; i < cfg->num_inputs; i++) {
1914                 hda_nid_t pin = cfg->inputs[i].pin;
1915                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
1916                 spec->cur_input = spec->last_input = i;
1917                 spec->num_inputs++;
1918
1919                 /* check whether the automatic mic switch is available */
1920                 if (is_ext_mic(codec, i) && cfg->num_inputs >= 2) {
1921                         spec->mic_detect = 1;
1922                         spec->automic_idx = i;
1923                 }
1924         }
1925         return 0;
1926 }
1927
1928 static int cs421x_parse_auto_config(struct hda_codec *codec)
1929 {
1930         struct cs_spec *spec = codec->spec;
1931         int err;
1932
1933         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1934         if (err < 0)
1935                 return err;
1936         err = parse_output(codec);
1937         if (err < 0)
1938                 return err;
1939         err = parse_cs421x_input(codec);
1940         if (err < 0)
1941                 return err;
1942         err = parse_digital_output(codec);
1943         if (err < 0)
1944                 return err;
1945         return 0;
1946 }
1947
1948 #ifdef CONFIG_PM
1949 /*
1950         Manage PDREF, when transitioning to D3hot
1951         (DAC,ADC) -> D3, PDREF=1, AFG->D3
1952 */
1953 static int cs421x_suspend(struct hda_codec *codec)
1954 {
1955         struct cs_spec *spec = codec->spec;
1956         unsigned int coef;
1957
1958         snd_hda_shutup_pins(codec);
1959
1960         snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
1961                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1962         snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
1963                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1964
1965         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1966                 coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1967                 coef |= 0x0004; /* PDREF */
1968                 cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1969         }
1970
1971         return 0;
1972 }
1973 #endif
1974
1975 static struct hda_codec_ops cs421x_patch_ops = {
1976         .build_controls = cs421x_build_controls,
1977         .build_pcms = cs_build_pcms,
1978         .init = cs421x_init,
1979         .free = cs_free,
1980         .unsol_event = cs421x_unsol_event,
1981 #ifdef CONFIG_PM
1982         .suspend = cs421x_suspend,
1983 #endif
1984 };
1985
1986 static int patch_cs4210(struct hda_codec *codec)
1987 {
1988         struct cs_spec *spec;
1989         int err;
1990
1991         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1992         if (!spec)
1993                 return -ENOMEM;
1994         codec->spec = spec;
1995
1996         spec->vendor_nid = CS4210_VENDOR_NID;
1997
1998         snd_hda_pick_fixup(codec, cs421x_models, cs421x_fixup_tbl,
1999                            cs421x_fixups);
2000         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2001
2002         /*
2003             Update the GPIO/DMIC/SENSE_B pinmux before the configuration
2004             is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
2005             is disabled.
2006         */
2007         cs4210_pinmux_init(codec);
2008
2009         err = cs421x_parse_auto_config(codec);
2010         if (err < 0)
2011                 goto error;
2012
2013         codec->patch_ops = cs421x_patch_ops;
2014
2015         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2016
2017         return 0;
2018
2019  error:
2020         kfree(codec->spec);
2021         codec->spec = NULL;
2022         return err;
2023 }
2024
2025 static int patch_cs4213(struct hda_codec *codec)
2026 {
2027         struct cs_spec *spec;
2028         int err;
2029
2030         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2031         if (!spec)
2032                 return -ENOMEM;
2033         codec->spec = spec;
2034
2035         spec->vendor_nid = CS4213_VENDOR_NID;
2036
2037         err = cs421x_parse_auto_config(codec);
2038         if (err < 0)
2039                 goto error;
2040
2041         codec->patch_ops = cs421x_patch_ops;
2042         return 0;
2043
2044  error:
2045         kfree(codec->spec);
2046         codec->spec = NULL;
2047         return err;
2048 }
2049
2050
2051 /*
2052  * patch entries
2053  */
2054 static const struct hda_codec_preset snd_hda_preset_cirrus[] = {
2055         { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
2056         { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
2057         { .id = 0x10134210, .name = "CS4210", .patch = patch_cs4210 },
2058         { .id = 0x10134213, .name = "CS4213", .patch = patch_cs4213 },
2059         {} /* terminator */
2060 };
2061
2062 MODULE_ALIAS("snd-hda-codec-id:10134206");
2063 MODULE_ALIAS("snd-hda-codec-id:10134207");
2064 MODULE_ALIAS("snd-hda-codec-id:10134210");
2065 MODULE_ALIAS("snd-hda-codec-id:10134213");
2066
2067 MODULE_LICENSE("GPL");
2068 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
2069
2070 static struct hda_codec_preset_list cirrus_list = {
2071         .preset = snd_hda_preset_cirrus,
2072         .owner = THIS_MODULE,
2073 };
2074
2075 static int __init patch_cirrus_init(void)
2076 {
2077         return snd_hda_add_codec_preset(&cirrus_list);
2078 }
2079
2080 static void __exit patch_cirrus_exit(void)
2081 {
2082         snd_hda_delete_codec_preset(&cirrus_list);
2083 }
2084
2085 module_init(patch_cirrus_init)
2086 module_exit(patch_cirrus_exit)