2006-11-14 11:13:39 +00:00
|
|
|
/*
|
|
|
|
* HD audio interface patch for Conexant HDA audio codec
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Pototskiy Akex <alex.pototskiy@gmail.com>
|
|
|
|
* Takashi Iwai <tiwai@suse.de>
|
|
|
|
* Tobin Davis <tdavis@dsl-only.net>
|
|
|
|
*
|
|
|
|
* This driver is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This driver is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <sound/core.h>
|
2009-01-02 18:30:13 +00:00
|
|
|
#include <sound/jack.h>
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
#include "hda_codec.h"
|
|
|
|
#include "hda_local.h"
|
|
|
|
|
|
|
|
#define CXT_PIN_DIR_IN 0x00
|
|
|
|
#define CXT_PIN_DIR_OUT 0x01
|
|
|
|
#define CXT_PIN_DIR_INOUT 0x02
|
|
|
|
#define CXT_PIN_DIR_IN_NOMICBIAS 0x03
|
|
|
|
#define CXT_PIN_DIR_INOUT_NOMICBIAS 0x04
|
|
|
|
|
|
|
|
#define CONEXANT_HP_EVENT 0x37
|
|
|
|
#define CONEXANT_MIC_EVENT 0x38
|
|
|
|
|
2009-01-02 18:30:13 +00:00
|
|
|
/* Conexant 5051 specific */
|
|
|
|
|
|
|
|
#define CXT5051_SPDIF_OUT 0x1C
|
|
|
|
#define CXT5051_PORTB_EVENT 0x38
|
|
|
|
#define CXT5051_PORTC_EVENT 0x39
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
|
2009-01-02 18:30:13 +00:00
|
|
|
struct conexant_jack {
|
|
|
|
|
|
|
|
hda_nid_t nid;
|
|
|
|
int type;
|
|
|
|
struct snd_jack *jack;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
struct conexant_spec {
|
|
|
|
|
|
|
|
struct snd_kcontrol_new *mixers[5];
|
|
|
|
int num_mixers;
|
|
|
|
|
|
|
|
const struct hda_verb *init_verbs[5]; /* initialization verbs
|
|
|
|
* don't forget NULL
|
|
|
|
* termination!
|
|
|
|
*/
|
|
|
|
unsigned int num_init_verbs;
|
|
|
|
|
|
|
|
/* playback */
|
|
|
|
struct hda_multi_out multiout; /* playback set-up
|
|
|
|
* max_channels, dacs must be set
|
|
|
|
* dig_out_nid and hp_nid are optional
|
|
|
|
*/
|
|
|
|
unsigned int cur_eapd;
|
2007-02-13 11:45:44 +00:00
|
|
|
unsigned int hp_present;
|
2006-11-14 11:13:39 +00:00
|
|
|
unsigned int need_dac_fix;
|
|
|
|
|
|
|
|
/* capture */
|
|
|
|
unsigned int num_adc_nids;
|
|
|
|
hda_nid_t *adc_nids;
|
|
|
|
hda_nid_t dig_in_nid; /* digital-in NID; optional */
|
|
|
|
|
2008-01-25 10:35:17 +00:00
|
|
|
unsigned int cur_adc_idx;
|
|
|
|
hda_nid_t cur_adc;
|
|
|
|
unsigned int cur_adc_stream_tag;
|
|
|
|
unsigned int cur_adc_format;
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* capture source */
|
|
|
|
const struct hda_input_mux *input_mux;
|
|
|
|
hda_nid_t *capsrc_nids;
|
|
|
|
unsigned int cur_mux[3];
|
|
|
|
|
|
|
|
/* channel model */
|
|
|
|
const struct hda_channel_mode *channel_mode;
|
|
|
|
int num_channel_mode;
|
|
|
|
|
|
|
|
/* PCM information */
|
|
|
|
struct hda_pcm pcm_rec[2]; /* used in build_pcms() */
|
|
|
|
|
|
|
|
unsigned int spdif_route;
|
|
|
|
|
2009-01-02 18:30:13 +00:00
|
|
|
/* jack detection */
|
|
|
|
struct snd_array jacks;
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* dynamic controls, init_verbs and input_mux */
|
|
|
|
struct auto_pin_cfg autocfg;
|
|
|
|
struct hda_input_mux private_imux;
|
2007-10-22 15:20:10 +00:00
|
|
|
hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
2008-02-12 17:37:26 +00:00
|
|
|
return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
|
|
|
|
hinfo);
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_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 conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
|
|
|
|
stream_tag,
|
|
|
|
format, substream);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Digital out
|
|
|
|
*/
|
|
|
|
static int conexant_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_dig_open(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_dig_close(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
2007-04-05 12:51:48 +00:00
|
|
|
static int conexant_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 conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
|
|
|
|
stream_tag,
|
|
|
|
format, substream);
|
|
|
|
}
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/*
|
|
|
|
* Analog capture
|
|
|
|
*/
|
|
|
|
static int conexant_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 conexant_spec *spec = codec->spec;
|
|
|
|
snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
|
|
|
|
stream_tag, 0, format);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
2008-03-18 08:57:50 +00:00
|
|
|
snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
|
2006-11-14 11:13:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct hda_pcm_stream conexant_pcm_analog_playback = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.nid = 0, /* fill later */
|
|
|
|
.ops = {
|
|
|
|
.open = conexant_playback_pcm_open,
|
|
|
|
.prepare = conexant_playback_pcm_prepare,
|
|
|
|
.cleanup = conexant_playback_pcm_cleanup
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_pcm_stream conexant_pcm_analog_capture = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.nid = 0, /* fill later */
|
|
|
|
.ops = {
|
|
|
|
.prepare = conexant_capture_pcm_prepare,
|
|
|
|
.cleanup = conexant_capture_pcm_cleanup
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static struct hda_pcm_stream conexant_pcm_digital_playback = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.nid = 0, /* fill later */
|
|
|
|
.ops = {
|
|
|
|
.open = conexant_dig_playback_pcm_open,
|
2007-04-05 12:51:48 +00:00
|
|
|
.close = conexant_dig_playback_pcm_close,
|
|
|
|
.prepare = conexant_dig_playback_pcm_prepare
|
2006-11-14 11:13:39 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_pcm_stream conexant_pcm_digital_capture = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
/* NID is set in alc_build_pcms */
|
|
|
|
};
|
|
|
|
|
2008-01-25 10:35:17 +00:00
|
|
|
static int cx5051_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 conexant_spec *spec = codec->spec;
|
|
|
|
spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
|
|
|
|
spec->cur_adc_stream_tag = stream_tag;
|
|
|
|
spec->cur_adc_format = format;
|
|
|
|
snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cx5051_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
2008-03-18 08:57:50 +00:00
|
|
|
snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
|
2008-01-25 10:35:17 +00:00
|
|
|
spec->cur_adc = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hda_pcm_stream cx5051_pcm_analog_capture = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.nid = 0, /* fill later */
|
|
|
|
.ops = {
|
|
|
|
.prepare = cx5051_capture_pcm_prepare,
|
|
|
|
.cleanup = cx5051_capture_pcm_cleanup
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
static int conexant_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
struct hda_pcm *info = spec->pcm_rec;
|
|
|
|
|
|
|
|
codec->num_pcms = 1;
|
|
|
|
codec->pcm_info = info;
|
|
|
|
|
|
|
|
info->name = "CONEXANT Analog";
|
|
|
|
info->stream[SNDRV_PCM_STREAM_PLAYBACK] = conexant_pcm_analog_playback;
|
|
|
|
info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
|
|
|
|
spec->multiout.max_channels;
|
|
|
|
info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
|
|
|
|
spec->multiout.dac_nids[0];
|
2008-01-25 10:35:17 +00:00
|
|
|
if (codec->vendor_id == 0x14f15051)
|
|
|
|
info->stream[SNDRV_PCM_STREAM_CAPTURE] =
|
|
|
|
cx5051_pcm_analog_capture;
|
|
|
|
else
|
|
|
|
info->stream[SNDRV_PCM_STREAM_CAPTURE] =
|
|
|
|
conexant_pcm_analog_capture;
|
2006-11-14 11:13:39 +00:00
|
|
|
info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
|
|
|
|
info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
|
|
|
|
|
|
|
|
if (spec->multiout.dig_out_nid) {
|
|
|
|
info++;
|
|
|
|
codec->num_pcms++;
|
|
|
|
info->name = "Conexant Digital";
|
[ALSA] hda-intel - Fix PCM device number assignment
In the current scheme, PCM device numbers are assigned incrementally
in the order of codecs. This causes problems when the codec number
is irregular, e.g. codec #0 for HDMI and codec #1 for analog. Then
the HDMI becomes the first PCM, which is picked up as the default
output device. Unfortuantely this doesn't work well with normal
setups.
This patch introduced the fixed device numbers for the PCM types,
namely, analog, SPDIF, HDMI and modem. The PCM devices are assigned
according to the corresponding PCM type. After this patch, HDMI will
be always assigned to PCM #3, SPDIF to PCM #1, and the first analog
to PCM #0, etc.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2008-02-06 13:03:20 +00:00
|
|
|
info->pcm_type = HDA_PCM_TYPE_SPDIF;
|
2006-11-14 11:13:39 +00:00
|
|
|
info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
|
|
|
|
conexant_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] =
|
|
|
|
conexant_pcm_digital_capture;
|
|
|
|
info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
|
|
|
|
spec->dig_in_nid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_mux_enum_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
|
|
|
|
return snd_hda_input_mux_info(spec->input_mux, uinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_mux_enum_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_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 conexant_mux_enum_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_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->capsrc_nids[adc_idx],
|
|
|
|
&spec->cur_mux[adc_idx]);
|
|
|
|
}
|
|
|
|
|
2009-01-02 18:30:13 +00:00
|
|
|
static int conexant_add_jack(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid, int type)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec;
|
|
|
|
struct conexant_jack *jack;
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
spec = codec->spec;
|
|
|
|
snd_array_init(&spec->jacks, sizeof(*jack), 32);
|
|
|
|
jack = snd_array_new(&spec->jacks);
|
|
|
|
name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
|
|
|
|
|
|
|
|
if (!jack)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
jack->nid = nid;
|
|
|
|
jack->type = type;
|
|
|
|
|
|
|
|
return snd_jack_new(codec->bus->card, name, type, &jack->jack);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
struct conexant_jack *jacks = spec->jacks.list;
|
|
|
|
|
|
|
|
if (jacks) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < spec->jacks.used; i++) {
|
|
|
|
if (jacks->nid == nid) {
|
|
|
|
unsigned int present;
|
|
|
|
present = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) &
|
|
|
|
AC_PINSENSE_PRESENCE;
|
|
|
|
|
|
|
|
present = (present) ? jacks->type : 0 ;
|
|
|
|
|
|
|
|
snd_jack_report(jacks->jack,
|
|
|
|
present);
|
|
|
|
}
|
|
|
|
jacks++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_init_jacks(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SND_JACK
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < spec->num_init_verbs; i++) {
|
|
|
|
const struct hda_verb *hv;
|
|
|
|
|
|
|
|
hv = spec->init_verbs[i];
|
|
|
|
while (hv->nid) {
|
|
|
|
int err = 0;
|
|
|
|
switch (hv->param ^ AC_USRSP_EN) {
|
|
|
|
case CONEXANT_HP_EVENT:
|
|
|
|
err = conexant_add_jack(codec, hv->nid,
|
|
|
|
SND_JACK_HEADPHONE);
|
|
|
|
conexant_report_jack(codec, hv->nid);
|
|
|
|
break;
|
|
|
|
case CXT5051_PORTC_EVENT:
|
|
|
|
case CONEXANT_MIC_EVENT:
|
|
|
|
err = conexant_add_jack(codec, hv->nid,
|
|
|
|
SND_JACK_MICROPHONE);
|
|
|
|
conexant_report_jack(codec, hv->nid);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
++hv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
static int conexant_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < spec->num_init_verbs; i++)
|
|
|
|
snd_hda_sequence_write(codec, spec->init_verbs[i]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void conexant_free(struct hda_codec *codec)
|
|
|
|
{
|
2009-01-02 18:30:13 +00:00
|
|
|
#ifdef CONFIG_SND_JACK
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
if (spec->jacks.list) {
|
|
|
|
struct conexant_jack *jacks = spec->jacks.list;
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < spec->jacks.used; i++)
|
|
|
|
snd_device_free(codec->bus->card, &jacks[i].jack);
|
|
|
|
snd_array_free(&spec->jacks);
|
|
|
|
}
|
|
|
|
#endif
|
2006-11-14 11:13:39 +00:00
|
|
|
kfree(codec->spec);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_build_controls(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
unsigned int i;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
for (i = 0; i < spec->num_mixers; i++) {
|
|
|
|
err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
if (spec->multiout.dig_out_nid) {
|
|
|
|
err = snd_hda_create_spdif_out_ctls(codec,
|
|
|
|
spec->multiout.dig_out_nid);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2008-02-12 17:37:26 +00:00
|
|
|
err = snd_hda_create_spdif_share_sw(codec,
|
|
|
|
&spec->multiout);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
spec->multiout.share_spdif = 1;
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
if (spec->dig_in_nid) {
|
|
|
|
err = snd_hda_create_spdif_in_ctls(codec,spec->dig_in_nid);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hda_codec_ops conexant_patch_ops = {
|
|
|
|
.build_controls = conexant_build_controls,
|
|
|
|
.build_pcms = conexant_build_pcms,
|
|
|
|
.init = conexant_init,
|
|
|
|
.free = conexant_free,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EAPD control
|
|
|
|
* the private value = nid | (invert << 8)
|
|
|
|
*/
|
|
|
|
|
2007-07-23 13:42:26 +00:00
|
|
|
#define cxt_eapd_info snd_ctl_boolean_mono_info
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
static int cxt_eapd_get(struct snd_kcontrol *kcontrol,
|
2006-11-14 11:13:39 +00:00
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
int invert = (kcontrol->private_value >> 8) & 1;
|
|
|
|
if (invert)
|
|
|
|
ucontrol->value.integer.value[0] = !spec->cur_eapd;
|
|
|
|
else
|
|
|
|
ucontrol->value.integer.value[0] = spec->cur_eapd;
|
|
|
|
return 0;
|
2007-02-13 11:45:44 +00:00
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
static int cxt_eapd_put(struct snd_kcontrol *kcontrol,
|
2006-11-14 11:13:39 +00:00
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
int invert = (kcontrol->private_value >> 8) & 1;
|
|
|
|
hda_nid_t nid = kcontrol->private_value & 0xff;
|
|
|
|
unsigned int eapd;
|
2007-02-13 11:45:44 +00:00
|
|
|
|
2007-11-15 14:54:38 +00:00
|
|
|
eapd = !!ucontrol->value.integer.value[0];
|
2006-11-14 11:13:39 +00:00
|
|
|
if (invert)
|
|
|
|
eapd = !eapd;
|
2007-08-10 15:09:26 +00:00
|
|
|
if (eapd == spec->cur_eapd)
|
2006-11-14 11:13:39 +00:00
|
|
|
return 0;
|
2007-02-13 11:45:44 +00:00
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
spec->cur_eapd = eapd;
|
2007-08-10 15:09:26 +00:00
|
|
|
snd_hda_codec_write_cache(codec, nid,
|
|
|
|
0, AC_VERB_SET_EAPD_BTLENABLE,
|
|
|
|
eapd ? 0x02 : 0x00);
|
2006-11-14 11:13:39 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-11-28 10:33:10 +00:00
|
|
|
/* controls for test mode */
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
#define CXT_EAPD_SWITCH(xname, nid, mask) \
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
|
|
.info = cxt_eapd_info, \
|
|
|
|
.get = cxt_eapd_get, \
|
|
|
|
.put = cxt_eapd_put, \
|
|
|
|
.private_value = nid | (mask<<16) }
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
static int conexant_ch_mode_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
|
|
|
|
spec->num_channel_mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_ch_mode_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
|
|
|
|
spec->num_channel_mode,
|
|
|
|
spec->multiout.max_channels);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int conexant_ch_mode_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
|
|
|
|
spec->num_channel_mode,
|
|
|
|
&spec->multiout.max_channels);
|
|
|
|
if (err >= 0 && spec->need_dac_fix)
|
|
|
|
spec->multiout.num_dacs = spec->multiout.max_channels / 2;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define CXT_PIN_MODE(xname, nid, dir) \
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
|
|
.info = conexant_ch_mode_info, \
|
|
|
|
.get = conexant_ch_mode_get, \
|
|
|
|
.put = conexant_ch_mode_put, \
|
|
|
|
.private_value = nid | (dir<<16) }
|
|
|
|
|
2006-11-28 10:33:10 +00:00
|
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* Conexant 5045 specific */
|
|
|
|
|
|
|
|
static hda_nid_t cxt5045_dac_nids[1] = { 0x19 };
|
|
|
|
static hda_nid_t cxt5045_adc_nids[1] = { 0x1a };
|
|
|
|
static hda_nid_t cxt5045_capsrc_nids[1] = { 0x1a };
|
2008-02-22 17:36:46 +00:00
|
|
|
#define CXT5045_SPDIF_OUT 0x18
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2006-11-20 16:42:09 +00:00
|
|
|
static struct hda_channel_mode cxt5045_modes[1] = {
|
|
|
|
{ 2, NULL },
|
|
|
|
};
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
static struct hda_input_mux cxt5045_capture_source = {
|
|
|
|
.num_items = 2,
|
|
|
|
.items = {
|
2007-02-13 11:45:44 +00:00
|
|
|
{ "IntMic", 0x1 },
|
[ALSA] hda-codec - Fix capture source for Cx5045 codec
For codec conexant 5045, I found that the name of 'Capture Source Items'
is different from the name of mixer.
The mixer is:
HDA_CODEC_VOLUME('Ext Mic Playback Volume', 0x17, 0x2, HDA_INPUT),
HDA_CODEC_MUTE('Ext Mic Playback Switch', 0x17, 0x2, HDA_INPUT),
But the capture source item is :
static struct hda_input_mux cxt5045_capture_source = {
.num_items = 2,
.items = {
{ 'IntMic', 0x1 },
{ 'LineIn', 0x2 },
}
};
I think that it's better to change the name of capture_source to avoid
misunderstanding.
Signed-off-by: Jiang zhe <zhe.jiang@intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2008-01-17 10:19:26 +00:00
|
|
|
{ "ExtMic", 0x2 },
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-01-17 10:18:41 +00:00
|
|
|
static struct hda_input_mux cxt5045_capture_source_benq = {
|
|
|
|
.num_items = 3,
|
|
|
|
.items = {
|
|
|
|
{ "IntMic", 0x1 },
|
|
|
|
{ "ExtMic", 0x2 },
|
|
|
|
{ "LineIn", 0x3 },
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-03-06 10:09:09 +00:00
|
|
|
static struct hda_input_mux cxt5045_capture_source_hp530 = {
|
|
|
|
.num_items = 2,
|
|
|
|
.items = {
|
|
|
|
{ "ExtMic", 0x1 },
|
|
|
|
{ "IntMic", 0x2 },
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* turn on/off EAPD (+ mute HP) as a master switch */
|
|
|
|
static int cxt5045_hp_master_sw_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
2007-02-13 11:45:44 +00:00
|
|
|
unsigned int bits;
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
if (!cxt_eapd_put(kcontrol, ucontrol))
|
2006-11-14 11:13:39 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* toggle internal speakers mute depending of presence of
|
|
|
|
* the headphone jack
|
|
|
|
*/
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2007-03-12 10:39:01 +00:00
|
|
|
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x11, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2006-11-14 11:13:39 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bind volumes of both NID 0x10 and 0x11 */
|
2007-08-10 15:12:15 +00:00
|
|
|
static struct hda_bind_ctls cxt5045_hp_bind_master_vol = {
|
|
|
|
.ops = &snd_hda_bind_vol,
|
|
|
|
.values = {
|
|
|
|
HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT),
|
|
|
|
HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
|
|
|
|
0
|
|
|
|
},
|
|
|
|
};
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-03-12 10:39:01 +00:00
|
|
|
/* toggle input of built-in and mic jack appropriately */
|
|
|
|
static void cxt5045_hp_automic(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
static struct hda_verb mic_jack_on[] = {
|
|
|
|
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
|
|
|
|
{0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
static struct hda_verb mic_jack_off[] = {
|
|
|
|
{0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
|
|
|
|
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
unsigned int present;
|
|
|
|
|
|
|
|
present = snd_hda_codec_read(codec, 0x12, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
|
|
|
|
if (present)
|
|
|
|
snd_hda_sequence_write(codec, mic_jack_on);
|
|
|
|
else
|
|
|
|
snd_hda_sequence_write(codec, mic_jack_off);
|
|
|
|
}
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* mute internal speaker if HP is plugged */
|
|
|
|
static void cxt5045_hp_automute(struct hda_codec *codec)
|
|
|
|
{
|
2007-02-13 11:45:44 +00:00
|
|
|
struct conexant_spec *spec = codec->spec;
|
2007-02-26 15:07:42 +00:00
|
|
|
unsigned int bits;
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
spec->hp_present = snd_hda_codec_read(codec, 0x11, 0,
|
2006-11-14 11:13:39 +00:00
|
|
|
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
|
2007-02-26 15:07:42 +00:00
|
|
|
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* unsolicited event for HP jack sensing */
|
|
|
|
static void cxt5045_hp_unsol_event(struct hda_codec *codec,
|
|
|
|
unsigned int res)
|
|
|
|
{
|
|
|
|
res >>= 26;
|
|
|
|
switch (res) {
|
|
|
|
case CONEXANT_HP_EVENT:
|
|
|
|
cxt5045_hp_automute(codec);
|
|
|
|
break;
|
2007-03-12 10:39:01 +00:00
|
|
|
case CONEXANT_MIC_EVENT:
|
|
|
|
cxt5045_hp_automic(codec);
|
|
|
|
break;
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5045_mixers[] = {
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put
|
|
|
|
},
|
2007-10-19 06:06:21 +00:00
|
|
|
HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Ext Mic Capture Switch", 0x1a, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Int Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
|
2007-08-10 15:12:15 +00:00
|
|
|
HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
|
2006-11-14 11:13:39 +00:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
2007-02-13 11:45:44 +00:00
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
2006-11-14 11:13:39 +00:00
|
|
|
.put = cxt5045_hp_master_sw_put,
|
2007-02-13 11:45:44 +00:00
|
|
|
.private_value = 0x10,
|
2006-11-14 11:13:39 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2008-01-17 10:18:41 +00:00
|
|
|
static struct snd_kcontrol_new cxt5045_benq_mixers[] = {
|
|
|
|
HDA_CODEC_VOLUME("Line In Capture Volume", 0x1a, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Line In Capture Switch", 0x1a, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Line In Playback Volume", 0x17, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Line In Playback Switch", 0x17, 0x3, HDA_INPUT),
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2008-03-06 10:09:09 +00:00
|
|
|
static struct snd_kcontrol_new cxt5045_mixers_hp530[] = {
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put
|
|
|
|
},
|
|
|
|
HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Ext Mic Capture Switch", 0x1a, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Int Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
|
|
|
.put = cxt5045_hp_master_sw_put,
|
|
|
|
.private_value = 0x10,
|
|
|
|
},
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
static struct hda_verb cxt5045_init_verbs[] = {
|
|
|
|
/* Line in, Mic */
|
2008-07-12 10:02:45 +00:00
|
|
|
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
|
2007-03-12 10:39:01 +00:00
|
|
|
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
|
2006-11-14 11:13:39 +00:00
|
|
|
/* HP, Amp */
|
2007-10-19 06:06:21 +00:00
|
|
|
{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
|
|
|
|
{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
|
|
|
{0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Record selector: Int mic */
|
2007-03-12 10:39:01 +00:00
|
|
|
{0x1a, AC_VERB_SET_CONNECT_SEL,0x1},
|
2007-02-13 11:45:44 +00:00
|
|
|
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
|
2006-11-14 11:13:39 +00:00
|
|
|
AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
|
|
|
|
/* SPDIF route: PCM */
|
2008-02-22 17:36:46 +00:00
|
|
|
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
2006-11-14 11:13:39 +00:00
|
|
|
{ 0x13, AC_VERB_SET_CONNECT_SEL, 0x0 },
|
|
|
|
/* EAPD */
|
2007-02-13 11:45:44 +00:00
|
|
|
{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2 }, /* default on */
|
2006-11-14 11:13:39 +00:00
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
2008-01-17 10:18:41 +00:00
|
|
|
static struct hda_verb cxt5045_benq_init_verbs[] = {
|
|
|
|
/* Int Mic, Mic */
|
|
|
|
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
|
|
|
|
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
|
|
|
|
/* Line In,HP, Amp */
|
|
|
|
{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
|
|
|
|
{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
|
|
|
{0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
|
|
|
|
/* Record selector: Int mic */
|
|
|
|
{0x1a, AC_VERB_SET_CONNECT_SEL, 0x1},
|
|
|
|
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
|
|
|
|
/* SPDIF route: PCM */
|
2008-02-22 17:36:46 +00:00
|
|
|
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
2008-01-17 10:18:41 +00:00
|
|
|
{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
|
|
|
|
/* EAPD */
|
|
|
|
{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
|
|
|
|
{ } /* end */
|
|
|
|
};
|
2007-03-12 10:39:01 +00:00
|
|
|
|
|
|
|
static struct hda_verb cxt5045_hp_sense_init_verbs[] = {
|
|
|
|
/* pin sensing on HP jack */
|
|
|
|
{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
|
2007-03-28 13:11:53 +00:00
|
|
|
{ } /* end */
|
2007-03-12 10:39:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_verb cxt5045_mic_sense_init_verbs[] = {
|
|
|
|
/* pin sensing on HP jack */
|
|
|
|
{0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
|
2007-03-28 13:11:53 +00:00
|
|
|
{ } /* end */
|
2007-03-12 10:39:01 +00:00
|
|
|
};
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
/* Test configuration for debugging, modelled after the ALC260 test
|
|
|
|
* configuration.
|
|
|
|
*/
|
|
|
|
static struct hda_input_mux cxt5045_test_capture_source = {
|
|
|
|
.num_items = 5,
|
|
|
|
.items = {
|
|
|
|
{ "MIXER", 0x0 },
|
|
|
|
{ "MIC1 pin", 0x1 },
|
|
|
|
{ "LINE1 pin", 0x2 },
|
|
|
|
{ "HP-OUT pin", 0x3 },
|
|
|
|
{ "CD pin", 0x4 },
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5045_test_mixer[] = {
|
|
|
|
|
|
|
|
/* Output controls */
|
|
|
|
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x10, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Speaker Playback Switch", 0x10, 0x0, HDA_OUTPUT),
|
2007-03-12 10:39:01 +00:00
|
|
|
HDA_CODEC_VOLUME("Node 11 Playback Volume", 0x11, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Node 11 Playback Switch", 0x11, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("Node 12 Playback Volume", 0x12, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Node 12 Playback Switch", 0x12, 0x0, HDA_OUTPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* Modes for retasking pin widgets */
|
|
|
|
CXT_PIN_MODE("HP-OUT pin mode", 0x11, CXT_PIN_DIR_INOUT),
|
|
|
|
CXT_PIN_MODE("LINE1 pin mode", 0x12, CXT_PIN_DIR_INOUT),
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* EAPD Switch Control */
|
|
|
|
CXT_EAPD_SWITCH("External Amplifier", 0x10, 0x0),
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* Loopback mixer controls */
|
2007-03-12 10:39:01 +00:00
|
|
|
|
|
|
|
HDA_CODEC_VOLUME("Mixer-1 Volume", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mixer-1 Switch", 0x17, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Mixer-2 Volume", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mixer-2 Switch", 0x17, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Mixer-3 Volume", 0x17, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mixer-3 Switch", 0x17, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Mixer-4 Volume", 0x17, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mixer-4 Switch", 0x17, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Mixer-5 Volume", 0x17, 0x4, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mixer-5 Switch", 0x17, 0x4, HDA_INPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Input Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put,
|
|
|
|
},
|
2007-05-17 07:40:47 +00:00
|
|
|
/* Audio input controls */
|
|
|
|
HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_verb cxt5045_test_init_verbs[] = {
|
2007-03-12 10:39:01 +00:00
|
|
|
/* Set connections */
|
|
|
|
{ 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
|
|
|
|
{ 0x11, AC_VERB_SET_CONNECT_SEL, 0x0 },
|
|
|
|
{ 0x12, AC_VERB_SET_CONNECT_SEL, 0x0 },
|
2006-11-14 11:13:39 +00:00
|
|
|
/* Enable retasking pins as output, initially without power amp */
|
|
|
|
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
2007-03-12 10:39:01 +00:00
|
|
|
{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* Disable digital (SPDIF) pins initially, but users can enable
|
|
|
|
* them via a mixer switch. In the case of SPDIF-out, this initverb
|
|
|
|
* payload also sets the generation to 0, output to be in "consumer"
|
|
|
|
* PCM format, copyright asserted, no pre-emphasis and no validity
|
|
|
|
* control.
|
|
|
|
*/
|
2008-02-22 17:36:46 +00:00
|
|
|
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* Start with output sum widgets muted and their output gains at min */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
|
|
|
|
|
|
|
/* Unmute retasking pin widget output buffers since the default
|
|
|
|
* state appears to be output. As the pin mode is changed by the
|
|
|
|
* user the pin mode control will take care of enabling the pin's
|
|
|
|
* input/output buffers as needed.
|
|
|
|
*/
|
|
|
|
{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
|
|
|
|
/* Mute capture amp left and right */
|
|
|
|
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
|
|
|
|
/* Set ADC connection select to match default mixer setting (mic1
|
|
|
|
* pin)
|
|
|
|
*/
|
|
|
|
{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
|
2007-03-12 10:39:01 +00:00
|
|
|
{0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* Mute all inputs to mixer widget (even unconnected ones) */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* Mixer pin */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* Mic1 pin */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* Line pin */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* HP pin */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
|
|
|
|
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* initialize jack-sensing, too */
|
|
|
|
static int cxt5045_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
conexant_init(codec);
|
|
|
|
cxt5045_hp_automute(codec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
enum {
|
2008-01-22 14:15:59 +00:00
|
|
|
CXT5045_LAPTOP_HPSENSE,
|
|
|
|
CXT5045_LAPTOP_MICSENSE,
|
|
|
|
CXT5045_LAPTOP_HPMICSENSE,
|
2008-01-17 10:18:41 +00:00
|
|
|
CXT5045_BENQ,
|
2008-03-06 10:09:09 +00:00
|
|
|
CXT5045_LAPTOP_HP530,
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
CXT5045_TEST,
|
|
|
|
#endif
|
2006-11-24 16:07:44 +00:00
|
|
|
CXT5045_MODELS
|
2006-11-14 11:13:39 +00:00
|
|
|
};
|
|
|
|
|
2006-11-24 16:07:44 +00:00
|
|
|
static const char *cxt5045_models[CXT5045_MODELS] = {
|
2008-01-22 14:15:59 +00:00
|
|
|
[CXT5045_LAPTOP_HPSENSE] = "laptop-hpsense",
|
|
|
|
[CXT5045_LAPTOP_MICSENSE] = "laptop-micsense",
|
|
|
|
[CXT5045_LAPTOP_HPMICSENSE] = "laptop-hpmicsense",
|
|
|
|
[CXT5045_BENQ] = "benq",
|
2008-03-06 10:09:09 +00:00
|
|
|
[CXT5045_LAPTOP_HP530] = "laptop-hp530",
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
2006-11-24 16:07:44 +00:00
|
|
|
[CXT5045_TEST] = "test",
|
2006-11-14 11:13:39 +00:00
|
|
|
#endif
|
2006-11-24 16:07:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_pci_quirk cxt5045_cfg_tbl[] = {
|
2008-01-22 14:15:59 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30a5, "HP", CXT5045_LAPTOP_HPSENSE),
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30b2, "HP DV Series", CXT5045_LAPTOP_HPSENSE),
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30b5, "HP DV2120", CXT5045_LAPTOP_HPSENSE),
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30b7, "HP DV6000Z", CXT5045_LAPTOP_HPSENSE),
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30bb, "HP DV8000", CXT5045_LAPTOP_HPSENSE),
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30cd, "HP DV Series", CXT5045_LAPTOP_HPSENSE),
|
2008-01-29 12:26:04 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV9533EG", CXT5045_LAPTOP_HPSENSE),
|
2008-03-06 10:09:09 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT5045_LAPTOP_HP530),
|
2008-01-22 14:15:59 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30d9, "HP Spartan", CXT5045_LAPTOP_HPSENSE),
|
2008-07-01 12:52:05 +00:00
|
|
|
SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT5045_LAPTOP_MICSENSE),
|
2008-01-17 10:18:41 +00:00
|
|
|
SND_PCI_QUIRK(0x152d, 0x0753, "Benq R55E", CXT5045_BENQ),
|
2008-01-22 14:15:59 +00:00
|
|
|
SND_PCI_QUIRK(0x1734, 0x10ad, "Fujitsu Si1520", CXT5045_LAPTOP_MICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x1734, 0x10cb, "Fujitsu Si3515", CXT5045_LAPTOP_HPMICSENSE),
|
2008-07-12 10:05:25 +00:00
|
|
|
SND_PCI_QUIRK(0x1734, 0x110e, "Fujitsu V5505",
|
|
|
|
CXT5045_LAPTOP_HPMICSENSE),
|
2008-01-22 14:15:59 +00:00
|
|
|
SND_PCI_QUIRK(0x1509, 0x1e40, "FIC", CXT5045_LAPTOP_HPMICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x1509, 0x2f05, "FIC", CXT5045_LAPTOP_HPMICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x1509, 0x2f06, "FIC", CXT5045_LAPTOP_HPMICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x1631, 0xc106, "Packard Bell", CXT5045_LAPTOP_HPMICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x1631, 0xc107, "Packard Bell", CXT5045_LAPTOP_HPMICSENSE),
|
|
|
|
SND_PCI_QUIRK(0x8086, 0x2111, "Conexant Reference board", CXT5045_LAPTOP_HPSENSE),
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int patch_cxt5045(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec;
|
|
|
|
int board_config;
|
|
|
|
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
|
|
if (!spec)
|
|
|
|
return -ENOMEM;
|
|
|
|
codec->spec = spec;
|
|
|
|
|
|
|
|
spec->multiout.max_channels = 2;
|
|
|
|
spec->multiout.num_dacs = ARRAY_SIZE(cxt5045_dac_nids);
|
|
|
|
spec->multiout.dac_nids = cxt5045_dac_nids;
|
|
|
|
spec->multiout.dig_out_nid = CXT5045_SPDIF_OUT;
|
|
|
|
spec->num_adc_nids = 1;
|
|
|
|
spec->adc_nids = cxt5045_adc_nids;
|
|
|
|
spec->capsrc_nids = cxt5045_capsrc_nids;
|
|
|
|
spec->input_mux = &cxt5045_capture_source;
|
|
|
|
spec->num_mixers = 1;
|
|
|
|
spec->mixers[0] = cxt5045_mixers;
|
|
|
|
spec->num_init_verbs = 1;
|
|
|
|
spec->init_verbs[0] = cxt5045_init_verbs;
|
|
|
|
spec->spdif_route = 0;
|
2006-11-20 16:42:09 +00:00
|
|
|
spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes),
|
|
|
|
spec->channel_mode = cxt5045_modes,
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
codec->patch_ops = conexant_patch_ops;
|
|
|
|
|
2006-11-24 16:07:44 +00:00
|
|
|
board_config = snd_hda_check_board_config(codec, CXT5045_MODELS,
|
|
|
|
cxt5045_models,
|
|
|
|
cxt5045_cfg_tbl);
|
2006-11-14 11:13:39 +00:00
|
|
|
switch (board_config) {
|
2008-01-22 14:15:59 +00:00
|
|
|
case CXT5045_LAPTOP_HPSENSE:
|
2007-03-12 10:39:01 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
|
|
|
|
spec->input_mux = &cxt5045_capture_source;
|
|
|
|
spec->num_init_verbs = 2;
|
|
|
|
spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
|
|
|
|
spec->mixers[0] = cxt5045_mixers;
|
|
|
|
codec->patch_ops.init = cxt5045_init;
|
|
|
|
break;
|
2008-01-22 14:15:59 +00:00
|
|
|
case CXT5045_LAPTOP_MICSENSE:
|
2008-07-12 10:04:05 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
|
2006-11-14 11:13:39 +00:00
|
|
|
spec->input_mux = &cxt5045_capture_source;
|
|
|
|
spec->num_init_verbs = 2;
|
2007-03-12 10:39:01 +00:00
|
|
|
spec->init_verbs[1] = cxt5045_mic_sense_init_verbs;
|
2006-11-14 11:13:39 +00:00
|
|
|
spec->mixers[0] = cxt5045_mixers;
|
|
|
|
codec->patch_ops.init = cxt5045_init;
|
|
|
|
break;
|
2008-01-22 14:15:59 +00:00
|
|
|
default:
|
|
|
|
case CXT5045_LAPTOP_HPMICSENSE:
|
|
|
|
codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
|
|
|
|
spec->input_mux = &cxt5045_capture_source;
|
|
|
|
spec->num_init_verbs = 3;
|
|
|
|
spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
|
|
|
|
spec->init_verbs[2] = cxt5045_mic_sense_init_verbs;
|
|
|
|
spec->mixers[0] = cxt5045_mixers;
|
|
|
|
codec->patch_ops.init = cxt5045_init;
|
|
|
|
break;
|
2008-01-17 10:18:41 +00:00
|
|
|
case CXT5045_BENQ:
|
|
|
|
codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
|
|
|
|
spec->input_mux = &cxt5045_capture_source_benq;
|
|
|
|
spec->num_init_verbs = 1;
|
|
|
|
spec->init_verbs[0] = cxt5045_benq_init_verbs;
|
|
|
|
spec->mixers[0] = cxt5045_mixers;
|
|
|
|
spec->mixers[1] = cxt5045_benq_mixers;
|
|
|
|
spec->num_mixers = 2;
|
|
|
|
codec->patch_ops.init = cxt5045_init;
|
|
|
|
break;
|
2008-03-06 10:09:09 +00:00
|
|
|
case CXT5045_LAPTOP_HP530:
|
|
|
|
codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
|
|
|
|
spec->input_mux = &cxt5045_capture_source_hp530;
|
|
|
|
spec->num_init_verbs = 2;
|
|
|
|
spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
|
|
|
|
spec->mixers[0] = cxt5045_mixers_hp530;
|
|
|
|
codec->patch_ops.init = cxt5045_init;
|
|
|
|
break;
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
case CXT5045_TEST:
|
|
|
|
spec->input_mux = &cxt5045_test_capture_source;
|
|
|
|
spec->mixers[0] = cxt5045_test_mixer;
|
|
|
|
spec->init_verbs[0] = cxt5045_test_init_verbs;
|
2008-01-22 14:15:59 +00:00
|
|
|
break;
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
#endif
|
|
|
|
}
|
2007-12-17 13:32:49 +00:00
|
|
|
|
2008-06-26 12:49:58 +00:00
|
|
|
switch (codec->subsystem_id >> 16) {
|
|
|
|
case 0x103c:
|
|
|
|
/* HP laptop has a really bad sound over 0dB on NID 0x17.
|
|
|
|
* Fix max PCM level to 0 dB
|
|
|
|
* (originall it has 0x2b steps with 0dB offset 0x14)
|
|
|
|
*/
|
|
|
|
snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT,
|
|
|
|
(0x14 << AC_AMPCAP_OFFSET_SHIFT) |
|
|
|
|
(0x14 << AC_AMPCAP_NUM_STEPS_SHIFT) |
|
|
|
|
(0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
|
|
|
|
(1 << AC_AMPCAP_MUTE_SHIFT));
|
|
|
|
break;
|
|
|
|
}
|
2007-12-17 13:32:49 +00:00
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Conexant 5047 specific */
|
2007-02-13 11:45:44 +00:00
|
|
|
#define CXT5047_SPDIF_OUT 0x11
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
static hda_nid_t cxt5047_dac_nids[2] = { 0x10, 0x1c };
|
2006-11-14 11:13:39 +00:00
|
|
|
static hda_nid_t cxt5047_adc_nids[1] = { 0x12 };
|
|
|
|
static hda_nid_t cxt5047_capsrc_nids[1] = { 0x1a };
|
|
|
|
|
2006-11-20 16:42:09 +00:00
|
|
|
static struct hda_channel_mode cxt5047_modes[1] = {
|
|
|
|
{ 2, NULL },
|
|
|
|
};
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
static struct hda_input_mux cxt5047_capture_source = {
|
2007-03-12 10:39:01 +00:00
|
|
|
.num_items = 1,
|
2006-11-14 11:13:39 +00:00
|
|
|
.items = {
|
2007-03-12 10:39:01 +00:00
|
|
|
{ "Mic", 0x2 },
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_input_mux cxt5047_hp_capture_source = {
|
|
|
|
.num_items = 1,
|
|
|
|
.items = {
|
2007-02-13 11:45:44 +00:00
|
|
|
{ "ExtMic", 0x2 },
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_input_mux cxt5047_toshiba_capture_source = {
|
|
|
|
.num_items = 2,
|
|
|
|
.items = {
|
|
|
|
{ "ExtMic", 0x2 },
|
|
|
|
{ "Line-In", 0x1 },
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/* turn on/off EAPD (+ mute HP) as a master switch */
|
|
|
|
static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
2007-02-13 11:45:44 +00:00
|
|
|
unsigned int bits;
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
if (!cxt_eapd_put(kcontrol, ucontrol))
|
2006-11-14 11:13:39 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* toggle internal speakers mute depending of presence of
|
|
|
|
* the headphone jack
|
|
|
|
*/
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
|
|
|
bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2006-11-14 11:13:39 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* bind volumes of both NID 0x13 (Headphones) and 0x1d (Speakers) */
|
2007-08-10 15:12:15 +00:00
|
|
|
static struct hda_bind_ctls cxt5047_bind_master_vol = {
|
|
|
|
.ops = &snd_hda_bind_vol,
|
|
|
|
.values = {
|
|
|
|
HDA_COMPOSE_AMP_VAL(0x13, 3, 0, HDA_OUTPUT),
|
|
|
|
HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
|
|
|
|
0
|
|
|
|
},
|
|
|
|
};
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* mute internal speaker if HP is plugged */
|
|
|
|
static void cxt5047_hp_automute(struct hda_codec *codec)
|
|
|
|
{
|
2007-02-13 11:45:44 +00:00
|
|
|
struct conexant_spec *spec = codec->spec;
|
2007-02-26 15:07:42 +00:00
|
|
|
unsigned int bits;
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
spec->hp_present = snd_hda_codec_read(codec, 0x13, 0,
|
2006-11-14 11:13:39 +00:00
|
|
|
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
|
2007-02-26 15:07:42 +00:00
|
|
|
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Mute/Unmute PCM 2 for good measure - some systems need this */
|
2007-08-10 15:11:07 +00:00
|
|
|
snd_hda_codec_amp_stereo(codec, 0x1c, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2006-11-14 11:13:39 +00:00
|
|
|
}
|
|
|
|
|
2007-05-17 07:40:47 +00:00
|
|
|
/* mute internal speaker if HP is plugged */
|
|
|
|
static void cxt5047_hp2_automute(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
unsigned int bits;
|
|
|
|
|
|
|
|
spec->hp_present = snd_hda_codec_read(codec, 0x13, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
|
|
|
|
|
2007-08-10 15:11:07 +00:00
|
|
|
bits = spec->hp_present ? HDA_AMP_MUTE : 0;
|
|
|
|
snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2007-05-17 07:40:47 +00:00
|
|
|
/* Mute/Unmute PCM 2 for good measure - some systems need this */
|
2007-08-10 15:11:07 +00:00
|
|
|
snd_hda_codec_amp_stereo(codec, 0x1c, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, bits);
|
2007-05-17 07:40:47 +00:00
|
|
|
}
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
/* toggle input of built-in and mic jack appropriately */
|
|
|
|
static void cxt5047_hp_automic(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
static struct hda_verb mic_jack_on[] = {
|
2008-01-22 14:18:08 +00:00
|
|
|
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
static struct hda_verb mic_jack_off[] = {
|
2008-01-22 14:18:08 +00:00
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
|
|
|
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
unsigned int present;
|
|
|
|
|
2007-03-12 10:39:01 +00:00
|
|
|
present = snd_hda_codec_read(codec, 0x15, 0,
|
2006-11-14 11:13:39 +00:00
|
|
|
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
|
|
|
|
if (present)
|
|
|
|
snd_hda_sequence_write(codec, mic_jack_on);
|
|
|
|
else
|
|
|
|
snd_hda_sequence_write(codec, mic_jack_off);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unsolicited event for HP jack sensing */
|
|
|
|
static void cxt5047_hp_unsol_event(struct hda_codec *codec,
|
|
|
|
unsigned int res)
|
|
|
|
{
|
2008-01-22 14:18:08 +00:00
|
|
|
switch (res >> 26) {
|
2006-11-14 11:13:39 +00:00
|
|
|
case CONEXANT_HP_EVENT:
|
|
|
|
cxt5047_hp_automute(codec);
|
|
|
|
break;
|
|
|
|
case CONEXANT_MIC_EVENT:
|
|
|
|
cxt5047_hp_automic(codec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-17 07:40:47 +00:00
|
|
|
/* unsolicited event for HP jack sensing - non-EAPD systems */
|
|
|
|
static void cxt5047_hp2_unsol_event(struct hda_codec *codec,
|
|
|
|
unsigned int res)
|
|
|
|
{
|
|
|
|
res >>= 26;
|
|
|
|
switch (res) {
|
|
|
|
case CONEXANT_HP_EVENT:
|
|
|
|
cxt5047_hp2_automute(codec);
|
|
|
|
break;
|
|
|
|
case CONEXANT_MIC_EVENT:
|
|
|
|
cxt5047_hp_automic(codec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
static struct snd_kcontrol_new cxt5047_mixers[] = {
|
|
|
|
HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19, 0x02, HDA_INPUT),
|
2007-03-12 10:39:01 +00:00
|
|
|
HDA_CODEC_VOLUME("Mic Gain Volume", 0x1a, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Mic Gain Switch", 0x1a, 0x0, HDA_OUTPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
|
2007-02-13 11:45:44 +00:00
|
|
|
HDA_CODEC_VOLUME("PCM-2 Volume", 0x1c, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM-2 Switch", 0x1c, 0x00, HDA_OUTPUT),
|
2007-04-24 15:56:55 +00:00
|
|
|
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Headphone Playback Switch", 0x13, 0x00, HDA_OUTPUT),
|
2007-02-13 11:45:44 +00:00
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5047_toshiba_mixers[] = {
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put
|
|
|
|
},
|
|
|
|
HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
|
2007-08-10 15:12:15 +00:00
|
|
|
HDA_BIND_VOL("Master Playback Volume", &cxt5047_bind_master_vol),
|
2007-02-13 11:45:44 +00:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
2006-11-14 11:13:39 +00:00
|
|
|
.put = cxt5047_hp_master_sw_put,
|
|
|
|
.private_value = 0x13,
|
|
|
|
},
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5047_hp_mixers[] = {
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put
|
|
|
|
},
|
|
|
|
HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19,0x02,HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("Master Playback Volume", 0x13, 0x00, HDA_OUTPUT),
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
2007-02-13 11:45:44 +00:00
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
2006-11-14 11:13:39 +00:00
|
|
|
.put = cxt5047_hp_master_sw_put,
|
|
|
|
.private_value = 0x13,
|
|
|
|
},
|
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_verb cxt5047_init_verbs[] = {
|
|
|
|
/* Line in, Mic, Built-in Mic */
|
|
|
|
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
|
|
|
|
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
|
|
|
|
{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
|
2007-03-12 10:39:01 +00:00
|
|
|
/* HP, Speaker */
|
2007-04-24 15:56:55 +00:00
|
|
|
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
|
|
|
|
{0x13, AC_VERB_SET_CONNECT_SEL,0x1},
|
2007-02-13 11:45:44 +00:00
|
|
|
{0x1d, AC_VERB_SET_CONNECT_SEL,0x0},
|
2007-03-12 10:39:01 +00:00
|
|
|
/* Record selector: Mic */
|
2006-11-14 11:13:39 +00:00
|
|
|
{0x12, AC_VERB_SET_CONNECT_SEL,0x03},
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
|
2007-03-12 10:39:01 +00:00
|
|
|
{0x1A, AC_VERB_SET_CONNECT_SEL,0x02},
|
|
|
|
{0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x00},
|
|
|
|
{0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x03},
|
2006-11-14 11:13:39 +00:00
|
|
|
/* SPDIF route: PCM */
|
|
|
|
{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x0 },
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Enable unsolicited events */
|
|
|
|
{0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
|
|
|
|
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
|
2006-11-14 11:13:39 +00:00
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* configuration for Toshiba Laptops */
|
|
|
|
static struct hda_verb cxt5047_toshiba_init_verbs[] = {
|
|
|
|
{0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0 }, /* default on */
|
|
|
|
/* pin sensing on HP and Mic jacks */
|
|
|
|
{0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
|
|
|
|
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Speaker routing */
|
|
|
|
{0x1d, AC_VERB_SET_CONNECT_SEL,0x1},
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
/* configuration for HP Laptops */
|
|
|
|
static struct hda_verb cxt5047_hp_init_verbs[] = {
|
2007-02-13 11:45:44 +00:00
|
|
|
/* pin sensing on HP jack */
|
2006-11-14 11:13:39 +00:00
|
|
|
{0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
|
2008-02-18 11:36:11 +00:00
|
|
|
/* 0x13 is actually shared by both HP and speaker;
|
|
|
|
* setting the connection to 0 (=0x19) makes the master volume control
|
|
|
|
* working mysteriouslly...
|
|
|
|
*/
|
|
|
|
{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Record selector: Ext Mic */
|
|
|
|
{0x12, AC_VERB_SET_CONNECT_SEL,0x03},
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
|
|
|
|
/* Speaker routing */
|
|
|
|
{0x1d, AC_VERB_SET_CONNECT_SEL,0x1},
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Test configuration for debugging, modelled after the ALC260 test
|
|
|
|
* configuration.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
static struct hda_input_mux cxt5047_test_capture_source = {
|
2007-02-13 11:45:44 +00:00
|
|
|
.num_items = 4,
|
2006-11-14 11:13:39 +00:00
|
|
|
.items = {
|
2007-02-13 11:45:44 +00:00
|
|
|
{ "LINE1 pin", 0x0 },
|
|
|
|
{ "MIC1 pin", 0x1 },
|
|
|
|
{ "MIC2 pin", 0x2 },
|
|
|
|
{ "CD pin", 0x3 },
|
2006-11-14 11:13:39 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5047_test_mixer[] = {
|
|
|
|
|
|
|
|
/* Output only controls */
|
2007-02-13 11:45:44 +00:00
|
|
|
HDA_CODEC_VOLUME("OutAmp-1 Volume", 0x10, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("OutAmp-1 Switch", 0x10,0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("OutAmp-2 Volume", 0x1c, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("OutAmp-2 Switch", 0x1c, 0x0, HDA_OUTPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("HeadPhone Playback Volume", 0x13, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("HeadPhone Playback Switch", 0x13, 0x0, HDA_OUTPUT),
|
2007-02-13 11:45:44 +00:00
|
|
|
HDA_CODEC_VOLUME("Line1-Out Playback Volume", 0x14, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Line1-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_VOLUME("Line2-Out Playback Volume", 0x15, 0x0, HDA_OUTPUT),
|
|
|
|
HDA_CODEC_MUTE("Line2-Out Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
/* Modes for retasking pin widgets */
|
|
|
|
CXT_PIN_MODE("LINE1 pin mode", 0x14, CXT_PIN_DIR_INOUT),
|
|
|
|
CXT_PIN_MODE("MIC1 pin mode", 0x15, CXT_PIN_DIR_INOUT),
|
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* EAPD Switch Control */
|
|
|
|
CXT_EAPD_SWITCH("External Amplifier", 0x13, 0x0),
|
2006-11-14 11:13:39 +00:00
|
|
|
|
2007-02-13 11:45:44 +00:00
|
|
|
/* Loopback mixer controls */
|
|
|
|
HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x12, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("MIC1 Playback Switch", 0x12, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x12, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("MIC2 Playback Switch", 0x12, 0x02, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("LINE Playback Volume", 0x12, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("LINE Playback Switch", 0x12, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("CD Playback Volume", 0x12, 0x04, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("CD Playback Switch", 0x12, 0x04, HDA_INPUT),
|
|
|
|
|
|
|
|
HDA_CODEC_VOLUME("Capture-1 Volume", 0x19, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture-1 Switch", 0x19, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Capture-2 Volume", 0x19, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture-2 Switch", 0x19, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Capture-3 Volume", 0x19, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture-3 Switch", 0x19, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Capture-4 Volume", 0x19, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Capture-4 Switch", 0x19, 0x3, HDA_INPUT),
|
2006-11-14 11:13:39 +00:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Input Source",
|
|
|
|
.info = conexant_mux_enum_info,
|
|
|
|
.get = conexant_mux_enum_get,
|
|
|
|
.put = conexant_mux_enum_put,
|
|
|
|
},
|
2008-01-22 14:18:08 +00:00
|
|
|
HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT),
|
|
|
|
|
2006-11-14 11:13:39 +00:00
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_verb cxt5047_test_init_verbs[] = {
|
|
|
|
/* Enable retasking pins as output, initially without power amp */
|
|
|
|
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
|
|
|
|
/* Disable digital (SPDIF) pins initially, but users can enable
|
|
|
|
* them via a mixer switch. In the case of SPDIF-out, this initverb
|
|
|
|
* payload also sets the generation to 0, output to be in "consumer"
|
|
|
|
* PCM format, copyright asserted, no pre-emphasis and no validity
|
|
|
|
* control.
|
|
|
|
*/
|
|
|
|
{0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
|
|
|
|
|
|
|
|
/* Ensure mic1, mic2, line1 pin widgets take input from the
|
|
|
|
* OUT1 sum bus when acting as an output.
|
|
|
|
*/
|
|
|
|
{0x1a, AC_VERB_SET_CONNECT_SEL, 0},
|
|
|
|
{0x1b, AC_VERB_SET_CONNECT_SEL, 0},
|
|
|
|
|
|
|
|
/* Start with output sum widgets muted and their output gains at min */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
|
|
|
|
|
|
|
/* Unmute retasking pin widget output buffers since the default
|
|
|
|
* state appears to be output. As the pin mode is changed by the
|
|
|
|
* user the pin mode control will take care of enabling the pin's
|
|
|
|
* input/output buffers as needed.
|
|
|
|
*/
|
|
|
|
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
|
|
|
|
/* Mute capture amp left and right */
|
|
|
|
{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
|
|
|
|
|
|
|
/* Set ADC connection select to match default mixer setting (mic1
|
|
|
|
* pin)
|
|
|
|
*/
|
|
|
|
{0x12, AC_VERB_SET_CONNECT_SEL, 0x00},
|
|
|
|
|
|
|
|
/* Mute all inputs to mixer widget (even unconnected ones) */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
|
|
|
|
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
|
|
|
|
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* initialize jack-sensing, too */
|
|
|
|
static int cxt5047_hp_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
conexant_init(codec);
|
|
|
|
cxt5047_hp_automute(codec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
enum {
|
2006-11-24 16:07:44 +00:00
|
|
|
CXT5047_LAPTOP, /* Laptops w/o EAPD support */
|
|
|
|
CXT5047_LAPTOP_HP, /* Some HP laptops */
|
|
|
|
CXT5047_LAPTOP_EAPD, /* Laptops with EAPD support */
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
CXT5047_TEST,
|
|
|
|
#endif
|
2006-11-24 16:07:44 +00:00
|
|
|
CXT5047_MODELS
|
2006-11-14 11:13:39 +00:00
|
|
|
};
|
|
|
|
|
2006-11-24 16:07:44 +00:00
|
|
|
static const char *cxt5047_models[CXT5047_MODELS] = {
|
|
|
|
[CXT5047_LAPTOP] = "laptop",
|
|
|
|
[CXT5047_LAPTOP_HP] = "laptop-hp",
|
|
|
|
[CXT5047_LAPTOP_EAPD] = "laptop-eapd",
|
2006-11-14 11:13:39 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
2006-11-24 16:07:44 +00:00
|
|
|
[CXT5047_TEST] = "test",
|
2006-11-14 11:13:39 +00:00
|
|
|
#endif
|
2006-11-24 16:07:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_pci_quirk cxt5047_cfg_tbl[] = {
|
|
|
|
SND_PCI_QUIRK(0x103c, 0x30a0, "HP DV1000", CXT5047_LAPTOP),
|
2007-12-17 16:14:18 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30a5, "HP DV5200T/DV8000T", CXT5047_LAPTOP_HP),
|
2006-11-24 16:07:44 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30b2, "HP DV2000T/DV3000T", CXT5047_LAPTOP),
|
2007-02-13 11:45:44 +00:00
|
|
|
SND_PCI_QUIRK(0x103c, 0x30b5, "HP DV2000Z", CXT5047_LAPTOP),
|
2006-11-24 16:07:44 +00:00
|
|
|
SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P100", CXT5047_LAPTOP_EAPD),
|
2006-11-14 11:13:39 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int patch_cxt5047(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec;
|
|
|
|
int board_config;
|
|
|
|
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
|
|
if (!spec)
|
|
|
|
return -ENOMEM;
|
|
|
|
codec->spec = spec;
|
|
|
|
|
|
|
|
spec->multiout.max_channels = 2;
|
|
|
|
spec->multiout.num_dacs = ARRAY_SIZE(cxt5047_dac_nids);
|
|
|
|
spec->multiout.dac_nids = cxt5047_dac_nids;
|
|
|
|
spec->multiout.dig_out_nid = CXT5047_SPDIF_OUT;
|
|
|
|
spec->num_adc_nids = 1;
|
|
|
|
spec->adc_nids = cxt5047_adc_nids;
|
|
|
|
spec->capsrc_nids = cxt5047_capsrc_nids;
|
|
|
|
spec->input_mux = &cxt5047_capture_source;
|
|
|
|
spec->num_mixers = 1;
|
|
|
|
spec->mixers[0] = cxt5047_mixers;
|
|
|
|
spec->num_init_verbs = 1;
|
|
|
|
spec->init_verbs[0] = cxt5047_init_verbs;
|
|
|
|
spec->spdif_route = 0;
|
2006-11-20 16:42:09 +00:00
|
|
|
spec->num_channel_mode = ARRAY_SIZE(cxt5047_modes),
|
|
|
|
spec->channel_mode = cxt5047_modes,
|
2006-11-14 11:13:39 +00:00
|
|
|
|
|
|
|
codec->patch_ops = conexant_patch_ops;
|
|
|
|
|
2006-11-24 16:07:44 +00:00
|
|
|
board_config = snd_hda_check_board_config(codec, CXT5047_MODELS,
|
|
|
|
cxt5047_models,
|
|
|
|
cxt5047_cfg_tbl);
|
2006-11-14 11:13:39 +00:00
|
|
|
switch (board_config) {
|
|
|
|
case CXT5047_LAPTOP:
|
2007-05-17 07:40:47 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5047_hp2_unsol_event;
|
2006-11-14 11:13:39 +00:00
|
|
|
break;
|
|
|
|
case CXT5047_LAPTOP_HP:
|
|
|
|
spec->input_mux = &cxt5047_hp_capture_source;
|
|
|
|
spec->num_init_verbs = 2;
|
|
|
|
spec->init_verbs[1] = cxt5047_hp_init_verbs;
|
|
|
|
spec->mixers[0] = cxt5047_hp_mixers;
|
2007-05-17 07:40:47 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
|
2006-11-14 11:13:39 +00:00
|
|
|
codec->patch_ops.init = cxt5047_hp_init;
|
|
|
|
break;
|
|
|
|
case CXT5047_LAPTOP_EAPD:
|
2007-02-13 11:45:44 +00:00
|
|
|
spec->input_mux = &cxt5047_toshiba_capture_source;
|
2006-11-14 11:13:39 +00:00
|
|
|
spec->num_init_verbs = 2;
|
|
|
|
spec->init_verbs[1] = cxt5047_toshiba_init_verbs;
|
2007-02-13 11:45:44 +00:00
|
|
|
spec->mixers[0] = cxt5047_toshiba_mixers;
|
2007-05-17 07:40:47 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
|
2006-11-14 11:13:39 +00:00
|
|
|
break;
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
case CXT5047_TEST:
|
|
|
|
spec->input_mux = &cxt5047_test_capture_source;
|
|
|
|
spec->mixers[0] = cxt5047_test_mixer;
|
|
|
|
spec->init_verbs[0] = cxt5047_test_init_verbs;
|
2007-05-17 07:40:47 +00:00
|
|
|
codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
|
2006-11-14 11:13:39 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-25 10:35:17 +00:00
|
|
|
/* Conexant 5051 specific */
|
|
|
|
static hda_nid_t cxt5051_dac_nids[1] = { 0x10 };
|
|
|
|
static hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 };
|
|
|
|
|
|
|
|
static struct hda_channel_mode cxt5051_modes[1] = {
|
|
|
|
{ 2, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
static void cxt5051_update_speaker(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
unsigned int pinctl;
|
|
|
|
pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
|
|
|
|
snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
|
|
pinctl);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* turn on/off EAPD (+ mute HP) as a master switch */
|
|
|
|
static int cxt5051_hp_master_sw_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
if (!cxt_eapd_put(kcontrol, ucontrol))
|
|
|
|
return 0;
|
|
|
|
cxt5051_update_speaker(codec);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* toggle input of built-in and mic jack appropriately */
|
|
|
|
static void cxt5051_portb_automic(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
unsigned int present;
|
|
|
|
|
|
|
|
present = snd_hda_codec_read(codec, 0x17, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) &
|
|
|
|
AC_PINSENSE_PRESENCE;
|
|
|
|
snd_hda_codec_write(codec, 0x14, 0,
|
|
|
|
AC_VERB_SET_CONNECT_SEL,
|
|
|
|
present ? 0x01 : 0x00);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* switch the current ADC according to the jack state */
|
|
|
|
static void cxt5051_portc_automic(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
unsigned int present;
|
|
|
|
hda_nid_t new_adc;
|
|
|
|
|
|
|
|
present = snd_hda_codec_read(codec, 0x18, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) &
|
|
|
|
AC_PINSENSE_PRESENCE;
|
|
|
|
if (present)
|
|
|
|
spec->cur_adc_idx = 1;
|
|
|
|
else
|
|
|
|
spec->cur_adc_idx = 0;
|
|
|
|
new_adc = spec->adc_nids[spec->cur_adc_idx];
|
|
|
|
if (spec->cur_adc && spec->cur_adc != new_adc) {
|
|
|
|
/* stream is running, let's swap the current ADC */
|
2008-03-18 08:57:50 +00:00
|
|
|
snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
|
2008-01-25 10:35:17 +00:00
|
|
|
spec->cur_adc = new_adc;
|
|
|
|
snd_hda_codec_setup_stream(codec, new_adc,
|
|
|
|
spec->cur_adc_stream_tag, 0,
|
|
|
|
spec->cur_adc_format);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* mute internal speaker if HP is plugged */
|
|
|
|
static void cxt5051_hp_automute(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec = codec->spec;
|
|
|
|
|
|
|
|
spec->hp_present = snd_hda_codec_read(codec, 0x16, 0,
|
|
|
|
AC_VERB_GET_PIN_SENSE, 0) &
|
|
|
|
AC_PINSENSE_PRESENCE;
|
|
|
|
cxt5051_update_speaker(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unsolicited event for HP jack sensing */
|
|
|
|
static void cxt5051_hp_unsol_event(struct hda_codec *codec,
|
|
|
|
unsigned int res)
|
|
|
|
{
|
|
|
|
switch (res >> 26) {
|
|
|
|
case CONEXANT_HP_EVENT:
|
|
|
|
cxt5051_hp_automute(codec);
|
|
|
|
break;
|
|
|
|
case CXT5051_PORTB_EVENT:
|
|
|
|
cxt5051_portb_automic(codec);
|
|
|
|
break;
|
|
|
|
case CXT5051_PORTC_EVENT:
|
|
|
|
cxt5051_portc_automic(codec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5051_mixers[] = {
|
|
|
|
HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("External Mic Volume", 0x14, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("External Mic Switch", 0x14, 0x01, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Docking Mic Volume", 0x15, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Docking Mic Switch", 0x15, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
|
|
|
.put = cxt5051_hp_master_sw_put,
|
|
|
|
.private_value = 0x1a,
|
|
|
|
},
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new cxt5051_hp_mixers[] = {
|
|
|
|
HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("External Mic Volume", 0x15, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_MUTE("External Mic Switch", 0x15, 0x00, HDA_INPUT),
|
|
|
|
HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Master Playback Switch",
|
|
|
|
.info = cxt_eapd_info,
|
|
|
|
.get = cxt_eapd_get,
|
|
|
|
.put = cxt5051_hp_master_sw_put,
|
|
|
|
.private_value = 0x1a,
|
|
|
|
},
|
|
|
|
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_verb cxt5051_init_verbs[] = {
|
|
|
|
/* Line in, Mic */
|
|
|
|
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
|
|
|
|
{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
|
|
|
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
|
|
|
|
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
|
|
|
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
|
|
|
{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
|
|
|
|
/* SPK */
|
|
|
|
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
|
|
|
{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
|
|
|
|
/* HP, Amp */
|
|
|
|
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
|
|
|
{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
|
|
|
|
/* DAC1 */
|
|
|
|
{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
|
|
|
/* Record selector: Int mic */
|
|
|
|
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
|
|
|
|
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
|
|
|
|
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
|
|
|
|
/* SPDIF route: PCM */
|
|
|
|
{0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
|
|
|
|
/* EAPD */
|
|
|
|
{0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
|
|
|
|
{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
|
|
|
|
{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
|
|
|
|
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
|
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* initialize jack-sensing, too */
|
|
|
|
static int cxt5051_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
conexant_init(codec);
|
|
|
|
if (codec->patch_ops.unsol_event) {
|
|
|
|
cxt5051_hp_automute(codec);
|
|
|
|
cxt5051_portb_automic(codec);
|
|
|
|
cxt5051_portc_automic(codec);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
CXT5051_LAPTOP, /* Laptops w/ EAPD support */
|
|
|
|
CXT5051_HP, /* no docking */
|
|
|
|
CXT5051_MODELS
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *cxt5051_models[CXT5051_MODELS] = {
|
|
|
|
[CXT5051_LAPTOP] = "laptop",
|
|
|
|
[CXT5051_HP] = "hp",
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
|
|
|
|
SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
|
|
|
|
CXT5051_LAPTOP),
|
|
|
|
SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int patch_cxt5051(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct conexant_spec *spec;
|
|
|
|
int board_config;
|
|
|
|
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
|
|
if (!spec)
|
|
|
|
return -ENOMEM;
|
|
|
|
codec->spec = spec;
|
|
|
|
|
|
|
|
codec->patch_ops = conexant_patch_ops;
|
|
|
|
codec->patch_ops.init = cxt5051_init;
|
|
|
|
|
|
|
|
spec->multiout.max_channels = 2;
|
|
|
|
spec->multiout.num_dacs = ARRAY_SIZE(cxt5051_dac_nids);
|
|
|
|
spec->multiout.dac_nids = cxt5051_dac_nids;
|
|
|
|
spec->multiout.dig_out_nid = CXT5051_SPDIF_OUT;
|
|
|
|
spec->num_adc_nids = 1; /* not 2; via auto-mic switch */
|
|
|
|
spec->adc_nids = cxt5051_adc_nids;
|
|
|
|
spec->num_mixers = 1;
|
|
|
|
spec->mixers[0] = cxt5051_mixers;
|
|
|
|
spec->num_init_verbs = 1;
|
|
|
|
spec->init_verbs[0] = cxt5051_init_verbs;
|
|
|
|
spec->spdif_route = 0;
|
|
|
|
spec->num_channel_mode = ARRAY_SIZE(cxt5051_modes);
|
|
|
|
spec->channel_mode = cxt5051_modes;
|
|
|
|
spec->cur_adc = 0;
|
|
|
|
spec->cur_adc_idx = 0;
|
|
|
|
|
|
|
|
board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
|
|
|
|
cxt5051_models,
|
|
|
|
cxt5051_cfg_tbl);
|
|
|
|
switch (board_config) {
|
|
|
|
case CXT5051_HP:
|
|
|
|
codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
|
|
|
|
spec->mixers[0] = cxt5051_hp_mixers;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case CXT5051_LAPTOP:
|
|
|
|
codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
*/
|
|
|
|
|
2008-11-27 14:47:11 +00:00
|
|
|
static struct hda_codec_preset snd_hda_preset_conexant[] = {
|
2007-02-13 11:45:44 +00:00
|
|
|
{ .id = 0x14f15045, .name = "CX20549 (Venice)",
|
|
|
|
.patch = patch_cxt5045 },
|
|
|
|
{ .id = 0x14f15047, .name = "CX20551 (Waikiki)",
|
|
|
|
.patch = patch_cxt5047 },
|
2008-01-25 10:35:17 +00:00
|
|
|
{ .id = 0x14f15051, .name = "CX20561 (Hermosa)",
|
|
|
|
.patch = patch_cxt5051 },
|
2006-11-14 11:13:39 +00:00
|
|
|
{} /* terminator */
|
|
|
|
};
|
2008-11-27 14:47:11 +00:00
|
|
|
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:14f15045");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:14f15047");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:14f15051");
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("Conexant HD-audio codec");
|
|
|
|
|
|
|
|
static struct hda_codec_preset_list conexant_list = {
|
|
|
|
.preset = snd_hda_preset_conexant,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init patch_conexant_init(void)
|
|
|
|
{
|
|
|
|
return snd_hda_add_codec_preset(&conexant_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit patch_conexant_exit(void)
|
|
|
|
{
|
|
|
|
snd_hda_delete_codec_preset(&conexant_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(patch_conexant_init)
|
|
|
|
module_exit(patch_conexant_exit)
|