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