Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit db8e8a9d authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: hda - Remove the obsoleted static quirk codes from patch_cmedia.c 



The static quirk code has been disabled for a while and it seems
working fine, so it's time to actually get rid of it.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent d0ea6d27

sound/pci/hda/patch_cmedia.c

+9 −615
Original line number Diff line number Diff line
@@ -31,549 +31,10 @@ 
#include "hda_jack.h"

#include "hda_generic.h"



#undef ENABLE_CMI_STATIC_QUIRKS



#ifdef ENABLE_CMI_STATIC_QUIRKS

#define NUM_PINS	11





/* board config type */

enum {

	CMI_MINIMAL,	/* back 3-jack */

	CMI_MIN_FP,	/* back 3-jack + front-panel 2-jack */

	CMI_FULL,	/* back 6-jack + front-panel 2-jack */

	CMI_FULL_DIG,	/* back 6-jack + front-panel 2-jack + digital I/O */

	CMI_ALLOUT,	/* back 5-jack + front-panel 2-jack + digital out */

	CMI_AUTO,	/* let driver guess it */

	CMI_MODELS

};

#endif /* ENABLE_CMI_STATIC_QUIRKS */



struct cmi_spec {

	struct hda_gen_spec gen;



#ifdef ENABLE_CMI_STATIC_QUIRKS

	/* below are only for static models */



	int board_config;

	unsigned int no_line_in: 1;	/* no line-in (5-jack) */

	unsigned int front_panel: 1;	/* has front-panel 2-jack */



	/* playback */

	struct hda_multi_out multiout;

	hda_nid_t dac_nids[AUTO_CFG_MAX_OUTS];	/* NID for each DAC */

	int num_dacs;



	/* capture */

	const hda_nid_t *adc_nids;

	hda_nid_t dig_in_nid;



	/* capture source */

	const struct hda_input_mux *input_mux;

	unsigned int cur_mux[2];



	/* channel mode */

	int num_channel_modes;

	const struct hda_channel_mode *channel_modes;



	struct hda_pcm pcm_rec[2];	/* PCM information */



	/* pin default configuration */

	hda_nid_t pin_nid[NUM_PINS];

	unsigned int def_conf[NUM_PINS];

	unsigned int pin_def_confs;



	/* multichannel pins */

	struct hda_verb multi_init[9];	/* 2 verbs for each pin + terminator */

#endif /* ENABLE_CMI_STATIC_QUIRKS */

};



#ifdef ENABLE_CMI_STATIC_QUIRKS

/*

 * input MUX

 */

static int cmi_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	return snd_hda_input_mux_info(spec->input_mux, uinfo);

}



static int cmi_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);



	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];

	return 0;

}



static int cmi_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);



	return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,

				     spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]);

}



/*

 * shared line-in, mic for surrounds

 */



/* 3-stack / 2 channel */

static const struct hda_verb cmi9880_ch2_init[] = {

	/* set line-in PIN for input */

	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },

	/* set mic PIN for input, also enable vref */

	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },

	/* route front PCM (DAC1) to HP */

	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },

	{}

};



/* 3-stack / 6 channel */

static const struct hda_verb cmi9880_ch6_init[] = {

	/* set line-in PIN for output */

	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },

	/* set mic PIN for output */

	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },

	/* route front PCM (DAC1) to HP */

	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },

	{}

};



/* 3-stack+front / 8 channel */

static const struct hda_verb cmi9880_ch8_init[] = {

	/* set line-in PIN for output */

	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },

	/* set mic PIN for output */

	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },

	/* route rear-surround PCM (DAC4) to HP */

	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x03 },

	{}

};



static const struct hda_channel_mode cmi9880_channel_modes[3] = {

	{ 2, cmi9880_ch2_init },

	{ 6, cmi9880_ch6_init },

	{ 8, cmi9880_ch8_init },

};



static int cmi_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_modes,

				    spec->num_channel_modes);

}



static int cmi_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_modes,

				   spec->num_channel_modes, spec->multiout.max_channels);

}



static int cmi_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

{

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	struct cmi_spec *spec = codec->spec;

	return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_modes,

				   spec->num_channel_modes, &spec->multiout.max_channels);

}



/*

 */

static const struct snd_kcontrol_new cmi9880_basic_mixer[] = {

	/* CMI9880 has no playback volumes! */

	HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), /* front */

	HDA_CODEC_MUTE("Surround Playback Switch", 0x04, 0x0, HDA_OUTPUT),

	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),

	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),

	HDA_CODEC_MUTE("Side Playback Switch", 0x06, 0x0, HDA_OUTPUT),

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		/* The multiple "Capture Source" controls confuse alsamixer

		 * So call somewhat different..

		 */

		/* .name = "Capture Source", */

		.name = "Input Source",

		.count = 2,

		.info = cmi_mux_enum_info,

		.get = cmi_mux_enum_get,

		.put = cmi_mux_enum_put,

	},

	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0, HDA_INPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0, HDA_INPUT),

	HDA_CODEC_MUTE("Capture Switch", 0x08, 0, HDA_INPUT),

	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0, HDA_INPUT),

	HDA_CODEC_VOLUME("Beep Playback Volume", 0x23, 0, HDA_OUTPUT),

	HDA_CODEC_MUTE("Beep Playback Switch", 0x23, 0, HDA_OUTPUT),

	{ } /* end */

};



/*

 * shared I/O pins

 */

static const struct snd_kcontrol_new cmi9880_ch_mode_mixer[] = {

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		.name = "Channel Mode",

		.info = cmi_ch_mode_info,

		.get = cmi_ch_mode_get,

		.put = cmi_ch_mode_put,

	},

	{ } /* end */

};



/* AUD-in selections:

 * 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x1f 0x20

 */

static const struct hda_input_mux cmi9880_basic_mux = {

	.num_items = 4,

	.items = {

		{ "Front Mic", 0x5 },

		{ "Rear Mic", 0x2 },

		{ "Line", 0x1 },

		{ "CD", 0x7 },

	}

};



static const struct hda_input_mux cmi9880_no_line_mux = {

	.num_items = 3,

	.items = {

		{ "Front Mic", 0x5 },

		{ "Rear Mic", 0x2 },

		{ "CD", 0x7 },

	}

};



/* front, rear, clfe, rear_surr */

static const hda_nid_t cmi9880_dac_nids[4] = {

	0x03, 0x04, 0x05, 0x06

};

/* ADC0, ADC1 */

static const hda_nid_t cmi9880_adc_nids[2] = {

	0x08, 0x09

};



#define CMI_DIG_OUT_NID	0x07

#define CMI_DIG_IN_NID	0x0a



/*

 */

static const struct hda_verb cmi9880_basic_init[] = {

	/* port-D for line out (rear panel) */

	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* port-E for HP out (front panel) */

	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* route front PCM to HP */

	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },

	/* port-A for surround (rear panel) */

	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* port-G for CLFE (rear panel) */

	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x02 },

	/* port-H for side (rear panel) */

	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x01 },

	/* port-C for line-in (rear panel) */

	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },

	/* port-B for mic-in (rear panel) with vref */

	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },

	/* port-F for mic-in (front panel) with vref */

	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },

	/* CD-in */

	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },

	/* route front mic to ADC1/2 */

	{ 0x08, AC_VERB_SET_CONNECT_SEL, 0x05 },

	{ 0x09, AC_VERB_SET_CONNECT_SEL, 0x05 },

	{} /* terminator */

};



static const struct hda_verb cmi9880_allout_init[] = {

	/* port-D for line out (rear panel) */

	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* port-E for HP out (front panel) */

	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* route front PCM to HP */

	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },

	/* port-A for side (rear panel) */

	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* port-G for CLFE (rear panel) */

	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x02 },

	/* port-H for side (rear panel) */

	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x01 },

	/* port-C for surround (rear panel) */

	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },

	/* port-B for mic-in (rear panel) with vref */

	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },

	/* port-F for mic-in (front panel) with vref */

	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },

	/* CD-in */

	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },

	/* route front mic to ADC1/2 */

	{ 0x08, AC_VERB_SET_CONNECT_SEL, 0x05 },

	{ 0x09, AC_VERB_SET_CONNECT_SEL, 0x05 },

	{} /* terminator */

};



/*

 */

static int cmi9880_build_controls(struct hda_codec *codec)

{

	struct cmi_spec *spec = codec->spec;

	struct snd_kcontrol *kctl;

	int i, err;



	err = snd_hda_add_new_ctls(codec, cmi9880_basic_mixer);

	if (err < 0)

		return err;

	if (spec->channel_modes) {

		err = snd_hda_add_new_ctls(codec, cmi9880_ch_mode_mixer);

		if (err < 0)

			return err;

	}

	if (spec->multiout.dig_out_nid) {

		err = snd_hda_create_spdif_out_ctls(codec,

						    spec->multiout.dig_out_nid,

						    spec->multiout.dig_out_nid);

		if (err < 0)

			return err;

		err = snd_hda_create_spdif_share_sw(codec,

						    &spec->multiout);

		if (err < 0)

			return err;

		spec->multiout.share_spdif = 1;

	}

	if (spec->dig_in_nid) {

		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);

		if (err < 0)

			return err;

	}



	/* assign Capture Source enums to NID */

	kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");

	for (i = 0; kctl && i < kctl->count; i++) {

		err = snd_hda_add_nid(codec, kctl, i, spec->adc_nids[i]);

		if (err < 0)

			return err;

	}

	return 0;

}



static int cmi9880_init(struct hda_codec *codec)

{

	struct cmi_spec *spec = codec->spec;

	if (spec->board_config == CMI_ALLOUT)

		snd_hda_sequence_write(codec, cmi9880_allout_init);

	else

		snd_hda_sequence_write(codec, cmi9880_basic_init);

	if (spec->board_config == CMI_AUTO)

		snd_hda_sequence_write(codec, spec->multi_init);

	return 0;

}



/*

 * Analog playback callbacks

 */

static int cmi9880_playback_pcm_open(struct hda_pcm_stream *hinfo,

				     struct hda_codec *codec,

				     struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,

					     hinfo);

}



static int cmi9880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,

					struct hda_codec *codec,

					unsigned int stream_tag,

					unsigned int format,

					struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,

						format, substream);

}



static int cmi9880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,

				       struct hda_codec *codec,

				       struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);

}



/*

 * Digital out

 */

static int cmi9880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,

					 struct hda_codec *codec,

					 struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_dig_open(codec, &spec->multiout);

}



static int cmi9880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,

					  struct hda_codec *codec,

					  struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_dig_close(codec, &spec->multiout);

}



static int cmi9880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,

					    struct hda_codec *codec,

					    unsigned int stream_tag,

					    unsigned int format,

					    struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;

	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,

					     format, substream);

}



/*

 * Analog capture

 */

static int cmi9880_capture_pcm_prepare(struct hda_pcm_stream *hinfo,

				      struct hda_codec *codec,

				      unsigned int stream_tag,

				      unsigned int format,

				      struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;



	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],

				   stream_tag, 0, format);

	return 0;

}



static int cmi9880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,

				      struct hda_codec *codec,

				      struct snd_pcm_substream *substream)

{

	struct cmi_spec *spec = codec->spec;



	snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);

	return 0;

}





/*

 */

static const struct hda_pcm_stream cmi9880_pcm_analog_playback = {

	.substreams = 1,

	.channels_min = 2,

	.channels_max = 8,

	.nid = 0x03, /* NID to query formats and rates */

	.ops = {

		.open = cmi9880_playback_pcm_open,

		.prepare = cmi9880_playback_pcm_prepare,

		.cleanup = cmi9880_playback_pcm_cleanup

	},

};



static const struct hda_pcm_stream cmi9880_pcm_analog_capture = {

	.substreams = 2,

	.channels_min = 2,

	.channels_max = 2,

	.nid = 0x08, /* NID to query formats and rates */

	.ops = {

		.prepare = cmi9880_capture_pcm_prepare,

		.cleanup = cmi9880_capture_pcm_cleanup

	},

};



static const struct hda_pcm_stream cmi9880_pcm_digital_playback = {

	.substreams = 1,

	.channels_min = 2,

	.channels_max = 2,

	/* NID is set in cmi9880_build_pcms */

	.ops = {

		.open = cmi9880_dig_playback_pcm_open,

		.close = cmi9880_dig_playback_pcm_close,

		.prepare = cmi9880_dig_playback_pcm_prepare

	},

};



static const struct hda_pcm_stream cmi9880_pcm_digital_capture = {

	.substreams = 1,

	.channels_min = 2,

	.channels_max = 2,

	/* NID is set in cmi9880_build_pcms */

};



static int cmi9880_build_pcms(struct hda_codec *codec)

{

	struct cmi_spec *spec = codec->spec;

	struct hda_pcm *info = spec->pcm_rec;



	codec->num_pcms = 1;

	codec->pcm_info = info;



	info->name = "CMI9880";

	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cmi9880_pcm_analog_playback;

	info->stream[SNDRV_PCM_STREAM_CAPTURE] = cmi9880_pcm_analog_capture;



	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {

		codec->num_pcms++;

		info++;

		info->name = "CMI9880 Digital";

		info->pcm_type = HDA_PCM_TYPE_SPDIF;

		if (spec->multiout.dig_out_nid) {

			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cmi9880_pcm_digital_playback;

			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;

		}

		if (spec->dig_in_nid) {

			info->stream[SNDRV_PCM_STREAM_CAPTURE] = cmi9880_pcm_digital_capture;

			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;

		}

	}



	return 0;

}



static void cmi9880_free(struct hda_codec *codec)

{

	kfree(codec->spec);

}



/*

 */



static const char * const cmi9880_models[CMI_MODELS] = {

	[CMI_MINIMAL]	= "minimal",

	[CMI_MIN_FP]	= "min_fp",

	[CMI_FULL]	= "full",

	[CMI_FULL_DIG]	= "full_dig",

	[CMI_ALLOUT]	= "allout",

	[CMI_AUTO]	= "auto",

};



static const struct snd_pci_quirk cmi9880_cfg_tbl[] = {

	SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", CMI_FULL_DIG),

	SND_PCI_QUIRK(0x1854, 0x002b, "LG LS75", CMI_MINIMAL),

	SND_PCI_QUIRK(0x1854, 0x0032, "LG", CMI_FULL_DIG),

	{} /* terminator */

};



static const struct hda_codec_ops cmi9880_patch_ops = {

	.build_controls = cmi9880_build_controls,

	.build_pcms = cmi9880_build_pcms,

	.init = cmi9880_init,

	.free = cmi9880_free,

};

#endif /* ENABLE_CMI_STATIC_QUIRKS */



/*

 * stuff for auto-parser

 */
@@ -585,12 +46,18 @@ static const struct hda_codec_ops cmi_auto_patch_ops = { 
	.unsol_event = snd_hda_jack_unsol_event,

};



static int cmi_parse_auto_config(struct hda_codec *codec)

static int patch_cmi9880(struct hda_codec *codec)

{

	struct cmi_spec *spec = codec->spec;

	struct auto_pin_cfg *cfg = &spec->gen.autocfg;

	struct cmi_spec *spec;

	struct auto_pin_cfg *cfg;

	int err;



	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

	if (spec == NULL)

		return -ENOMEM;



	codec->spec = spec;

	cfg = &spec->gen.autocfg;

	snd_hda_gen_spec_init(&spec->gen);



	err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0);
@@ -608,79 +75,6 @@ static int cmi_parse_auto_config(struct hda_codec *codec) 
	return err;

}





static int patch_cmi9880(struct hda_codec *codec)

{

	struct cmi_spec *spec;



	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

	if (spec == NULL)

		return -ENOMEM;



	codec->spec = spec;

#ifdef ENABLE_CMI_STATIC_QUIRKS

	spec->board_config = snd_hda_check_board_config(codec, CMI_MODELS,

							cmi9880_models,

							cmi9880_cfg_tbl);

	if (spec->board_config < 0) {

		codec_dbg(codec, "%s: BIOS auto-probing.\n",

			    codec->chip_name);

		spec->board_config = CMI_AUTO; /* try everything */

	}



	if (spec->board_config == CMI_AUTO)

		return cmi_parse_auto_config(codec);



	/* copy default DAC NIDs */

	memcpy(spec->dac_nids, cmi9880_dac_nids, sizeof(spec->dac_nids));

	spec->num_dacs = 4;



	switch (spec->board_config) {

	case CMI_MINIMAL:

	case CMI_MIN_FP:

		spec->channel_modes = cmi9880_channel_modes;

		if (spec->board_config == CMI_MINIMAL)

			spec->num_channel_modes = 2;

		else {

			spec->front_panel = 1;

			spec->num_channel_modes = 3;

		}

		spec->multiout.max_channels = cmi9880_channel_modes[0].channels;

		spec->input_mux = &cmi9880_basic_mux;

		break;

	case CMI_FULL:

	case CMI_FULL_DIG:

		spec->front_panel = 1;

		spec->multiout.max_channels = 8;

		spec->input_mux = &cmi9880_basic_mux;

		if (spec->board_config == CMI_FULL_DIG) {

			spec->multiout.dig_out_nid = CMI_DIG_OUT_NID;

			spec->dig_in_nid = CMI_DIG_IN_NID;

		}

		break;

	case CMI_ALLOUT:

	default:

		spec->front_panel = 1;

		spec->multiout.max_channels = 8;

		spec->no_line_in = 1;

		spec->input_mux = &cmi9880_no_line_mux;

		spec->multiout.dig_out_nid = CMI_DIG_OUT_NID;

		break;

	}



	spec->multiout.num_dacs = spec->num_dacs;

	spec->multiout.dac_nids = spec->dac_nids;



	spec->adc_nids = cmi9880_adc_nids;



	codec->patch_ops = cmi9880_patch_ops;



	return 0;

#else

	return cmi_parse_auto_config(codec);

#endif

}



/*

 * patch entries

 */