mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 18 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190520170857.186505395@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1243 lines
32 KiB
C
1243 lines
32 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* HD audio interface patch for Cirrus Logic CS420x chip
|
|
*
|
|
* Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <sound/core.h>
|
|
#include <sound/tlv.h>
|
|
#include <sound/hda_codec.h>
|
|
#include "hda_local.h"
|
|
#include "hda_auto_parser.h"
|
|
#include "hda_jack.h"
|
|
#include "hda_generic.h"
|
|
|
|
/*
|
|
*/
|
|
|
|
struct cs_spec {
|
|
struct hda_gen_spec gen;
|
|
|
|
unsigned int gpio_mask;
|
|
unsigned int gpio_dir;
|
|
unsigned int gpio_data;
|
|
unsigned int gpio_eapd_hp; /* EAPD GPIO bit for headphones */
|
|
unsigned int gpio_eapd_speaker; /* EAPD GPIO bit for speakers */
|
|
|
|
/* CS421x */
|
|
unsigned int spdif_detect:1;
|
|
unsigned int spdif_present:1;
|
|
unsigned int sense_b:1;
|
|
hda_nid_t vendor_nid;
|
|
|
|
/* for MBP SPDIF control */
|
|
int (*spdif_sw_put)(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
};
|
|
|
|
/* available models with CS420x */
|
|
enum {
|
|
CS420X_MBP53,
|
|
CS420X_MBP55,
|
|
CS420X_IMAC27,
|
|
CS420X_GPIO_13,
|
|
CS420X_GPIO_23,
|
|
CS420X_MBP101,
|
|
CS420X_MBP81,
|
|
CS420X_MBA42,
|
|
CS420X_AUTO,
|
|
/* aliases */
|
|
CS420X_IMAC27_122 = CS420X_GPIO_23,
|
|
CS420X_APPLE = CS420X_GPIO_13,
|
|
};
|
|
|
|
/* CS421x boards */
|
|
enum {
|
|
CS421X_CDB4210,
|
|
CS421X_SENSE_B,
|
|
CS421X_STUMPY,
|
|
};
|
|
|
|
/* Vendor-specific processing widget */
|
|
#define CS420X_VENDOR_NID 0x11
|
|
#define CS_DIG_OUT1_PIN_NID 0x10
|
|
#define CS_DIG_OUT2_PIN_NID 0x15
|
|
#define CS_DMIC1_PIN_NID 0x0e
|
|
#define CS_DMIC2_PIN_NID 0x12
|
|
|
|
/* coef indices */
|
|
#define IDX_SPDIF_STAT 0x0000
|
|
#define IDX_SPDIF_CTL 0x0001
|
|
#define IDX_ADC_CFG 0x0002
|
|
/* SZC bitmask, 4 modes below:
|
|
* 0 = immediate,
|
|
* 1 = digital immediate, analog zero-cross
|
|
* 2 = digtail & analog soft-ramp
|
|
* 3 = digital soft-ramp, analog zero-cross
|
|
*/
|
|
#define CS_COEF_ADC_SZC_MASK (3 << 0)
|
|
#define CS_COEF_ADC_MIC_SZC_MODE (3 << 0) /* SZC setup for mic */
|
|
#define CS_COEF_ADC_LI_SZC_MODE (3 << 0) /* SZC setup for line-in */
|
|
/* PGA mode: 0 = differential, 1 = signle-ended */
|
|
#define CS_COEF_ADC_MIC_PGA_MODE (1 << 5) /* PGA setup for mic */
|
|
#define CS_COEF_ADC_LI_PGA_MODE (1 << 6) /* PGA setup for line-in */
|
|
#define IDX_DAC_CFG 0x0003
|
|
/* SZC bitmask, 4 modes below:
|
|
* 0 = Immediate
|
|
* 1 = zero-cross
|
|
* 2 = soft-ramp
|
|
* 3 = soft-ramp on zero-cross
|
|
*/
|
|
#define CS_COEF_DAC_HP_SZC_MODE (3 << 0) /* nid 0x02 */
|
|
#define CS_COEF_DAC_LO_SZC_MODE (3 << 2) /* nid 0x03 */
|
|
#define CS_COEF_DAC_SPK_SZC_MODE (3 << 4) /* nid 0x04 */
|
|
|
|
#define IDX_BEEP_CFG 0x0004
|
|
/* 0x0008 - test reg key */
|
|
/* 0x0009 - 0x0014 -> 12 test regs */
|
|
/* 0x0015 - visibility reg */
|
|
|
|
/* Cirrus Logic CS4208 */
|
|
#define CS4208_VENDOR_NID 0x24
|
|
|
|
/*
|
|
* Cirrus Logic CS4210
|
|
*
|
|
* 1 DAC => HP(sense) / Speakers,
|
|
* 1 ADC <= LineIn(sense) / MicIn / DMicIn,
|
|
* 1 SPDIF OUT => SPDIF Trasmitter(sense)
|
|
*/
|
|
#define CS4210_DAC_NID 0x02
|
|
#define CS4210_ADC_NID 0x03
|
|
#define CS4210_VENDOR_NID 0x0B
|
|
#define CS421X_DMIC_PIN_NID 0x09 /* Port E */
|
|
#define CS421X_SPDIF_PIN_NID 0x0A /* Port H */
|
|
|
|
#define CS421X_IDX_DEV_CFG 0x01
|
|
#define CS421X_IDX_ADC_CFG 0x02
|
|
#define CS421X_IDX_DAC_CFG 0x03
|
|
#define CS421X_IDX_SPK_CTL 0x04
|
|
|
|
/* Cirrus Logic CS4213 is like CS4210 but does not have SPDIF input/output */
|
|
#define CS4213_VENDOR_NID 0x09
|
|
|
|
|
|
static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
snd_hda_codec_write(codec, spec->vendor_nid, 0,
|
|
AC_VERB_SET_COEF_INDEX, idx);
|
|
return snd_hda_codec_read(codec, spec->vendor_nid, 0,
|
|
AC_VERB_GET_PROC_COEF, 0);
|
|
}
|
|
|
|
static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
|
|
unsigned int coef)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
snd_hda_codec_write(codec, spec->vendor_nid, 0,
|
|
AC_VERB_SET_COEF_INDEX, idx);
|
|
snd_hda_codec_write(codec, spec->vendor_nid, 0,
|
|
AC_VERB_SET_PROC_COEF, coef);
|
|
}
|
|
|
|
/*
|
|
* auto-mute and auto-mic switching
|
|
* CS421x auto-output redirecting
|
|
* HP/SPK/SPDIF
|
|
*/
|
|
|
|
static void cs_automute(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
|
|
/* mute HPs if spdif jack (SENSE_B) is present */
|
|
spec->gen.master_mute = !!(spec->spdif_present && spec->sense_b);
|
|
|
|
snd_hda_gen_update_outputs(codec);
|
|
|
|
if (spec->gpio_eapd_hp || spec->gpio_eapd_speaker) {
|
|
if (spec->gen.automute_speaker)
|
|
spec->gpio_data = spec->gen.hp_jack_present ?
|
|
spec->gpio_eapd_hp : spec->gpio_eapd_speaker;
|
|
else
|
|
spec->gpio_data =
|
|
spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
|
|
snd_hda_codec_write(codec, 0x01, 0,
|
|
AC_VERB_SET_GPIO_DATA, spec->gpio_data);
|
|
}
|
|
}
|
|
|
|
static bool is_active_pin(struct hda_codec *codec, hda_nid_t nid)
|
|
{
|
|
unsigned int val;
|
|
val = snd_hda_codec_get_pincfg(codec, nid);
|
|
return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
|
|
}
|
|
|
|
static void init_input_coef(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
unsigned int coef;
|
|
|
|
/* CS420x has multiple ADC, CS421x has single ADC */
|
|
if (spec->vendor_nid == CS420X_VENDOR_NID) {
|
|
coef = cs_vendor_coef_get(codec, IDX_BEEP_CFG);
|
|
if (is_active_pin(codec, CS_DMIC2_PIN_NID))
|
|
coef |= 1 << 4; /* DMIC2 2 chan on, GPIO1 off */
|
|
if (is_active_pin(codec, CS_DMIC1_PIN_NID))
|
|
coef |= 1 << 3; /* DMIC1 2 chan on, GPIO0 off
|
|
* No effect if SPDIF_OUT2 is
|
|
* selected in IDX_SPDIF_CTL.
|
|
*/
|
|
|
|
cs_vendor_coef_set(codec, IDX_BEEP_CFG, coef);
|
|
}
|
|
}
|
|
|
|
static const struct hda_verb cs_coef_init_verbs[] = {
|
|
{0x11, AC_VERB_SET_PROC_STATE, 1},
|
|
{0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
|
|
{0x11, AC_VERB_SET_PROC_COEF,
|
|
(0x002a /* DAC1/2/3 SZCMode Soft Ramp */
|
|
| 0x0040 /* Mute DACs on FIFO error */
|
|
| 0x1000 /* Enable DACs High Pass Filter */
|
|
| 0x0400 /* Disable Coefficient Auto increment */
|
|
)},
|
|
/* ADC1/2 - Digital and Analog Soft Ramp */
|
|
{0x11, AC_VERB_SET_COEF_INDEX, IDX_ADC_CFG},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x000a},
|
|
/* Beep */
|
|
{0x11, AC_VERB_SET_COEF_INDEX, IDX_BEEP_CFG},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
|
|
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_verb cs4208_coef_init_verbs[] = {
|
|
{0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
|
|
{0x24, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */
|
|
{0x24, AC_VERB_SET_COEF_INDEX, 0x0033},
|
|
{0x24, AC_VERB_SET_PROC_COEF, 0x0001}, /* A1 ICS */
|
|
{0x24, AC_VERB_SET_COEF_INDEX, 0x0034},
|
|
{0x24, AC_VERB_SET_PROC_COEF, 0x1C01}, /* A1 Enable, A Thresh = 300mV */
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* Errata: CS4207 rev C0/C1/C2 Silicon
|
|
*
|
|
* http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
|
|
*
|
|
* 6. At high temperature (TA > +85°C), the digital supply current (IVD)
|
|
* may be excessive (up to an additional 200 μA), which is most easily
|
|
* observed while the part is being held in reset (RESET# active low).
|
|
*
|
|
* Root Cause: At initial powerup of the device, the logic that drives
|
|
* the clock and write enable to the S/PDIF SRC RAMs is not properly
|
|
* initialized.
|
|
* Certain random patterns will cause a steady leakage current in those
|
|
* RAM cells. The issue will resolve once the SRCs are used (turned on).
|
|
*
|
|
* Workaround: The following verb sequence briefly turns on the S/PDIF SRC
|
|
* blocks, which will alleviate the issue.
|
|
*/
|
|
|
|
static const struct hda_verb cs_errata_init_verbs[] = {
|
|
{0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
|
|
{0x11, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */
|
|
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x9999},
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0xa412},
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x0009},
|
|
|
|
{0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
|
|
{0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
|
|
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x2412},
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x0000},
|
|
{0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x0008},
|
|
{0x11, AC_VERB_SET_PROC_STATE, 0x00},
|
|
|
|
#if 0 /* Don't to set to D3 as we are in power-up sequence */
|
|
{0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
|
|
{0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
|
|
/*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
|
|
#endif
|
|
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* SPDIF setup */
|
|
static void init_digital_coef(struct hda_codec *codec)
|
|
{
|
|
unsigned int coef;
|
|
|
|
coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
|
|
coef |= 0x0008; /* Replace with mute on error */
|
|
if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
|
|
coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
|
|
* SPDIF_OUT2 is shared with GPIO1 and
|
|
* DMIC_SDA2.
|
|
*/
|
|
cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
|
|
}
|
|
|
|
static int cs_init(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
|
|
if (spec->vendor_nid == CS420X_VENDOR_NID) {
|
|
/* init_verb sequence for C0/C1/C2 errata*/
|
|
snd_hda_sequence_write(codec, cs_errata_init_verbs);
|
|
snd_hda_sequence_write(codec, cs_coef_init_verbs);
|
|
} else if (spec->vendor_nid == CS4208_VENDOR_NID) {
|
|
snd_hda_sequence_write(codec, cs4208_coef_init_verbs);
|
|
}
|
|
|
|
snd_hda_gen_init(codec);
|
|
|
|
if (spec->gpio_mask) {
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
|
|
spec->gpio_mask);
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
|
|
spec->gpio_dir);
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
|
|
spec->gpio_data);
|
|
}
|
|
|
|
if (spec->vendor_nid == CS420X_VENDOR_NID) {
|
|
init_input_coef(codec);
|
|
init_digital_coef(codec);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cs_build_controls(struct hda_codec *codec)
|
|
{
|
|
int err;
|
|
|
|
err = snd_hda_gen_build_controls(codec);
|
|
if (err < 0)
|
|
return err;
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
|
|
return 0;
|
|
}
|
|
|
|
#define cs_free snd_hda_gen_free
|
|
|
|
static const struct hda_codec_ops cs_patch_ops = {
|
|
.build_controls = cs_build_controls,
|
|
.build_pcms = snd_hda_gen_build_pcms,
|
|
.init = cs_init,
|
|
.free = cs_free,
|
|
.unsol_event = snd_hda_jack_unsol_event,
|
|
};
|
|
|
|
static int cs_parse_auto_config(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
int err;
|
|
int i;
|
|
|
|
err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* keep the ADCs powered up when it's dynamically switchable */
|
|
if (spec->gen.dyn_adc_switch) {
|
|
unsigned int done = 0;
|
|
for (i = 0; i < spec->gen.input_mux.num_items; i++) {
|
|
int idx = spec->gen.dyn_adc_idx[i];
|
|
if (done & (1 << idx))
|
|
continue;
|
|
snd_hda_gen_fix_pin_power(codec,
|
|
spec->gen.adc_nids[idx]);
|
|
done |= 1 << idx;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct hda_model_fixup cs420x_models[] = {
|
|
{ .id = CS420X_MBP53, .name = "mbp53" },
|
|
{ .id = CS420X_MBP55, .name = "mbp55" },
|
|
{ .id = CS420X_IMAC27, .name = "imac27" },
|
|
{ .id = CS420X_IMAC27_122, .name = "imac27_122" },
|
|
{ .id = CS420X_APPLE, .name = "apple" },
|
|
{ .id = CS420X_MBP101, .name = "mbp101" },
|
|
{ .id = CS420X_MBP81, .name = "mbp81" },
|
|
{ .id = CS420X_MBA42, .name = "mba42" },
|
|
{}
|
|
};
|
|
|
|
static const struct snd_pci_quirk cs420x_fixup_tbl[] = {
|
|
SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
|
|
SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
|
|
SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
|
|
SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
|
|
/* this conflicts with too many other models */
|
|
/*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
|
|
|
|
/* codec SSID */
|
|
SND_PCI_QUIRK(0x106b, 0x0600, "iMac 14,1", CS420X_IMAC27_122),
|
|
SND_PCI_QUIRK(0x106b, 0x1c00, "MacBookPro 8,1", CS420X_MBP81),
|
|
SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),
|
|
SND_PCI_QUIRK(0x106b, 0x2800, "MacBookPro 10,1", CS420X_MBP101),
|
|
SND_PCI_QUIRK(0x106b, 0x5600, "MacBookAir 5,2", CS420X_MBP81),
|
|
SND_PCI_QUIRK(0x106b, 0x5b00, "MacBookAir 4,2", CS420X_MBA42),
|
|
SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl mbp53_pincfgs[] = {
|
|
{ 0x09, 0x012b4050 },
|
|
{ 0x0a, 0x90100141 },
|
|
{ 0x0b, 0x90100140 },
|
|
{ 0x0c, 0x018b3020 },
|
|
{ 0x0d, 0x90a00110 },
|
|
{ 0x0e, 0x400000f0 },
|
|
{ 0x0f, 0x01cbe030 },
|
|
{ 0x10, 0x014be060 },
|
|
{ 0x12, 0x400000f0 },
|
|
{ 0x15, 0x400000f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl mbp55_pincfgs[] = {
|
|
{ 0x09, 0x012b4030 },
|
|
{ 0x0a, 0x90100121 },
|
|
{ 0x0b, 0x90100120 },
|
|
{ 0x0c, 0x400000f0 },
|
|
{ 0x0d, 0x90a00110 },
|
|
{ 0x0e, 0x400000f0 },
|
|
{ 0x0f, 0x400000f0 },
|
|
{ 0x10, 0x014be040 },
|
|
{ 0x12, 0x400000f0 },
|
|
{ 0x15, 0x400000f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl imac27_pincfgs[] = {
|
|
{ 0x09, 0x012b4050 },
|
|
{ 0x0a, 0x90100140 },
|
|
{ 0x0b, 0x90100142 },
|
|
{ 0x0c, 0x018b3020 },
|
|
{ 0x0d, 0x90a00110 },
|
|
{ 0x0e, 0x400000f0 },
|
|
{ 0x0f, 0x01cbe030 },
|
|
{ 0x10, 0x014be060 },
|
|
{ 0x12, 0x01ab9070 },
|
|
{ 0x15, 0x400000f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl mbp101_pincfgs[] = {
|
|
{ 0x0d, 0x40ab90f0 },
|
|
{ 0x0e, 0x90a600f0 },
|
|
{ 0x12, 0x50a600f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl mba42_pincfgs[] = {
|
|
{ 0x09, 0x012b4030 }, /* HP */
|
|
{ 0x0a, 0x400000f0 },
|
|
{ 0x0b, 0x90100120 }, /* speaker */
|
|
{ 0x0c, 0x400000f0 },
|
|
{ 0x0d, 0x90a00110 }, /* mic */
|
|
{ 0x0e, 0x400000f0 },
|
|
{ 0x0f, 0x400000f0 },
|
|
{ 0x10, 0x400000f0 },
|
|
{ 0x12, 0x400000f0 },
|
|
{ 0x15, 0x400000f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static const struct hda_pintbl mba6_pincfgs[] = {
|
|
{ 0x10, 0x032120f0 }, /* HP */
|
|
{ 0x11, 0x500000f0 },
|
|
{ 0x12, 0x90100010 }, /* Speaker */
|
|
{ 0x13, 0x500000f0 },
|
|
{ 0x14, 0x500000f0 },
|
|
{ 0x15, 0x770000f0 },
|
|
{ 0x16, 0x770000f0 },
|
|
{ 0x17, 0x430000f0 },
|
|
{ 0x18, 0x43ab9030 }, /* Mic */
|
|
{ 0x19, 0x770000f0 },
|
|
{ 0x1a, 0x770000f0 },
|
|
{ 0x1b, 0x770000f0 },
|
|
{ 0x1c, 0x90a00090 },
|
|
{ 0x1d, 0x500000f0 },
|
|
{ 0x1e, 0x500000f0 },
|
|
{ 0x1f, 0x500000f0 },
|
|
{ 0x20, 0x500000f0 },
|
|
{ 0x21, 0x430000f0 },
|
|
{ 0x22, 0x430000f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
static void cs420x_fixup_gpio_13(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
if (action == HDA_FIXUP_ACT_PRE_PROBE) {
|
|
struct cs_spec *spec = codec->spec;
|
|
spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
|
|
spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
|
|
spec->gpio_mask = spec->gpio_dir =
|
|
spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
|
|
}
|
|
}
|
|
|
|
static void cs420x_fixup_gpio_23(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
if (action == HDA_FIXUP_ACT_PRE_PROBE) {
|
|
struct cs_spec *spec = codec->spec;
|
|
spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
|
|
spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
|
|
spec->gpio_mask = spec->gpio_dir =
|
|
spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
|
|
}
|
|
}
|
|
|
|
static const struct hda_fixup cs420x_fixups[] = {
|
|
[CS420X_MBP53] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = mbp53_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS420X_APPLE,
|
|
},
|
|
[CS420X_MBP55] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = mbp55_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS420X_GPIO_13,
|
|
},
|
|
[CS420X_IMAC27] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = imac27_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS420X_GPIO_13,
|
|
},
|
|
[CS420X_GPIO_13] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs420x_fixup_gpio_13,
|
|
},
|
|
[CS420X_GPIO_23] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs420x_fixup_gpio_23,
|
|
},
|
|
[CS420X_MBP101] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = mbp101_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS420X_GPIO_13,
|
|
},
|
|
[CS420X_MBP81] = {
|
|
.type = HDA_FIXUP_VERBS,
|
|
.v.verbs = (const struct hda_verb[]) {
|
|
/* internal mic ADC2: right only, single ended */
|
|
{0x11, AC_VERB_SET_COEF_INDEX, IDX_ADC_CFG},
|
|
{0x11, AC_VERB_SET_PROC_COEF, 0x102a},
|
|
{}
|
|
},
|
|
.chained = true,
|
|
.chain_id = CS420X_GPIO_13,
|
|
},
|
|
[CS420X_MBA42] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = mba42_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS420X_GPIO_13,
|
|
},
|
|
};
|
|
|
|
static struct cs_spec *cs_alloc_spec(struct hda_codec *codec, int vendor_nid)
|
|
{
|
|
struct cs_spec *spec;
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
if (!spec)
|
|
return NULL;
|
|
codec->spec = spec;
|
|
spec->vendor_nid = vendor_nid;
|
|
codec->power_save_node = 1;
|
|
snd_hda_gen_spec_init(&spec->gen);
|
|
|
|
return spec;
|
|
}
|
|
|
|
static int patch_cs420x(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec;
|
|
int err;
|
|
|
|
spec = cs_alloc_spec(codec, CS420X_VENDOR_NID);
|
|
if (!spec)
|
|
return -ENOMEM;
|
|
|
|
codec->patch_ops = cs_patch_ops;
|
|
spec->gen.automute_hook = cs_automute;
|
|
codec->single_adc_amp = 1;
|
|
|
|
snd_hda_pick_fixup(codec, cs420x_models, cs420x_fixup_tbl,
|
|
cs420x_fixups);
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
|
|
|
|
err = cs_parse_auto_config(codec);
|
|
if (err < 0)
|
|
goto error;
|
|
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
|
|
|
|
return 0;
|
|
|
|
error:
|
|
cs_free(codec);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* CS4208 support:
|
|
* Its layout is no longer compatible with CS4206/CS4207
|
|
*/
|
|
enum {
|
|
CS4208_MAC_AUTO,
|
|
CS4208_MBA6,
|
|
CS4208_MBP11,
|
|
CS4208_MACMINI,
|
|
CS4208_GPIO0,
|
|
};
|
|
|
|
static const struct hda_model_fixup cs4208_models[] = {
|
|
{ .id = CS4208_GPIO0, .name = "gpio0" },
|
|
{ .id = CS4208_MBA6, .name = "mba6" },
|
|
{ .id = CS4208_MBP11, .name = "mbp11" },
|
|
{ .id = CS4208_MACMINI, .name = "macmini" },
|
|
{}
|
|
};
|
|
|
|
static const struct snd_pci_quirk cs4208_fixup_tbl[] = {
|
|
SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS4208_MAC_AUTO),
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* codec SSID matching */
|
|
static const struct snd_pci_quirk cs4208_mac_fixup_tbl[] = {
|
|
SND_PCI_QUIRK(0x106b, 0x5e00, "MacBookPro 11,2", CS4208_MBP11),
|
|
SND_PCI_QUIRK(0x106b, 0x6c00, "MacMini 7,1", CS4208_MACMINI),
|
|
SND_PCI_QUIRK(0x106b, 0x7100, "MacBookAir 6,1", CS4208_MBA6),
|
|
SND_PCI_QUIRK(0x106b, 0x7200, "MacBookAir 6,2", CS4208_MBA6),
|
|
SND_PCI_QUIRK(0x106b, 0x7b00, "MacBookPro 12,1", CS4208_MBP11),
|
|
{} /* terminator */
|
|
};
|
|
|
|
static void cs4208_fixup_gpio0(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
if (action == HDA_FIXUP_ACT_PRE_PROBE) {
|
|
struct cs_spec *spec = codec->spec;
|
|
spec->gpio_eapd_hp = 0;
|
|
spec->gpio_eapd_speaker = 1;
|
|
spec->gpio_mask = spec->gpio_dir =
|
|
spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
|
|
}
|
|
}
|
|
|
|
static const struct hda_fixup cs4208_fixups[];
|
|
|
|
/* remap the fixup from codec SSID and apply it */
|
|
static void cs4208_fixup_mac(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
if (action != HDA_FIXUP_ACT_PRE_PROBE)
|
|
return;
|
|
|
|
codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
|
|
snd_hda_pick_fixup(codec, NULL, cs4208_mac_fixup_tbl, cs4208_fixups);
|
|
if (codec->fixup_id == HDA_FIXUP_ID_NOT_SET)
|
|
codec->fixup_id = CS4208_GPIO0; /* default fixup */
|
|
snd_hda_apply_fixup(codec, action);
|
|
}
|
|
|
|
/* MacMini 7,1 has the inverted jack detection */
|
|
static void cs4208_fixup_macmini(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
static const struct hda_pintbl pincfgs[] = {
|
|
{ 0x18, 0x00ab9150 }, /* mic (audio-in) jack: disable detect */
|
|
{ 0x21, 0x004be140 }, /* SPDIF: disable detect */
|
|
{ }
|
|
};
|
|
|
|
if (action == HDA_FIXUP_ACT_PRE_PROBE) {
|
|
/* HP pin (0x10) has an inverted detection */
|
|
codec->inv_jack_detect = 1;
|
|
/* disable the bogus Mic and SPDIF jack detections */
|
|
snd_hda_apply_pincfgs(codec, pincfgs);
|
|
}
|
|
}
|
|
|
|
static int cs4208_spdif_sw_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
struct cs_spec *spec = codec->spec;
|
|
hda_nid_t pin = spec->gen.autocfg.dig_out_pins[0];
|
|
int pinctl = ucontrol->value.integer.value[0] ? PIN_OUT : 0;
|
|
|
|
snd_hda_set_pin_ctl_cache(codec, pin, pinctl);
|
|
return spec->spdif_sw_put(kcontrol, ucontrol);
|
|
}
|
|
|
|
/* hook the SPDIF switch */
|
|
static void cs4208_fixup_spdif_switch(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
if (action == HDA_FIXUP_ACT_BUILD) {
|
|
struct cs_spec *spec = codec->spec;
|
|
struct snd_kcontrol *kctl;
|
|
|
|
if (!spec->gen.autocfg.dig_out_pins[0])
|
|
return;
|
|
kctl = snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch");
|
|
if (!kctl)
|
|
return;
|
|
spec->spdif_sw_put = kctl->put;
|
|
kctl->put = cs4208_spdif_sw_put;
|
|
}
|
|
}
|
|
|
|
static const struct hda_fixup cs4208_fixups[] = {
|
|
[CS4208_MBA6] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = mba6_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS4208_GPIO0,
|
|
},
|
|
[CS4208_MBP11] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs4208_fixup_spdif_switch,
|
|
.chained = true,
|
|
.chain_id = CS4208_GPIO0,
|
|
},
|
|
[CS4208_MACMINI] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs4208_fixup_macmini,
|
|
.chained = true,
|
|
.chain_id = CS4208_GPIO0,
|
|
},
|
|
[CS4208_GPIO0] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs4208_fixup_gpio0,
|
|
},
|
|
[CS4208_MAC_AUTO] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs4208_fixup_mac,
|
|
},
|
|
};
|
|
|
|
/* correct the 0dB offset of input pins */
|
|
static void cs4208_fix_amp_caps(struct hda_codec *codec, hda_nid_t adc)
|
|
{
|
|
unsigned int caps;
|
|
|
|
caps = query_amp_caps(codec, adc, HDA_INPUT);
|
|
caps &= ~(AC_AMPCAP_OFFSET);
|
|
caps |= 0x02;
|
|
snd_hda_override_amp_caps(codec, adc, HDA_INPUT, caps);
|
|
}
|
|
|
|
static int patch_cs4208(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec;
|
|
int err;
|
|
|
|
spec = cs_alloc_spec(codec, CS4208_VENDOR_NID);
|
|
if (!spec)
|
|
return -ENOMEM;
|
|
|
|
codec->patch_ops = cs_patch_ops;
|
|
spec->gen.automute_hook = cs_automute;
|
|
/* exclude NID 0x10 (HP) from output volumes due to different steps */
|
|
spec->gen.out_vol_mask = 1ULL << 0x10;
|
|
|
|
snd_hda_pick_fixup(codec, cs4208_models, cs4208_fixup_tbl,
|
|
cs4208_fixups);
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
|
|
|
|
snd_hda_override_wcaps(codec, 0x18,
|
|
get_wcaps(codec, 0x18) | AC_WCAP_STEREO);
|
|
cs4208_fix_amp_caps(codec, 0x18);
|
|
cs4208_fix_amp_caps(codec, 0x1b);
|
|
cs4208_fix_amp_caps(codec, 0x1c);
|
|
|
|
err = cs_parse_auto_config(codec);
|
|
if (err < 0)
|
|
goto error;
|
|
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
|
|
|
|
return 0;
|
|
|
|
error:
|
|
cs_free(codec);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Cirrus Logic CS4210
|
|
*
|
|
* 1 DAC => HP(sense) / Speakers,
|
|
* 1 ADC <= LineIn(sense) / MicIn / DMicIn,
|
|
* 1 SPDIF OUT => SPDIF Trasmitter(sense)
|
|
*/
|
|
|
|
/* CS4210 board names */
|
|
static const struct hda_model_fixup cs421x_models[] = {
|
|
{ .id = CS421X_CDB4210, .name = "cdb4210" },
|
|
{ .id = CS421X_STUMPY, .name = "stumpy" },
|
|
{}
|
|
};
|
|
|
|
static const struct snd_pci_quirk cs421x_fixup_tbl[] = {
|
|
/* Test Intel board + CDB2410 */
|
|
SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* CS4210 board pinconfigs */
|
|
/* Default CS4210 (CDB4210)*/
|
|
static const struct hda_pintbl cdb4210_pincfgs[] = {
|
|
{ 0x05, 0x0321401f },
|
|
{ 0x06, 0x90170010 },
|
|
{ 0x07, 0x03813031 },
|
|
{ 0x08, 0xb7a70037 },
|
|
{ 0x09, 0xb7a6003e },
|
|
{ 0x0a, 0x034510f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* Stumpy ChromeBox */
|
|
static const struct hda_pintbl stumpy_pincfgs[] = {
|
|
{ 0x05, 0x022120f0 },
|
|
{ 0x06, 0x901700f0 },
|
|
{ 0x07, 0x02a120f0 },
|
|
{ 0x08, 0x77a70037 },
|
|
{ 0x09, 0x77a6003e },
|
|
{ 0x0a, 0x434510f0 },
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* Setup GPIO/SENSE for each board (if used) */
|
|
static void cs421x_fixup_sense_b(struct hda_codec *codec,
|
|
const struct hda_fixup *fix, int action)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
if (action == HDA_FIXUP_ACT_PRE_PROBE)
|
|
spec->sense_b = 1;
|
|
}
|
|
|
|
static const struct hda_fixup cs421x_fixups[] = {
|
|
[CS421X_CDB4210] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = cdb4210_pincfgs,
|
|
.chained = true,
|
|
.chain_id = CS421X_SENSE_B,
|
|
},
|
|
[CS421X_SENSE_B] = {
|
|
.type = HDA_FIXUP_FUNC,
|
|
.v.func = cs421x_fixup_sense_b,
|
|
},
|
|
[CS421X_STUMPY] = {
|
|
.type = HDA_FIXUP_PINS,
|
|
.v.pins = stumpy_pincfgs,
|
|
},
|
|
};
|
|
|
|
static const struct hda_verb cs421x_coef_init_verbs[] = {
|
|
{0x0B, AC_VERB_SET_PROC_STATE, 1},
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
|
|
/*
|
|
Disable Coefficient Index Auto-Increment(DAI)=1,
|
|
PDREF=0
|
|
*/
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
|
|
/* ADC SZCMode = Digital Soft Ramp */
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
|
|
{0x0B, AC_VERB_SET_PROC_COEF,
|
|
(0x0002 /* DAC SZCMode = Digital Soft Ramp */
|
|
| 0x0004 /* Mute DAC on FIFO error */
|
|
| 0x0008 /* Enable DAC High Pass Filter */
|
|
)},
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* Errata: CS4210 rev A1 Silicon
|
|
*
|
|
* http://www.cirrus.com/en/pubs/errata/
|
|
*
|
|
* Description:
|
|
* 1. Performance degredation is present in the ADC.
|
|
* 2. Speaker output is not completely muted upon HP detect.
|
|
* 3. Noise is present when clipping occurs on the amplified
|
|
* speaker outputs.
|
|
*
|
|
* Workaround:
|
|
* The following verb sequence written to the registers during
|
|
* initialization will correct the issues listed above.
|
|
*/
|
|
|
|
static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
|
|
{0x0B, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
|
|
|
|
{0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
|
|
{0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
|
|
|
|
{} /* terminator */
|
|
};
|
|
|
|
/* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
|
|
static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
|
|
|
|
static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 3;
|
|
return 0;
|
|
}
|
|
|
|
static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
|
|
return 0;
|
|
}
|
|
|
|
static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int vol = ucontrol->value.integer.value[0];
|
|
unsigned int coef =
|
|
cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
|
|
unsigned int original_coef = coef;
|
|
|
|
coef &= ~0x0003;
|
|
coef |= (vol & 0x0003);
|
|
if (original_coef == coef)
|
|
return 0;
|
|
else {
|
|
cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static const struct snd_kcontrol_new cs421x_speaker_boost_ctl = {
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ),
|
|
.name = "Speaker Boost Playback Volume",
|
|
.info = cs421x_boost_vol_info,
|
|
.get = cs421x_boost_vol_get,
|
|
.put = cs421x_boost_vol_put,
|
|
.tlv = { .p = cs421x_speaker_boost_db_scale },
|
|
};
|
|
|
|
static void cs4210_pinmux_init(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
unsigned int def_conf, coef;
|
|
|
|
/* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
|
|
coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
|
|
|
|
if (spec->gpio_mask)
|
|
coef |= 0x0008; /* B1,B2 are GPIOs */
|
|
else
|
|
coef &= ~0x0008;
|
|
|
|
if (spec->sense_b)
|
|
coef |= 0x0010; /* B2 is SENSE_B, not inverted */
|
|
else
|
|
coef &= ~0x0010;
|
|
|
|
cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
|
|
|
|
if ((spec->gpio_mask || spec->sense_b) &&
|
|
is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
|
|
|
|
/*
|
|
GPIO or SENSE_B forced - disconnect the DMIC pin.
|
|
*/
|
|
def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
|
|
def_conf &= ~AC_DEFCFG_PORT_CONN;
|
|
def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
|
|
snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
|
|
}
|
|
}
|
|
|
|
static void cs4210_spdif_automute(struct hda_codec *codec,
|
|
struct hda_jack_callback *tbl)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
bool spdif_present = false;
|
|
hda_nid_t spdif_pin = spec->gen.autocfg.dig_out_pins[0];
|
|
|
|
/* detect on spdif is specific to CS4210 */
|
|
if (!spec->spdif_detect ||
|
|
spec->vendor_nid != CS4210_VENDOR_NID)
|
|
return;
|
|
|
|
spdif_present = snd_hda_jack_detect(codec, spdif_pin);
|
|
if (spdif_present == spec->spdif_present)
|
|
return;
|
|
|
|
spec->spdif_present = spdif_present;
|
|
/* SPDIF TX on/off */
|
|
snd_hda_set_pin_ctl(codec, spdif_pin, spdif_present ? PIN_OUT : 0);
|
|
|
|
cs_automute(codec);
|
|
}
|
|
|
|
static void parse_cs421x_digital(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
struct auto_pin_cfg *cfg = &spec->gen.autocfg;
|
|
int i;
|
|
|
|
for (i = 0; i < cfg->dig_outs; i++) {
|
|
hda_nid_t nid = cfg->dig_out_pins[i];
|
|
if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
|
|
spec->spdif_detect = 1;
|
|
snd_hda_jack_detect_enable_callback(codec, nid,
|
|
cs4210_spdif_automute);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int cs421x_init(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
|
|
if (spec->vendor_nid == CS4210_VENDOR_NID) {
|
|
snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
|
|
snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
|
|
cs4210_pinmux_init(codec);
|
|
}
|
|
|
|
snd_hda_gen_init(codec);
|
|
|
|
if (spec->gpio_mask) {
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
|
|
spec->gpio_mask);
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
|
|
spec->gpio_dir);
|
|
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
|
|
spec->gpio_data);
|
|
}
|
|
|
|
init_input_coef(codec);
|
|
|
|
cs4210_spdif_automute(codec, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
|
|
{
|
|
unsigned int caps;
|
|
|
|
/* set the upper-limit for mixer amp to 0dB */
|
|
caps = query_amp_caps(codec, dac, HDA_OUTPUT);
|
|
caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
|
|
caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
|
|
<< AC_AMPCAP_NUM_STEPS_SHIFT;
|
|
snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
|
|
}
|
|
|
|
static int cs421x_parse_auto_config(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
hda_nid_t dac = CS4210_DAC_NID;
|
|
int err;
|
|
|
|
fix_volume_caps(codec, dac);
|
|
|
|
err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL, 0);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
parse_cs421x_digital(codec);
|
|
|
|
if (spec->gen.autocfg.speaker_outs &&
|
|
spec->vendor_nid == CS4210_VENDOR_NID) {
|
|
if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
|
|
&cs421x_speaker_boost_ctl))
|
|
return -ENOMEM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
/*
|
|
Manage PDREF, when transitioning to D3hot
|
|
(DAC,ADC) -> D3, PDREF=1, AFG->D3
|
|
*/
|
|
static int cs421x_suspend(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec = codec->spec;
|
|
unsigned int coef;
|
|
|
|
snd_hda_shutup_pins(codec);
|
|
|
|
snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
|
|
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
|
|
snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
|
|
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
|
|
|
|
if (spec->vendor_nid == CS4210_VENDOR_NID) {
|
|
coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
|
|
coef |= 0x0004; /* PDREF */
|
|
cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static const struct hda_codec_ops cs421x_patch_ops = {
|
|
.build_controls = snd_hda_gen_build_controls,
|
|
.build_pcms = snd_hda_gen_build_pcms,
|
|
.init = cs421x_init,
|
|
.free = cs_free,
|
|
.unsol_event = snd_hda_jack_unsol_event,
|
|
#ifdef CONFIG_PM
|
|
.suspend = cs421x_suspend,
|
|
#endif
|
|
};
|
|
|
|
static int patch_cs4210(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec;
|
|
int err;
|
|
|
|
spec = cs_alloc_spec(codec, CS4210_VENDOR_NID);
|
|
if (!spec)
|
|
return -ENOMEM;
|
|
|
|
codec->patch_ops = cs421x_patch_ops;
|
|
spec->gen.automute_hook = cs_automute;
|
|
|
|
snd_hda_pick_fixup(codec, cs421x_models, cs421x_fixup_tbl,
|
|
cs421x_fixups);
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
|
|
|
|
/*
|
|
Update the GPIO/DMIC/SENSE_B pinmux before the configuration
|
|
is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
|
|
is disabled.
|
|
*/
|
|
cs4210_pinmux_init(codec);
|
|
|
|
err = cs421x_parse_auto_config(codec);
|
|
if (err < 0)
|
|
goto error;
|
|
|
|
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
|
|
|
|
return 0;
|
|
|
|
error:
|
|
cs_free(codec);
|
|
return err;
|
|
}
|
|
|
|
static int patch_cs4213(struct hda_codec *codec)
|
|
{
|
|
struct cs_spec *spec;
|
|
int err;
|
|
|
|
spec = cs_alloc_spec(codec, CS4213_VENDOR_NID);
|
|
if (!spec)
|
|
return -ENOMEM;
|
|
|
|
codec->patch_ops = cs421x_patch_ops;
|
|
|
|
err = cs421x_parse_auto_config(codec);
|
|
if (err < 0)
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
error:
|
|
cs_free(codec);
|
|
return err;
|
|
}
|
|
|
|
|
|
/*
|
|
* patch entries
|
|
*/
|
|
static const struct hda_device_id snd_hda_id_cirrus[] = {
|
|
HDA_CODEC_ENTRY(0x10134206, "CS4206", patch_cs420x),
|
|
HDA_CODEC_ENTRY(0x10134207, "CS4207", patch_cs420x),
|
|
HDA_CODEC_ENTRY(0x10134208, "CS4208", patch_cs4208),
|
|
HDA_CODEC_ENTRY(0x10134210, "CS4210", patch_cs4210),
|
|
HDA_CODEC_ENTRY(0x10134213, "CS4213", patch_cs4213),
|
|
{} /* terminator */
|
|
};
|
|
MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_cirrus);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
|
|
|
|
static struct hda_codec_driver cirrus_driver = {
|
|
.id = snd_hda_id_cirrus,
|
|
};
|
|
|
|
module_hda_codec_driver(cirrus_driver);
|