2019-05-27 00:55:01 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2009-03-10 04:55:15 -06:00
|
|
|
/*
|
|
|
|
* wm8400.c -- WM8400 ALSA Soc Audio driver
|
|
|
|
*
|
2012-05-23 05:39:07 -06:00
|
|
|
* Copyright 2008-11 Wolfson Microelectronics PLC.
|
2009-03-10 04:55:15 -06:00
|
|
|
* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/kernel.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-03-10 04:55:15 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <linux/mfd/wm8400-audio.h>
|
|
|
|
#include <linux/mfd/wm8400-private.h>
|
2011-02-17 20:07:27 -07:00
|
|
|
#include <linux/mfd/core.h>
|
2009-03-10 04:55:15 -06:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
|
|
|
#include <sound/initval.h>
|
|
|
|
#include <sound/tlv.h>
|
|
|
|
|
|
|
|
#include "wm8400.h"
|
|
|
|
|
|
|
|
static struct regulator_bulk_data power[] = {
|
|
|
|
{
|
|
|
|
.supply = "I2S1VDD",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.supply = "I2S2VDD",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.supply = "DCVDD",
|
|
|
|
},
|
2009-03-18 09:19:48 -06:00
|
|
|
{
|
|
|
|
.supply = "AVDD",
|
|
|
|
},
|
2009-03-10 04:55:15 -06:00
|
|
|
{
|
|
|
|
.supply = "FLLVDD",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.supply = "HPVDD",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.supply = "SPKVDD",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* codec private data */
|
|
|
|
struct wm8400_priv {
|
|
|
|
struct wm8400 *wm8400;
|
|
|
|
u16 fake_register;
|
|
|
|
unsigned int sysclk;
|
|
|
|
unsigned int pcmclk;
|
2009-03-18 12:28:01 -06:00
|
|
|
int fll_in, fll_out;
|
2009-03-10 04:55:15 -06:00
|
|
|
};
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
static void wm8400_component_reset(struct snd_soc_component *component)
|
2009-03-10 04:55:15 -06:00
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
wm8400_reset_codec_reg_cache(wm8400->wm8400);
|
|
|
|
}
|
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(rec_mix_tlv, -1500, 600, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(in_pga_tlv, -1650, 3000, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(out_mix_tlv, -2100, 0, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(out_pga_tlv, -7300, 600, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(out_omix_tlv, -600, 0, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(out_dac_tlv, -7163, 0, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(in_adc_tlv, -7163, 1763, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2010-05-25 11:48:31 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(out_sidetone_tlv, -3600, 0, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static int wm8400_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
|
2009-03-10 04:55:15 -06:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
int reg = mc->reg;
|
|
|
|
int ret;
|
|
|
|
u16 val;
|
|
|
|
|
|
|
|
ret = snd_soc_put_volsw(kcontrol, ucontrol);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* now hit the volume update bits (always bit 8) */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, reg);
|
|
|
|
return snd_soc_component_write(component, reg, val | 0x0100);
|
2009-03-10 04:55:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define WM8400_OUTPGA_SINGLE_R_TLV(xname, reg, shift, max, invert, tlv_array) \
|
2013-06-19 11:33:54 -06:00
|
|
|
SOC_SINGLE_EXT_TLV(xname, reg, shift, max, invert, \
|
|
|
|
snd_soc_get_volsw, wm8400_outpga_put_volsw_vu, tlv_array)
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
|
|
|
|
static const char *wm8400_digital_sidetone[] =
|
|
|
|
{"None", "Left ADC", "Right ADC", "Reserved"};
|
|
|
|
|
2014-02-18 01:34:44 -07:00
|
|
|
static SOC_ENUM_SINGLE_DECL(wm8400_left_digital_sidetone_enum,
|
|
|
|
WM8400_DIGITAL_SIDE_TONE,
|
|
|
|
WM8400_ADC_TO_DACL_SHIFT,
|
|
|
|
wm8400_digital_sidetone);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2014-02-18 01:34:44 -07:00
|
|
|
static SOC_ENUM_SINGLE_DECL(wm8400_right_digital_sidetone_enum,
|
|
|
|
WM8400_DIGITAL_SIDE_TONE,
|
|
|
|
WM8400_ADC_TO_DACR_SHIFT,
|
|
|
|
wm8400_digital_sidetone);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static const char *wm8400_adcmode[] =
|
|
|
|
{"Hi-fi mode", "Voice mode 1", "Voice mode 2", "Voice mode 3"};
|
|
|
|
|
2014-02-18 01:34:44 -07:00
|
|
|
static SOC_ENUM_SINGLE_DECL(wm8400_right_adcmode_enum,
|
|
|
|
WM8400_ADC_CTRL,
|
|
|
|
WM8400_ADC_HPF_CUT_SHIFT,
|
|
|
|
wm8400_adcmode);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static const struct snd_kcontrol_new wm8400_snd_controls[] = {
|
|
|
|
/* INMIXL */
|
|
|
|
SOC_SINGLE("LIN12 PGA Boost", WM8400_INPUT_MIXER3, WM8400_L12MNBST_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
SOC_SINGLE("LIN34 PGA Boost", WM8400_INPUT_MIXER3, WM8400_L34MNBST_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
/* INMIXR */
|
|
|
|
SOC_SINGLE("RIN12 PGA Boost", WM8400_INPUT_MIXER3, WM8400_R12MNBST_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
SOC_SINGLE("RIN34 PGA Boost", WM8400_INPUT_MIXER3, WM8400_R34MNBST_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
|
|
|
|
/* LOMIX */
|
|
|
|
SOC_SINGLE_TLV("LOMIX LIN3 Bypass Volume", WM8400_OUTPUT_MIXER3,
|
|
|
|
WM8400_LLI3LOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("LOMIX RIN12 PGA Bypass Volume", WM8400_OUTPUT_MIXER3,
|
|
|
|
WM8400_LR12LOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("LOMIX LIN12 PGA Bypass Volume", WM8400_OUTPUT_MIXER3,
|
|
|
|
WM8400_LL12LOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("LOMIX RIN3 Bypass Volume", WM8400_OUTPUT_MIXER5,
|
|
|
|
WM8400_LRI3LOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("LOMIX AINRMUX Bypass Volume", WM8400_OUTPUT_MIXER5,
|
|
|
|
WM8400_LRBLOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("LOMIX AINLMUX Bypass Volume", WM8400_OUTPUT_MIXER5,
|
|
|
|
WM8400_LRBLOVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
|
|
|
|
/* ROMIX */
|
|
|
|
SOC_SINGLE_TLV("ROMIX RIN3 Bypass Volume", WM8400_OUTPUT_MIXER4,
|
|
|
|
WM8400_RRI3ROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("ROMIX LIN12 PGA Bypass Volume", WM8400_OUTPUT_MIXER4,
|
|
|
|
WM8400_RL12ROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("ROMIX RIN12 PGA Bypass Volume", WM8400_OUTPUT_MIXER4,
|
|
|
|
WM8400_RR12ROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("ROMIX LIN3 Bypass Volume", WM8400_OUTPUT_MIXER6,
|
|
|
|
WM8400_RLI3ROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("ROMIX AINLMUX Bypass Volume", WM8400_OUTPUT_MIXER6,
|
|
|
|
WM8400_RLBROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
SOC_SINGLE_TLV("ROMIX AINRMUX Bypass Volume", WM8400_OUTPUT_MIXER6,
|
|
|
|
WM8400_RRBROVOL_SHIFT, 7, 0, out_mix_tlv),
|
|
|
|
|
|
|
|
/* LOUT */
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("LOUT Volume", WM8400_LEFT_OUTPUT_VOLUME,
|
|
|
|
WM8400_LOUTVOL_SHIFT, WM8400_LOUTVOL_MASK, 0, out_pga_tlv),
|
|
|
|
SOC_SINGLE("LOUT ZC", WM8400_LEFT_OUTPUT_VOLUME, WM8400_LOZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
/* ROUT */
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("ROUT Volume", WM8400_RIGHT_OUTPUT_VOLUME,
|
|
|
|
WM8400_ROUTVOL_SHIFT, WM8400_ROUTVOL_MASK, 0, out_pga_tlv),
|
|
|
|
SOC_SINGLE("ROUT ZC", WM8400_RIGHT_OUTPUT_VOLUME, WM8400_ROZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
/* LOPGA */
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("LOPGA Volume", WM8400_LEFT_OPGA_VOLUME,
|
|
|
|
WM8400_LOPGAVOL_SHIFT, WM8400_LOPGAVOL_MASK, 0, out_pga_tlv),
|
|
|
|
SOC_SINGLE("LOPGA ZC Switch", WM8400_LEFT_OPGA_VOLUME,
|
|
|
|
WM8400_LOPGAZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
/* ROPGA */
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("ROPGA Volume", WM8400_RIGHT_OPGA_VOLUME,
|
|
|
|
WM8400_ROPGAVOL_SHIFT, WM8400_ROPGAVOL_MASK, 0, out_pga_tlv),
|
|
|
|
SOC_SINGLE("ROPGA ZC Switch", WM8400_RIGHT_OPGA_VOLUME,
|
|
|
|
WM8400_ROPGAZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("LON Mute Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_LONMUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("LOP Mute Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_LOPMUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("LOP Attenuation Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_LOATTN_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("RON Mute Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_RONMUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("ROP Mute Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_ROPMUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("ROP Attenuation Switch", WM8400_LINE_OUTPUTS_VOLUME,
|
|
|
|
WM8400_ROATTN_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("OUT3 Mute Switch", WM8400_OUT3_4_VOLUME,
|
|
|
|
WM8400_OUT3MUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("OUT3 Attenuation Switch", WM8400_OUT3_4_VOLUME,
|
|
|
|
WM8400_OUT3ATTN_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("OUT4 Mute Switch", WM8400_OUT3_4_VOLUME,
|
|
|
|
WM8400_OUT4MUTE_SHIFT, 1, 0),
|
|
|
|
SOC_SINGLE("OUT4 Attenuation Switch", WM8400_OUT3_4_VOLUME,
|
|
|
|
WM8400_OUT4ATTN_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("Speaker Mode Switch", WM8400_CLASSD1,
|
|
|
|
WM8400_CDMODE_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("Speaker Output Attenuation Volume", WM8400_SPEAKER_VOLUME,
|
|
|
|
WM8400_SPKATTN_SHIFT, WM8400_SPKATTN_MASK, 0),
|
|
|
|
SOC_SINGLE("Speaker DC Boost Volume", WM8400_CLASSD3,
|
|
|
|
WM8400_DCGAIN_SHIFT, 6, 0),
|
|
|
|
SOC_SINGLE("Speaker AC Boost Volume", WM8400_CLASSD3,
|
|
|
|
WM8400_ACGAIN_SHIFT, 6, 0),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("Left DAC Digital Volume",
|
|
|
|
WM8400_LEFT_DAC_DIGITAL_VOLUME, WM8400_DACL_VOL_SHIFT,
|
|
|
|
127, 0, out_dac_tlv),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("Right DAC Digital Volume",
|
|
|
|
WM8400_RIGHT_DAC_DIGITAL_VOLUME, WM8400_DACR_VOL_SHIFT,
|
|
|
|
127, 0, out_dac_tlv),
|
|
|
|
|
|
|
|
SOC_ENUM("Left Digital Sidetone", wm8400_left_digital_sidetone_enum),
|
|
|
|
SOC_ENUM("Right Digital Sidetone", wm8400_right_digital_sidetone_enum),
|
|
|
|
|
|
|
|
SOC_SINGLE_TLV("Left Digital Sidetone Volume", WM8400_DIGITAL_SIDE_TONE,
|
|
|
|
WM8400_ADCL_DAC_SVOL_SHIFT, 15, 0, out_sidetone_tlv),
|
|
|
|
SOC_SINGLE_TLV("Right Digital Sidetone Volume", WM8400_DIGITAL_SIDE_TONE,
|
|
|
|
WM8400_ADCR_DAC_SVOL_SHIFT, 15, 0, out_sidetone_tlv),
|
|
|
|
|
|
|
|
SOC_SINGLE("ADC Digital High Pass Filter Switch", WM8400_ADC_CTRL,
|
|
|
|
WM8400_ADC_HPF_ENA_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_ENUM("ADC HPF Mode", wm8400_right_adcmode_enum),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("Left ADC Digital Volume",
|
|
|
|
WM8400_LEFT_ADC_DIGITAL_VOLUME,
|
|
|
|
WM8400_ADCL_VOL_SHIFT,
|
|
|
|
WM8400_ADCL_VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_adc_tlv),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("Right ADC Digital Volume",
|
|
|
|
WM8400_RIGHT_ADC_DIGITAL_VOLUME,
|
|
|
|
WM8400_ADCR_VOL_SHIFT,
|
|
|
|
WM8400_ADCR_VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_adc_tlv),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("LIN12 Volume",
|
|
|
|
WM8400_LEFT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_LIN12VOL_SHIFT,
|
|
|
|
WM8400_LIN12VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_pga_tlv),
|
|
|
|
|
|
|
|
SOC_SINGLE("LIN12 ZC Switch", WM8400_LEFT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_LI12ZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("LIN12 Mute Switch", WM8400_LEFT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_LI12MUTE_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("LIN34 Volume",
|
|
|
|
WM8400_LEFT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_LIN34VOL_SHIFT,
|
|
|
|
WM8400_LIN34VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_pga_tlv),
|
|
|
|
|
|
|
|
SOC_SINGLE("LIN34 ZC Switch", WM8400_LEFT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_LI34ZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("LIN34 Mute Switch", WM8400_LEFT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_LI34MUTE_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("RIN12 Volume",
|
|
|
|
WM8400_RIGHT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_RIN12VOL_SHIFT,
|
|
|
|
WM8400_RIN12VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_pga_tlv),
|
|
|
|
|
|
|
|
SOC_SINGLE("RIN12 ZC Switch", WM8400_RIGHT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_RI12ZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("RIN12 Mute Switch", WM8400_RIGHT_LINE_INPUT_1_2_VOLUME,
|
|
|
|
WM8400_RI12MUTE_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
WM8400_OUTPGA_SINGLE_R_TLV("RIN34 Volume",
|
|
|
|
WM8400_RIGHT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_RIN34VOL_SHIFT,
|
|
|
|
WM8400_RIN34VOL_MASK,
|
|
|
|
0,
|
|
|
|
in_pga_tlv),
|
|
|
|
|
|
|
|
SOC_SINGLE("RIN34 ZC Switch", WM8400_RIGHT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_RI34ZC_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE("RIN34 Mute Switch", WM8400_RIGHT_LINE_INPUT_3_4_VOLUME,
|
|
|
|
WM8400_RI34MUTE_SHIFT, 1, 0),
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* _DAPM_ Controls
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int outmixer_event (struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol * kcontrol, int event)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
|
2009-03-10 04:55:15 -06:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
u32 reg_shift = mc->shift;
|
|
|
|
int ret = 0;
|
|
|
|
u16 reg;
|
|
|
|
|
|
|
|
switch (reg_shift) {
|
|
|
|
case WM8400_SPEAKER_MIXER | (WM8400_LDSPK << 8) :
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_OUTPUT_MIXER1);
|
2009-03-10 04:55:15 -06:00
|
|
|
if (reg & WM8400_LDLO) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Cannot set as Output Mixer 1 LDLO Set\n");
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WM8400_SPEAKER_MIXER | (WM8400_RDSPK << 8):
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_OUTPUT_MIXER2);
|
2009-03-10 04:55:15 -06:00
|
|
|
if (reg & WM8400_RDRO) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Cannot set as Output Mixer 2 RDRO Set\n");
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WM8400_OUTPUT_MIXER1 | (WM8400_LDLO << 8):
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_SPEAKER_MIXER);
|
2009-03-10 04:55:15 -06:00
|
|
|
if (reg & WM8400_LDSPK) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Cannot set as Speaker Mixer LDSPK Set\n");
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WM8400_OUTPUT_MIXER2 | (WM8400_RDRO << 8):
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_SPEAKER_MIXER);
|
2009-03-10 04:55:15 -06:00
|
|
|
if (reg & WM8400_RDSPK) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Cannot set as Speaker Mixer RDSPK Set\n");
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* INMIX dB values */
|
2015-08-02 09:19:59 -06:00
|
|
|
static const DECLARE_TLV_DB_SCALE(in_mix_tlv, -1200, 600, 0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Left In PGA Connections */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_lin12_pga_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("LIN1 Switch", WM8400_INPUT_MIXER2, WM8400_LMN1_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LIN2 Switch", WM8400_INPUT_MIXER2, WM8400_LMP2_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_lin34_pga_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("LIN3 Switch", WM8400_INPUT_MIXER2, WM8400_LMN3_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LIN4 Switch", WM8400_INPUT_MIXER2, WM8400_LMP4_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Right In PGA Connections */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_rin12_pga_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("RIN1 Switch", WM8400_INPUT_MIXER2, WM8400_RMN1_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("RIN2 Switch", WM8400_INPUT_MIXER2, WM8400_RMP2_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_rin34_pga_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("RIN3 Switch", WM8400_INPUT_MIXER2, WM8400_RMN3_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("RIN4 Switch", WM8400_INPUT_MIXER2, WM8400_RMP4_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* INMIXL */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_inmixl_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE_TLV("Record Left Volume", WM8400_INPUT_MIXER3,
|
|
|
|
WM8400_LDBVOL_SHIFT, WM8400_LDBVOL_MASK, 0, in_mix_tlv),
|
|
|
|
SOC_DAPM_SINGLE_TLV("LIN2 Volume", WM8400_INPUT_MIXER5, WM8400_LI2BVOL_SHIFT,
|
|
|
|
7, 0, in_mix_tlv),
|
|
|
|
SOC_DAPM_SINGLE("LINPGA12 Switch", WM8400_INPUT_MIXER3, WM8400_L12MNB_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LINPGA34 Switch", WM8400_INPUT_MIXER3, WM8400_L34MNB_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* INMIXR */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_inmixr_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE_TLV("Record Right Volume", WM8400_INPUT_MIXER4,
|
|
|
|
WM8400_RDBVOL_SHIFT, WM8400_RDBVOL_MASK, 0, in_mix_tlv),
|
|
|
|
SOC_DAPM_SINGLE_TLV("RIN2 Volume", WM8400_INPUT_MIXER6, WM8400_RI2BVOL_SHIFT,
|
|
|
|
7, 0, in_mix_tlv),
|
|
|
|
SOC_DAPM_SINGLE("RINPGA12 Switch", WM8400_INPUT_MIXER3, WM8400_L12MNB_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
SOC_DAPM_SINGLE("RINPGA34 Switch", WM8400_INPUT_MIXER3, WM8400_L34MNB_SHIFT,
|
|
|
|
1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* AINLMUX */
|
|
|
|
static const char *wm8400_ainlmux[] =
|
|
|
|
{"INMIXL Mix", "RXVOICE Mix", "DIFFINL Mix"};
|
|
|
|
|
2014-02-18 01:34:44 -07:00
|
|
|
static SOC_ENUM_SINGLE_DECL(wm8400_ainlmux_enum,
|
|
|
|
WM8400_INPUT_MIXER1,
|
|
|
|
WM8400_AINLMODE_SHIFT,
|
|
|
|
wm8400_ainlmux);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_ainlmux_controls =
|
|
|
|
SOC_DAPM_ENUM("Route", wm8400_ainlmux_enum);
|
|
|
|
|
|
|
|
/* DIFFINL */
|
|
|
|
|
|
|
|
/* AINRMUX */
|
|
|
|
static const char *wm8400_ainrmux[] =
|
|
|
|
{"INMIXR Mix", "RXVOICE Mix", "DIFFINR Mix"};
|
|
|
|
|
2014-02-18 01:34:44 -07:00
|
|
|
static SOC_ENUM_SINGLE_DECL(wm8400_ainrmux_enum,
|
|
|
|
WM8400_INPUT_MIXER1,
|
|
|
|
WM8400_AINRMODE_SHIFT,
|
|
|
|
wm8400_ainrmux);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_ainrmux_controls =
|
|
|
|
SOC_DAPM_ENUM("Route", wm8400_ainrmux_enum);
|
|
|
|
|
|
|
|
/* RXVOICE */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_rxvoice_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE_TLV("LIN4/RXN", WM8400_INPUT_MIXER5, WM8400_LR4BVOL_SHIFT,
|
|
|
|
WM8400_LR4BVOL_MASK, 0, in_mix_tlv),
|
|
|
|
SOC_DAPM_SINGLE_TLV("RIN4/RXP", WM8400_INPUT_MIXER6, WM8400_RL4BVOL_SHIFT,
|
|
|
|
WM8400_RL4BVOL_MASK, 0, in_mix_tlv),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* LOMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_lomix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("LOMIX Right ADC Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LRBLO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX Left ADC Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LLBLO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX RIN3 Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LRI3LO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX LIN3 Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LLI3LO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX RIN12 PGA Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LR12LO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX LIN12 PGA Bypass Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LL12LO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOMIX Left DAC Switch", WM8400_OUTPUT_MIXER1,
|
|
|
|
WM8400_LDLO_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ROMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_romix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("ROMIX Left ADC Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RLBRO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX Right ADC Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RRBRO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX LIN3 Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RLI3RO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX RIN3 Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RRI3RO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX LIN12 PGA Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RL12RO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX RIN12 PGA Bypass Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RR12RO_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROMIX Right DAC Switch", WM8400_OUTPUT_MIXER2,
|
|
|
|
WM8400_RDRO_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* LONMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_lonmix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("LONMIX Left Mixer PGA Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LLOPGALON_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LONMIX Right Mixer PGA Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LROPGALON_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LONMIX Inverted LOP Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LOPLON_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* LOPMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_lopmix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("LOPMIX Right Mic Bypass Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LR12LOP_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOPMIX Left Mic Bypass Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LL12LOP_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("LOPMIX Left Mixer PGA Switch", WM8400_LINE_MIXER1,
|
|
|
|
WM8400_LLOPGALOP_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* RONMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_ronmix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("RONMIX Right Mixer PGA Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_RROPGARON_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("RONMIX Left Mixer PGA Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_RLOPGARON_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("RONMIX Inverted ROP Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_ROPRON_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ROPMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_ropmix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("ROPMIX Left Mic Bypass Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_RL12ROP_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROPMIX Right Mic Bypass Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_RR12ROP_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("ROPMIX Right Mixer PGA Switch", WM8400_LINE_MIXER2,
|
|
|
|
WM8400_RROPGAROP_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* OUT3MIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_out3mix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("OUT3MIX LIN4/RXP Bypass Switch", WM8400_OUT3_4_MIXER,
|
|
|
|
WM8400_LI4O3_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("OUT3MIX Left Out PGA Switch", WM8400_OUT3_4_MIXER,
|
|
|
|
WM8400_LPGAO3_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* OUT4MIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_out4mix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("OUT4MIX Right Out PGA Switch", WM8400_OUT3_4_MIXER,
|
|
|
|
WM8400_RPGAO4_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("OUT4MIX RIN4/RXP Bypass Switch", WM8400_OUT3_4_MIXER,
|
|
|
|
WM8400_RI4O4_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* SPKMIX */
|
|
|
|
static const struct snd_kcontrol_new wm8400_dapm_spkmix_controls[] = {
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX LIN2 Bypass Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_LI2SPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX LADC Bypass Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_LB2SPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX Left Mixer PGA Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_LOPGASPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX Left DAC Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_LDSPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX Right DAC Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_RDSPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX Right Mixer PGA Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_ROPGASPK_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX RADC Bypass Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_RL12ROP_SHIFT, 1, 0),
|
|
|
|
SOC_DAPM_SINGLE("SPKMIX RIN2 Bypass Switch", WM8400_SPEAKER_MIXER,
|
|
|
|
WM8400_RI2SPK_SHIFT, 1, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct snd_soc_dapm_widget wm8400_dapm_widgets[] = {
|
|
|
|
/* Input Side */
|
|
|
|
/* Input Lines */
|
|
|
|
SND_SOC_DAPM_INPUT("LIN1"),
|
|
|
|
SND_SOC_DAPM_INPUT("LIN2"),
|
|
|
|
SND_SOC_DAPM_INPUT("LIN3"),
|
|
|
|
SND_SOC_DAPM_INPUT("LIN4/RXN"),
|
|
|
|
SND_SOC_DAPM_INPUT("RIN3"),
|
|
|
|
SND_SOC_DAPM_INPUT("RIN4/RXP"),
|
|
|
|
SND_SOC_DAPM_INPUT("RIN1"),
|
|
|
|
SND_SOC_DAPM_INPUT("RIN2"),
|
|
|
|
SND_SOC_DAPM_INPUT("Internal ADC Source"),
|
|
|
|
|
|
|
|
/* DACs */
|
|
|
|
SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_ADCL_ENA_SHIFT, 0),
|
|
|
|
SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_ADCR_ENA_SHIFT, 0),
|
|
|
|
|
|
|
|
/* Input PGAs */
|
|
|
|
SND_SOC_DAPM_MIXER("LIN12 PGA", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_LIN12_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_lin12_pga_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_lin12_pga_controls)),
|
|
|
|
SND_SOC_DAPM_MIXER("LIN34 PGA", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_LIN34_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_lin34_pga_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_lin34_pga_controls)),
|
|
|
|
SND_SOC_DAPM_MIXER("RIN12 PGA", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_RIN12_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_rin12_pga_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_rin12_pga_controls)),
|
|
|
|
SND_SOC_DAPM_MIXER("RIN34 PGA", WM8400_POWER_MANAGEMENT_2,
|
|
|
|
WM8400_RIN34_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_rin34_pga_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_rin34_pga_controls)),
|
|
|
|
|
2013-08-31 06:17:08 -06:00
|
|
|
SND_SOC_DAPM_SUPPLY("INL", WM8400_POWER_MANAGEMENT_2, WM8400_AINL_ENA_SHIFT,
|
|
|
|
0, NULL, 0),
|
|
|
|
SND_SOC_DAPM_SUPPLY("INR", WM8400_POWER_MANAGEMENT_2, WM8400_AINR_ENA_SHIFT,
|
|
|
|
0, NULL, 0),
|
|
|
|
|
2009-03-10 04:55:15 -06:00
|
|
|
/* INMIXL */
|
2013-08-31 06:17:08 -06:00
|
|
|
SND_SOC_DAPM_MIXER("INMIXL", SND_SOC_NOPM, 0, 0,
|
2009-03-10 04:55:15 -06:00
|
|
|
&wm8400_dapm_inmixl_controls[0],
|
2013-08-31 06:17:08 -06:00
|
|
|
ARRAY_SIZE(wm8400_dapm_inmixl_controls)),
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* AINLMUX */
|
2013-08-31 06:17:08 -06:00
|
|
|
SND_SOC_DAPM_MUX("AILNMUX", SND_SOC_NOPM, 0, 0, &wm8400_dapm_ainlmux_controls),
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* INMIXR */
|
2013-08-31 06:17:08 -06:00
|
|
|
SND_SOC_DAPM_MIXER("INMIXR", SND_SOC_NOPM, 0, 0,
|
2009-03-10 04:55:15 -06:00
|
|
|
&wm8400_dapm_inmixr_controls[0],
|
2013-08-31 06:17:08 -06:00
|
|
|
ARRAY_SIZE(wm8400_dapm_inmixr_controls)),
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* AINRMUX */
|
2013-08-31 06:17:08 -06:00
|
|
|
SND_SOC_DAPM_MUX("AIRNMUX", SND_SOC_NOPM, 0, 0, &wm8400_dapm_ainrmux_controls),
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Output Side */
|
|
|
|
/* DACs */
|
|
|
|
SND_SOC_DAPM_DAC("Left DAC", "Left Playback", WM8400_POWER_MANAGEMENT_3,
|
|
|
|
WM8400_DACL_ENA_SHIFT, 0),
|
|
|
|
SND_SOC_DAPM_DAC("Right DAC", "Right Playback", WM8400_POWER_MANAGEMENT_3,
|
|
|
|
WM8400_DACR_ENA_SHIFT, 0),
|
|
|
|
|
|
|
|
/* LOMIX */
|
|
|
|
SND_SOC_DAPM_MIXER_E("LOMIX", WM8400_POWER_MANAGEMENT_3,
|
|
|
|
WM8400_LOMIX_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_lomix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_lomix_controls),
|
|
|
|
outmixer_event, SND_SOC_DAPM_PRE_REG),
|
|
|
|
|
|
|
|
/* LONMIX */
|
|
|
|
SND_SOC_DAPM_MIXER("LONMIX", WM8400_POWER_MANAGEMENT_3, WM8400_LON_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_lonmix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_lonmix_controls)),
|
|
|
|
|
|
|
|
/* LOPMIX */
|
|
|
|
SND_SOC_DAPM_MIXER("LOPMIX", WM8400_POWER_MANAGEMENT_3, WM8400_LOP_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_lopmix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_lopmix_controls)),
|
|
|
|
|
|
|
|
/* OUT3MIX */
|
|
|
|
SND_SOC_DAPM_MIXER("OUT3MIX", WM8400_POWER_MANAGEMENT_1, WM8400_OUT3_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_out3mix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_out3mix_controls)),
|
|
|
|
|
|
|
|
/* SPKMIX */
|
|
|
|
SND_SOC_DAPM_MIXER_E("SPKMIX", WM8400_POWER_MANAGEMENT_1, WM8400_SPK_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_spkmix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_spkmix_controls), outmixer_event,
|
|
|
|
SND_SOC_DAPM_PRE_REG),
|
|
|
|
|
|
|
|
/* OUT4MIX */
|
|
|
|
SND_SOC_DAPM_MIXER("OUT4MIX", WM8400_POWER_MANAGEMENT_1, WM8400_OUT4_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_out4mix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_out4mix_controls)),
|
|
|
|
|
|
|
|
/* ROPMIX */
|
|
|
|
SND_SOC_DAPM_MIXER("ROPMIX", WM8400_POWER_MANAGEMENT_3, WM8400_ROP_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_ropmix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_ropmix_controls)),
|
|
|
|
|
|
|
|
/* RONMIX */
|
|
|
|
SND_SOC_DAPM_MIXER("RONMIX", WM8400_POWER_MANAGEMENT_3, WM8400_RON_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_ronmix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_ronmix_controls)),
|
|
|
|
|
|
|
|
/* ROMIX */
|
|
|
|
SND_SOC_DAPM_MIXER_E("ROMIX", WM8400_POWER_MANAGEMENT_3,
|
|
|
|
WM8400_ROMIX_ENA_SHIFT,
|
|
|
|
0, &wm8400_dapm_romix_controls[0],
|
|
|
|
ARRAY_SIZE(wm8400_dapm_romix_controls),
|
|
|
|
outmixer_event, SND_SOC_DAPM_PRE_REG),
|
|
|
|
|
|
|
|
/* LOUT PGA */
|
|
|
|
SND_SOC_DAPM_PGA("LOUT PGA", WM8400_POWER_MANAGEMENT_1, WM8400_LOUT_ENA_SHIFT,
|
|
|
|
0, NULL, 0),
|
|
|
|
|
|
|
|
/* ROUT PGA */
|
|
|
|
SND_SOC_DAPM_PGA("ROUT PGA", WM8400_POWER_MANAGEMENT_1, WM8400_ROUT_ENA_SHIFT,
|
|
|
|
0, NULL, 0),
|
|
|
|
|
|
|
|
/* LOPGA */
|
|
|
|
SND_SOC_DAPM_PGA("LOPGA", WM8400_POWER_MANAGEMENT_3, WM8400_LOPGA_ENA_SHIFT, 0,
|
|
|
|
NULL, 0),
|
|
|
|
|
|
|
|
/* ROPGA */
|
|
|
|
SND_SOC_DAPM_PGA("ROPGA", WM8400_POWER_MANAGEMENT_3, WM8400_ROPGA_ENA_SHIFT, 0,
|
|
|
|
NULL, 0),
|
|
|
|
|
|
|
|
/* MICBIAS */
|
2011-10-27 01:44:59 -06:00
|
|
|
SND_SOC_DAPM_SUPPLY("MICBIAS", WM8400_POWER_MANAGEMENT_1,
|
|
|
|
WM8400_MIC1BIAS_ENA_SHIFT, 0, NULL, 0),
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
SND_SOC_DAPM_OUTPUT("LON"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("LOP"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("OUT3"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("LOUT"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("SPKN"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("SPKP"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("ROUT"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("OUT4"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("ROP"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("RON"),
|
|
|
|
|
|
|
|
SND_SOC_DAPM_OUTPUT("Internal DAC Sink"),
|
|
|
|
};
|
|
|
|
|
2011-12-03 04:34:34 -07:00
|
|
|
static const struct snd_soc_dapm_route wm8400_dapm_routes[] = {
|
2009-03-10 04:55:15 -06:00
|
|
|
/* Make DACs turn on when playing even if not mixed into any outputs */
|
|
|
|
{"Internal DAC Sink", NULL, "Left DAC"},
|
|
|
|
{"Internal DAC Sink", NULL, "Right DAC"},
|
|
|
|
|
|
|
|
/* Make ADCs turn on when recording
|
|
|
|
* even if not mixed from any inputs */
|
|
|
|
{"Left ADC", NULL, "Internal ADC Source"},
|
|
|
|
{"Right ADC", NULL, "Internal ADC Source"},
|
|
|
|
|
|
|
|
/* Input Side */
|
|
|
|
/* LIN12 PGA */
|
|
|
|
{"LIN12 PGA", "LIN1 Switch", "LIN1"},
|
|
|
|
{"LIN12 PGA", "LIN2 Switch", "LIN2"},
|
|
|
|
/* LIN34 PGA */
|
|
|
|
{"LIN34 PGA", "LIN3 Switch", "LIN3"},
|
|
|
|
{"LIN34 PGA", "LIN4 Switch", "LIN4/RXN"},
|
|
|
|
/* INMIXL */
|
2013-08-31 06:17:08 -06:00
|
|
|
{"INMIXL", NULL, "INL"},
|
2009-03-10 04:55:15 -06:00
|
|
|
{"INMIXL", "Record Left Volume", "LOMIX"},
|
|
|
|
{"INMIXL", "LIN2 Volume", "LIN2"},
|
|
|
|
{"INMIXL", "LINPGA12 Switch", "LIN12 PGA"},
|
|
|
|
{"INMIXL", "LINPGA34 Switch", "LIN34 PGA"},
|
|
|
|
/* AILNMUX */
|
2013-08-31 06:17:08 -06:00
|
|
|
{"AILNMUX", NULL, "INL"},
|
2009-03-10 04:55:15 -06:00
|
|
|
{"AILNMUX", "INMIXL Mix", "INMIXL"},
|
|
|
|
{"AILNMUX", "DIFFINL Mix", "LIN12 PGA"},
|
|
|
|
{"AILNMUX", "DIFFINL Mix", "LIN34 PGA"},
|
|
|
|
{"AILNMUX", "RXVOICE Mix", "LIN4/RXN"},
|
|
|
|
{"AILNMUX", "RXVOICE Mix", "RIN4/RXP"},
|
|
|
|
/* ADC */
|
|
|
|
{"Left ADC", NULL, "AILNMUX"},
|
|
|
|
|
|
|
|
/* RIN12 PGA */
|
|
|
|
{"RIN12 PGA", "RIN1 Switch", "RIN1"},
|
|
|
|
{"RIN12 PGA", "RIN2 Switch", "RIN2"},
|
|
|
|
/* RIN34 PGA */
|
|
|
|
{"RIN34 PGA", "RIN3 Switch", "RIN3"},
|
|
|
|
{"RIN34 PGA", "RIN4 Switch", "RIN4/RXP"},
|
2013-08-31 06:17:08 -06:00
|
|
|
/* INMIXR */
|
|
|
|
{"INMIXR", NULL, "INR"},
|
2009-03-10 04:55:15 -06:00
|
|
|
{"INMIXR", "Record Right Volume", "ROMIX"},
|
|
|
|
{"INMIXR", "RIN2 Volume", "RIN2"},
|
|
|
|
{"INMIXR", "RINPGA12 Switch", "RIN12 PGA"},
|
|
|
|
{"INMIXR", "RINPGA34 Switch", "RIN34 PGA"},
|
|
|
|
/* AIRNMUX */
|
2013-08-31 06:17:08 -06:00
|
|
|
{"AIRNMUX", NULL, "INR"},
|
2009-03-10 04:55:15 -06:00
|
|
|
{"AIRNMUX", "INMIXR Mix", "INMIXR"},
|
|
|
|
{"AIRNMUX", "DIFFINR Mix", "RIN12 PGA"},
|
|
|
|
{"AIRNMUX", "DIFFINR Mix", "RIN34 PGA"},
|
|
|
|
{"AIRNMUX", "RXVOICE Mix", "LIN4/RXN"},
|
|
|
|
{"AIRNMUX", "RXVOICE Mix", "RIN4/RXP"},
|
|
|
|
/* ADC */
|
|
|
|
{"Right ADC", NULL, "AIRNMUX"},
|
|
|
|
|
|
|
|
/* LOMIX */
|
|
|
|
{"LOMIX", "LOMIX RIN3 Bypass Switch", "RIN3"},
|
|
|
|
{"LOMIX", "LOMIX LIN3 Bypass Switch", "LIN3"},
|
|
|
|
{"LOMIX", "LOMIX LIN12 PGA Bypass Switch", "LIN12 PGA"},
|
|
|
|
{"LOMIX", "LOMIX RIN12 PGA Bypass Switch", "RIN12 PGA"},
|
|
|
|
{"LOMIX", "LOMIX Right ADC Bypass Switch", "AIRNMUX"},
|
|
|
|
{"LOMIX", "LOMIX Left ADC Bypass Switch", "AILNMUX"},
|
|
|
|
{"LOMIX", "LOMIX Left DAC Switch", "Left DAC"},
|
|
|
|
|
|
|
|
/* ROMIX */
|
|
|
|
{"ROMIX", "ROMIX RIN3 Bypass Switch", "RIN3"},
|
|
|
|
{"ROMIX", "ROMIX LIN3 Bypass Switch", "LIN3"},
|
|
|
|
{"ROMIX", "ROMIX LIN12 PGA Bypass Switch", "LIN12 PGA"},
|
|
|
|
{"ROMIX", "ROMIX RIN12 PGA Bypass Switch", "RIN12 PGA"},
|
|
|
|
{"ROMIX", "ROMIX Right ADC Bypass Switch", "AIRNMUX"},
|
|
|
|
{"ROMIX", "ROMIX Left ADC Bypass Switch", "AILNMUX"},
|
|
|
|
{"ROMIX", "ROMIX Right DAC Switch", "Right DAC"},
|
|
|
|
|
|
|
|
/* SPKMIX */
|
|
|
|
{"SPKMIX", "SPKMIX LIN2 Bypass Switch", "LIN2"},
|
|
|
|
{"SPKMIX", "SPKMIX RIN2 Bypass Switch", "RIN2"},
|
|
|
|
{"SPKMIX", "SPKMIX LADC Bypass Switch", "AILNMUX"},
|
|
|
|
{"SPKMIX", "SPKMIX RADC Bypass Switch", "AIRNMUX"},
|
|
|
|
{"SPKMIX", "SPKMIX Left Mixer PGA Switch", "LOPGA"},
|
|
|
|
{"SPKMIX", "SPKMIX Right Mixer PGA Switch", "ROPGA"},
|
|
|
|
{"SPKMIX", "SPKMIX Right DAC Switch", "Right DAC"},
|
|
|
|
{"SPKMIX", "SPKMIX Left DAC Switch", "Right DAC"},
|
|
|
|
|
|
|
|
/* LONMIX */
|
|
|
|
{"LONMIX", "LONMIX Left Mixer PGA Switch", "LOPGA"},
|
|
|
|
{"LONMIX", "LONMIX Right Mixer PGA Switch", "ROPGA"},
|
|
|
|
{"LONMIX", "LONMIX Inverted LOP Switch", "LOPMIX"},
|
|
|
|
|
|
|
|
/* LOPMIX */
|
|
|
|
{"LOPMIX", "LOPMIX Right Mic Bypass Switch", "RIN12 PGA"},
|
|
|
|
{"LOPMIX", "LOPMIX Left Mic Bypass Switch", "LIN12 PGA"},
|
|
|
|
{"LOPMIX", "LOPMIX Left Mixer PGA Switch", "LOPGA"},
|
|
|
|
|
|
|
|
/* OUT3MIX */
|
|
|
|
{"OUT3MIX", "OUT3MIX LIN4/RXP Bypass Switch", "LIN4/RXN"},
|
|
|
|
{"OUT3MIX", "OUT3MIX Left Out PGA Switch", "LOPGA"},
|
|
|
|
|
|
|
|
/* OUT4MIX */
|
|
|
|
{"OUT4MIX", "OUT4MIX Right Out PGA Switch", "ROPGA"},
|
|
|
|
{"OUT4MIX", "OUT4MIX RIN4/RXP Bypass Switch", "RIN4/RXP"},
|
|
|
|
|
|
|
|
/* RONMIX */
|
|
|
|
{"RONMIX", "RONMIX Right Mixer PGA Switch", "ROPGA"},
|
|
|
|
{"RONMIX", "RONMIX Left Mixer PGA Switch", "LOPGA"},
|
|
|
|
{"RONMIX", "RONMIX Inverted ROP Switch", "ROPMIX"},
|
|
|
|
|
|
|
|
/* ROPMIX */
|
|
|
|
{"ROPMIX", "ROPMIX Left Mic Bypass Switch", "LIN12 PGA"},
|
|
|
|
{"ROPMIX", "ROPMIX Right Mic Bypass Switch", "RIN12 PGA"},
|
|
|
|
{"ROPMIX", "ROPMIX Right Mixer PGA Switch", "ROPGA"},
|
|
|
|
|
|
|
|
/* Out Mixer PGAs */
|
|
|
|
{"LOPGA", NULL, "LOMIX"},
|
|
|
|
{"ROPGA", NULL, "ROMIX"},
|
|
|
|
|
|
|
|
{"LOUT PGA", NULL, "LOMIX"},
|
|
|
|
{"ROUT PGA", NULL, "ROMIX"},
|
|
|
|
|
|
|
|
/* Output Pins */
|
|
|
|
{"LON", NULL, "LONMIX"},
|
|
|
|
{"LOP", NULL, "LOPMIX"},
|
|
|
|
{"OUT3", NULL, "OUT3MIX"},
|
|
|
|
{"LOUT", NULL, "LOUT PGA"},
|
|
|
|
{"SPKN", NULL, "SPKMIX"},
|
|
|
|
{"ROUT", NULL, "ROUT PGA"},
|
|
|
|
{"OUT4", NULL, "OUT4MIX"},
|
|
|
|
{"ROP", NULL, "ROPMIX"},
|
|
|
|
{"RON", NULL, "RONMIX"},
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clock after FLL and dividers
|
|
|
|
*/
|
|
|
|
static int wm8400_set_dai_sysclk(struct snd_soc_dai *codec_dai,
|
|
|
|
int clk_id, unsigned int freq, int dir)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = codec_dai->component;
|
|
|
|
struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
wm8400->sysclk = freq;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-18 12:28:01 -06:00
|
|
|
struct fll_factors {
|
|
|
|
u16 n;
|
|
|
|
u16 k;
|
|
|
|
u16 outdiv;
|
|
|
|
u16 fratio;
|
|
|
|
u16 freq_ref;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define FIXED_FLL_SIZE ((1 << 16) * 10)
|
|
|
|
|
|
|
|
static int fll_factors(struct wm8400_priv *wm8400, struct fll_factors *factors,
|
|
|
|
unsigned int Fref, unsigned int Fout)
|
|
|
|
{
|
|
|
|
u64 Kpart;
|
|
|
|
unsigned int K, Nmod, target;
|
|
|
|
|
|
|
|
factors->outdiv = 2;
|
|
|
|
while (Fout * factors->outdiv < 90000000 ||
|
|
|
|
Fout * factors->outdiv > 100000000) {
|
|
|
|
factors->outdiv *= 2;
|
|
|
|
if (factors->outdiv > 32) {
|
|
|
|
dev_err(wm8400->wm8400->dev,
|
2009-05-27 18:08:39 -06:00
|
|
|
"Unsupported FLL output frequency %uHz\n",
|
2009-03-18 12:28:01 -06:00
|
|
|
Fout);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
target = Fout * factors->outdiv;
|
|
|
|
factors->outdiv = factors->outdiv >> 2;
|
|
|
|
|
|
|
|
if (Fref < 48000)
|
|
|
|
factors->freq_ref = 1;
|
|
|
|
else
|
|
|
|
factors->freq_ref = 0;
|
|
|
|
|
|
|
|
if (Fref < 1000000)
|
|
|
|
factors->fratio = 9;
|
|
|
|
else
|
|
|
|
factors->fratio = 0;
|
|
|
|
|
|
|
|
/* Ensure we have a fractional part */
|
|
|
|
do {
|
|
|
|
if (Fref < 1000000)
|
|
|
|
factors->fratio--;
|
|
|
|
else
|
|
|
|
factors->fratio++;
|
|
|
|
|
|
|
|
if (factors->fratio < 1 || factors->fratio > 8) {
|
|
|
|
dev_err(wm8400->wm8400->dev,
|
|
|
|
"Unable to calculate FRATIO\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
factors->n = target / (Fref * factors->fratio);
|
|
|
|
Nmod = target % (Fref * factors->fratio);
|
|
|
|
} while (Nmod == 0);
|
|
|
|
|
|
|
|
/* Calculate fractional part - scale up so we can round. */
|
|
|
|
Kpart = FIXED_FLL_SIZE * (long long)Nmod;
|
|
|
|
|
|
|
|
do_div(Kpart, (Fref * factors->fratio));
|
|
|
|
|
|
|
|
K = Kpart & 0xFFFFFFFF;
|
|
|
|
|
|
|
|
if ((K % 10) >= 5)
|
|
|
|
K += 5;
|
|
|
|
|
|
|
|
/* Move down to proper range now rounding is done */
|
|
|
|
factors->k = K / 10;
|
|
|
|
|
|
|
|
dev_dbg(wm8400->wm8400->dev,
|
2009-05-27 18:08:39 -06:00
|
|
|
"FLL: Fref=%u Fout=%u N=%x K=%x, FRATIO=%x OUTDIV=%x\n",
|
2009-03-18 12:28:01 -06:00
|
|
|
Fref, Fout,
|
|
|
|
factors->n, factors->k, factors->fratio, factors->outdiv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
|
2009-09-05 11:52:16 -06:00
|
|
|
int source, unsigned int freq_in,
|
|
|
|
unsigned int freq_out)
|
2009-03-18 12:28:01 -06:00
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = codec_dai->component;
|
|
|
|
struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component);
|
2009-03-18 12:28:01 -06:00
|
|
|
struct fll_factors factors;
|
|
|
|
int ret;
|
|
|
|
u16 reg;
|
|
|
|
|
|
|
|
if (freq_in == wm8400->fll_in && freq_out == wm8400->fll_out)
|
|
|
|
return 0;
|
|
|
|
|
2009-07-17 14:53:49 -06:00
|
|
|
if (freq_out) {
|
2009-03-18 12:28:01 -06:00
|
|
|
ret = fll_factors(wm8400, &factors, freq_in, freq_out);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
2009-07-17 14:53:49 -06:00
|
|
|
} else {
|
|
|
|
/* Bodge GCC 4.4.0 uninitialised variable warning - it
|
|
|
|
* doesn't seem capable of working out that we exit if
|
|
|
|
* freq_out is 0 before any of the uses. */
|
|
|
|
memset(&factors, 0, sizeof(factors));
|
2009-03-18 12:28:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
wm8400->fll_out = freq_out;
|
|
|
|
wm8400->fll_in = freq_in;
|
|
|
|
|
|
|
|
/* We *must* disable the FLL before any changes */
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_2);
|
2009-03-18 12:28:01 -06:00
|
|
|
reg &= ~WM8400_FLL_ENA;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_2, reg);
|
2009-03-18 12:28:01 -06:00
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_FLL_CONTROL_1);
|
2009-03-18 12:28:01 -06:00
|
|
|
reg &= ~WM8400_FLL_OSC_ENA;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_FLL_CONTROL_1, reg);
|
2009-03-18 12:28:01 -06:00
|
|
|
|
2009-07-17 14:53:49 -06:00
|
|
|
if (!freq_out)
|
2009-03-18 12:28:01 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
reg &= ~(WM8400_FLL_REF_FREQ | WM8400_FLL_FRATIO_MASK);
|
|
|
|
reg |= WM8400_FLL_FRAC | factors.fratio;
|
|
|
|
reg |= factors.freq_ref << WM8400_FLL_REF_FREQ_SHIFT;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_FLL_CONTROL_1, reg);
|
2009-03-18 12:28:01 -06:00
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_FLL_CONTROL_2, factors.k);
|
|
|
|
snd_soc_component_write(component, WM8400_FLL_CONTROL_3, factors.n);
|
2009-03-18 12:28:01 -06:00
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_FLL_CONTROL_4);
|
2011-10-22 08:48:27 -06:00
|
|
|
reg &= ~WM8400_FLL_OUTDIV_MASK;
|
2009-03-18 12:28:01 -06:00
|
|
|
reg |= factors.outdiv;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_FLL_CONTROL_4, reg);
|
2009-03-18 12:28:01 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-10 04:55:15 -06:00
|
|
|
/*
|
|
|
|
* Sets ADC and Voice DAC format.
|
|
|
|
*/
|
|
|
|
static int wm8400_set_dai_fmt(struct snd_soc_dai *codec_dai,
|
|
|
|
unsigned int fmt)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = codec_dai->component;
|
2009-03-10 04:55:15 -06:00
|
|
|
u16 audio1, audio3;
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
audio1 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_1);
|
|
|
|
audio3 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_3);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* set master/slave audio interface */
|
|
|
|
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFS:
|
|
|
|
audio3 &= ~WM8400_AIF_MSTR1;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFM:
|
|
|
|
audio3 |= WM8400_AIF_MSTR1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio1 &= ~WM8400_AIF_FMT_MASK;
|
|
|
|
|
|
|
|
/* interface format */
|
|
|
|
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_I2S:
|
|
|
|
audio1 |= WM8400_AIF_FMT_I2S;
|
|
|
|
audio1 &= ~WM8400_AIF_LRCLK_INV;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_RIGHT_J:
|
|
|
|
audio1 |= WM8400_AIF_FMT_RIGHTJ;
|
|
|
|
audio1 &= ~WM8400_AIF_LRCLK_INV;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_LEFT_J:
|
|
|
|
audio1 |= WM8400_AIF_FMT_LEFTJ;
|
|
|
|
audio1 &= ~WM8400_AIF_LRCLK_INV;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_DSP_A:
|
|
|
|
audio1 |= WM8400_AIF_FMT_DSP;
|
|
|
|
audio1 &= ~WM8400_AIF_LRCLK_INV;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_DSP_B:
|
|
|
|
audio1 |= WM8400_AIF_FMT_DSP | WM8400_AIF_LRCLK_INV;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_1, audio1);
|
|
|
|
snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_3, audio3);
|
2009-03-10 04:55:15 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wm8400_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
|
|
|
|
int div_id, int div)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = codec_dai->component;
|
2009-03-10 04:55:15 -06:00
|
|
|
u16 reg;
|
|
|
|
|
|
|
|
switch (div_id) {
|
|
|
|
case WM8400_MCLK_DIV:
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_MCLK_DIV_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
case WM8400_DACCLK_DIV:
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_DAC_CLKDIV_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
case WM8400_ADCCLK_DIV:
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_ADC_CLKDIV_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
case WM8400_BCLK_DIV:
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_CLOCKING_1) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_BCLK_DIV_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_CLOCKING_1, reg | div);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set PCM DAI bit size and sample rate.
|
|
|
|
*/
|
|
|
|
static int wm8400_hw_params(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *params,
|
|
|
|
struct snd_soc_dai *dai)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = dai->component;
|
|
|
|
u16 audio1 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_1);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
audio1 &= ~WM8400_AIF_WL_MASK;
|
|
|
|
/* bit size */
|
2014-07-31 05:49:53 -06:00
|
|
|
switch (params_width(params)) {
|
|
|
|
case 16:
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
2014-07-31 05:49:53 -06:00
|
|
|
case 20:
|
2009-03-10 04:55:15 -06:00
|
|
|
audio1 |= WM8400_AIF_WL_20BITS;
|
|
|
|
break;
|
2014-07-31 05:49:53 -06:00
|
|
|
case 24:
|
2009-03-10 04:55:15 -06:00
|
|
|
audio1 |= WM8400_AIF_WL_24BITS;
|
|
|
|
break;
|
2014-07-31 05:49:53 -06:00
|
|
|
case 32:
|
2009-03-10 04:55:15 -06:00
|
|
|
audio1 |= WM8400_AIF_WL_32BITS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_1, audio1);
|
2009-03-10 04:55:15 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wm8400_mute(struct snd_soc_dai *dai, int mute)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct snd_soc_component *component = dai->component;
|
|
|
|
u16 val = snd_soc_component_read32(component, WM8400_DAC_CTRL) & ~WM8400_DAC_MUTE;
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
if (mute)
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE);
|
2009-03-10 04:55:15 -06:00
|
|
|
else
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_DAC_CTRL, val);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: set bias for best performance at standby */
|
2018-01-28 20:00:04 -07:00
|
|
|
static int wm8400_set_bias_level(struct snd_soc_component *component,
|
2009-03-10 04:55:15 -06:00
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component);
|
2009-03-10 04:55:15 -06:00
|
|
|
u16 val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch (level) {
|
|
|
|
case SND_SOC_BIAS_ON:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_BIAS_PREPARE:
|
|
|
|
/* VMID=2*50k */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_VMID_MODE_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val | 0x2);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_BIAS_STANDBY:
|
2018-01-28 20:00:04 -07:00
|
|
|
if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
|
2009-03-10 04:55:15 -06:00
|
|
|
ret = regulator_bulk_enable(ARRAY_SIZE(power),
|
|
|
|
&power[0]);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(wm8400->wm8400->dev,
|
|
|
|
"Failed to enable regulators: %d\n",
|
|
|
|
ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1,
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_CODEC_ENA | WM8400_SYSCLK_ENA);
|
|
|
|
|
|
|
|
/* Enable POBCTRL, SOFT_ST, VMIDTOG and BUFDCOPEN */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST |
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_BUFDCOPEN | WM8400_POBCTRL);
|
|
|
|
|
2009-03-18 09:19:10 -06:00
|
|
|
msleep(50);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Enable VREF & VMID at 2x50k */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1);
|
2009-03-10 04:55:15 -06:00
|
|
|
val |= 0x2 | WM8400_VREF_ENA;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Enable BUFIOEN */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST |
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_BUFDCOPEN | WM8400_POBCTRL |
|
|
|
|
WM8400_BUFIOEN);
|
|
|
|
|
|
|
|
/* disable POBCTRL, SOFT_ST and BUFDCOPEN */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_BUFIOEN);
|
2009-03-10 04:55:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* VMID=2*300k */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1) &
|
2009-03-10 04:55:15 -06:00
|
|
|
~WM8400_VMID_MODE_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val | 0x4);
|
2009-03-10 04:55:15 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_BIAS_OFF:
|
|
|
|
/* Enable POBCTRL and SOFT_ST */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST |
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_POBCTRL | WM8400_BUFIOEN);
|
|
|
|
|
|
|
|
/* Enable POBCTRL, SOFT_ST and BUFDCOPEN */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST |
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_BUFDCOPEN | WM8400_POBCTRL |
|
|
|
|
WM8400_BUFIOEN);
|
|
|
|
|
|
|
|
/* mute DAC */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, WM8400_DAC_CTRL);
|
|
|
|
snd_soc_component_write(component, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Enable any disabled outputs */
|
2018-01-28 20:00:04 -07:00
|
|
|
val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1);
|
2009-03-10 04:55:15 -06:00
|
|
|
val |= WM8400_SPK_ENA | WM8400_OUT3_ENA |
|
|
|
|
WM8400_OUT4_ENA | WM8400_LOUT_ENA |
|
|
|
|
WM8400_ROUT_ENA;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Disable VMID */
|
|
|
|
val &= ~WM8400_VMID_MODE_MASK;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
msleep(300);
|
|
|
|
|
|
|
|
/* Enable all output discharge bits */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP1, WM8400_DIS_LLINE |
|
2009-03-10 04:55:15 -06:00
|
|
|
WM8400_DIS_RLINE | WM8400_DIS_OUT3 |
|
|
|
|
WM8400_DIS_OUT4 | WM8400_DIS_LOUT |
|
|
|
|
WM8400_DIS_ROUT);
|
|
|
|
|
|
|
|
/* Disable VREF */
|
|
|
|
val &= ~WM8400_VREF_ENA;
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* disable POBCTRL, SOFT_ST and BUFDCOPEN */
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_ANTIPOP2, 0x0);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
ret = regulator_bulk_disable(ARRAY_SIZE(power),
|
|
|
|
&power[0]);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define WM8400_RATES SNDRV_PCM_RATE_8000_96000
|
|
|
|
|
|
|
|
#define WM8400_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
|
|
|
|
SNDRV_PCM_FMTBIT_S24_LE)
|
|
|
|
|
2011-11-23 03:40:40 -07:00
|
|
|
static const struct snd_soc_dai_ops wm8400_dai_ops = {
|
2009-03-11 10:51:31 -06:00
|
|
|
.hw_params = wm8400_hw_params,
|
|
|
|
.digital_mute = wm8400_mute,
|
|
|
|
.set_fmt = wm8400_set_dai_fmt,
|
|
|
|
.set_clkdiv = wm8400_set_dai_clkdiv,
|
|
|
|
.set_sysclk = wm8400_set_dai_sysclk,
|
2009-03-18 12:28:01 -06:00
|
|
|
.set_pll = wm8400_set_dai_pll,
|
2009-03-11 10:51:31 -06:00
|
|
|
};
|
|
|
|
|
2009-03-10 04:55:15 -06:00
|
|
|
/*
|
|
|
|
* The WM8400 supports 2 different and mutually exclusive DAI
|
|
|
|
* configurations.
|
|
|
|
*
|
|
|
|
* 1. ADC/DAC on Primary Interface
|
|
|
|
* 2. ADC on Primary Interface/DAC on secondary
|
|
|
|
*/
|
2010-03-17 14:15:21 -06:00
|
|
|
static struct snd_soc_dai_driver wm8400_dai = {
|
2009-03-10 04:55:15 -06:00
|
|
|
/* ADC/DAC on primary */
|
2010-03-17 14:15:21 -06:00
|
|
|
.name = "wm8400-hifi",
|
2009-03-10 04:55:15 -06:00
|
|
|
.playback = {
|
|
|
|
.stream_name = "Playback",
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.rates = WM8400_RATES,
|
|
|
|
.formats = WM8400_FORMATS,
|
|
|
|
},
|
|
|
|
.capture = {
|
|
|
|
.stream_name = "Capture",
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.rates = WM8400_RATES,
|
|
|
|
.formats = WM8400_FORMATS,
|
|
|
|
},
|
2009-03-11 10:51:31 -06:00
|
|
|
.ops = &wm8400_dai_ops,
|
2009-03-10 04:55:15 -06:00
|
|
|
};
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
static int wm8400_component_probe(struct snd_soc_component *component)
|
2009-03-10 04:55:15 -06:00
|
|
|
{
|
2018-01-28 20:00:04 -07:00
|
|
|
struct wm8400 *wm8400 = dev_get_platdata(component->dev);
|
2009-03-10 04:55:15 -06:00
|
|
|
struct wm8400_priv *priv;
|
|
|
|
int ret;
|
|
|
|
u16 reg;
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
priv = devm_kzalloc(component->dev, sizeof(struct wm8400_priv),
|
2011-12-03 04:41:27 -07:00
|
|
|
GFP_KERNEL);
|
2009-03-10 04:55:15 -06:00
|
|
|
if (priv == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_init_regmap(component, wm8400->regmap);
|
|
|
|
snd_soc_component_set_drvdata(component, priv);
|
2013-08-31 06:21:12 -06:00
|
|
|
priv->wm8400 = wm8400;
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2012-11-26 04:49:36 -07:00
|
|
|
ret = devm_regulator_bulk_get(wm8400->dev,
|
2009-03-10 04:55:15 -06:00
|
|
|
ARRAY_SIZE(power), &power[0]);
|
|
|
|
if (ret != 0) {
|
2018-01-28 20:00:04 -07:00
|
|
|
dev_err(component->dev, "Failed to get regulators: %d\n", ret);
|
2011-12-03 04:41:27 -07:00
|
|
|
return ret;
|
2009-03-10 04:55:15 -06:00
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
wm8400_component_reset(component);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1);
|
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, reg | WM8400_CODEC_ENA);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
/* Latch volume update bits */
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_LEFT_LINE_INPUT_1_2_VOLUME);
|
|
|
|
snd_soc_component_write(component, WM8400_LEFT_LINE_INPUT_1_2_VOLUME,
|
2009-03-10 04:55:15 -06:00
|
|
|
reg & WM8400_IPVU);
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME);
|
|
|
|
snd_soc_component_write(component, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME,
|
2009-03-10 04:55:15 -06:00
|
|
|
reg & WM8400_IPVU);
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
snd_soc_component_write(component, WM8400_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8));
|
|
|
|
snd_soc_component_write(component, WM8400_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
static void wm8400_component_remove(struct snd_soc_component *component)
|
2009-03-10 04:55:15 -06:00
|
|
|
{
|
|
|
|
u16 reg;
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1);
|
|
|
|
snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1,
|
2009-03-10 04:55:15 -06:00
|
|
|
reg & (~WM8400_CODEC_ENA));
|
2010-03-17 14:15:21 -06:00
|
|
|
}
|
|
|
|
|
2018-01-28 20:00:04 -07:00
|
|
|
static const struct snd_soc_component_driver soc_component_dev_wm8400 = {
|
|
|
|
.probe = wm8400_component_probe,
|
|
|
|
.remove = wm8400_component_remove,
|
|
|
|
.set_bias_level = wm8400_set_bias_level,
|
|
|
|
.controls = wm8400_snd_controls,
|
|
|
|
.num_controls = ARRAY_SIZE(wm8400_snd_controls),
|
|
|
|
.dapm_widgets = wm8400_dapm_widgets,
|
|
|
|
.num_dapm_widgets = ARRAY_SIZE(wm8400_dapm_widgets),
|
|
|
|
.dapm_routes = wm8400_dapm_routes,
|
|
|
|
.num_dapm_routes = ARRAY_SIZE(wm8400_dapm_routes),
|
|
|
|
.suspend_bias_off = 1,
|
|
|
|
.idle_bias_on = 1,
|
|
|
|
.use_pmdown_time = 1,
|
|
|
|
.endianness = 1,
|
|
|
|
.non_legacy_dai_naming = 1,
|
2010-03-17 14:15:21 -06:00
|
|
|
};
|
|
|
|
|
2012-12-07 07:26:37 -07:00
|
|
|
static int wm8400_probe(struct platform_device *pdev)
|
2010-03-17 14:15:21 -06:00
|
|
|
{
|
2018-03-16 01:32:07 -06:00
|
|
|
return devm_snd_soc_register_component(&pdev->dev,
|
2018-01-28 20:00:04 -07:00
|
|
|
&soc_component_dev_wm8400,
|
2010-03-17 14:15:21 -06:00
|
|
|
&wm8400_dai, 1);
|
|
|
|
}
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
static struct platform_driver wm8400_codec_driver = {
|
|
|
|
.driver = {
|
2010-03-17 14:15:21 -06:00
|
|
|
.name = "wm8400-codec",
|
|
|
|
},
|
|
|
|
.probe = wm8400_probe,
|
2009-03-10 04:55:15 -06:00
|
|
|
};
|
|
|
|
|
2011-11-23 15:52:08 -07:00
|
|
|
module_platform_driver(wm8400_codec_driver);
|
2009-03-10 04:55:15 -06:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("ASoC WM8400 driver");
|
|
|
|
MODULE_AUTHOR("Mark Brown");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS("platform:wm8400-codec");
|