2011-02-23 18:08:21 +00:00
|
|
|
/*
|
|
|
|
* sgtl5000.c -- SGTL5000 ALSA SoC Audio driver
|
|
|
|
*
|
|
|
|
* Copyright 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/clk.h>
|
2014-10-14 06:43:11 +00:00
|
|
|
#include <linux/log2.h>
|
2013-05-04 18:39:34 +00:00
|
|
|
#include <linux/regmap.h>
|
2011-02-23 18:08:21 +00:00
|
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#include <linux/regulator/machine.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
2011-07-21 16:28:51 +00:00
|
|
|
#include <linux/of_device.h>
|
2011-02-23 18:08:21 +00:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/tlv.h>
|
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
|
|
|
#include <sound/soc-dapm.h>
|
|
|
|
#include <sound/initval.h>
|
|
|
|
|
|
|
|
#include "sgtl5000.h"
|
|
|
|
|
|
|
|
#define SGTL5000_DAP_REG_OFFSET 0x0100
|
|
|
|
#define SGTL5000_MAX_REG_OFFSET 0x013A
|
|
|
|
|
ASoC: sgtl5000: fix cache handling
Cache handling in this driver is broken. The chip has 16-bit registers, yet the
register numbers also increase by 2 per register, i.e. there are only
even-numbered registers. The cache in this driver, though, simply increments
register numbers, so it does need some mapping as seen in
sgtl5000_restore_regs(), note the '>> 1':
snd_soc_write(codec, SGTL5000_CHIP_LINREG_CTRL,
cache[SGTL5000_CHIP_LINREG_CTRL >> 1]);
That, of course, won't work with snd_soc_update_bits(). (Thus, we won't even
notice the missing register 0x1c in the default regs which shifted all follwing
registers to wrong values.) Noticed on the MX28EVK where enabling the regulators
simply locked up the chip.
Refactor the routines and use a properly sized default_regs array which matches
the register layout of the underlying chip, i.e. create a truly flat cache.
This also saves some code which should make up for the bigger array a little.
When soc-core will somewhen have another cache type which handles a step size,
this conversion will also ease the transition.
Signed-off-by: Wolfram Sang <w.sang@pengutronix.de>
Tested-by: Dong Aisheng <b29396@freescale.com>
Tested-by: Shawn Guo <shawn.guo@linaro.org>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Cc: stable@kernel.org
2011-08-02 17:42:19 +00:00
|
|
|
/* default value of sgtl5000 registers */
|
2013-05-04 18:39:34 +00:00
|
|
|
static const struct reg_default sgtl5000_reg_defaults[] = {
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_CHIP_DIG_POWER, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_CHIP_CLK_CTRL, 0x0008 },
|
|
|
|
{ SGTL5000_CHIP_I2S_CTRL, 0x0010 },
|
2013-07-04 23:01:02 +00:00
|
|
|
{ SGTL5000_CHIP_SSS_CTRL, 0x0010 },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_CHIP_ADCDAC_CTRL, 0x020c },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_CHIP_DAC_VOL, 0x3c3c },
|
|
|
|
{ SGTL5000_CHIP_PAD_STRENGTH, 0x015f },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_CHIP_ANA_ADC_CTRL, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_CHIP_ANA_HP_CTRL, 0x1818 },
|
|
|
|
{ SGTL5000_CHIP_ANA_CTRL, 0x0111 },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_CHIP_LINREG_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_REF_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_MIC_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_LINE_OUT_CTRL, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_CHIP_LINE_OUT_VOL, 0x0404 },
|
|
|
|
{ SGTL5000_CHIP_ANA_POWER, 0x7060 },
|
|
|
|
{ SGTL5000_CHIP_PLL_CTRL, 0x5000 },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_CHIP_CLK_TOP_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_ANA_STATUS, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_SHORT_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_CHIP_ANA_TEST2, 0x0000 },
|
|
|
|
{ SGTL5000_DAP_CTRL, 0x0000 },
|
|
|
|
{ SGTL5000_DAP_PEQ, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_DAP_BASS_ENHANCE, 0x0040 },
|
|
|
|
{ SGTL5000_DAP_BASS_ENHANCE_CTRL, 0x051f },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_DAP_AUDIO_EQ, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_DAP_SURROUND, 0x0040 },
|
|
|
|
{ SGTL5000_DAP_EQ_BASS_BAND0, 0x002f },
|
|
|
|
{ SGTL5000_DAP_EQ_BASS_BAND1, 0x002f },
|
|
|
|
{ SGTL5000_DAP_EQ_BASS_BAND2, 0x002f },
|
|
|
|
{ SGTL5000_DAP_EQ_BASS_BAND3, 0x002f },
|
|
|
|
{ SGTL5000_DAP_EQ_BASS_BAND4, 0x002f },
|
|
|
|
{ SGTL5000_DAP_MAIN_CHAN, 0x8000 },
|
2014-05-26 13:34:20 +00:00
|
|
|
{ SGTL5000_DAP_MIX_CHAN, 0x0000 },
|
2013-05-04 18:39:34 +00:00
|
|
|
{ SGTL5000_DAP_AVC_CTRL, 0x0510 },
|
|
|
|
{ SGTL5000_DAP_AVC_THRESHOLD, 0x1473 },
|
|
|
|
{ SGTL5000_DAP_AVC_ATTACK, 0x0028 },
|
|
|
|
{ SGTL5000_DAP_AVC_DECAY, 0x0050 },
|
2011-02-23 18:08:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* regulator supplies for sgtl5000, VDDD is an optional external supply */
|
|
|
|
enum sgtl5000_regulator_supplies {
|
|
|
|
VDDA,
|
|
|
|
VDDIO,
|
|
|
|
VDDD,
|
|
|
|
SGTL5000_SUPPLY_NUM
|
|
|
|
};
|
|
|
|
|
|
|
|
/* vddd is optional supply */
|
|
|
|
static const char *supply_names[SGTL5000_SUPPLY_NUM] = {
|
|
|
|
"VDDA",
|
|
|
|
"VDDIO",
|
|
|
|
"VDDD"
|
|
|
|
};
|
|
|
|
|
|
|
|
#define LDO_CONSUMER_NAME "VDDD_LDO"
|
|
|
|
#define LDO_VOLTAGE 1200000
|
|
|
|
|
|
|
|
static struct regulator_consumer_supply ldo_consumer[] = {
|
|
|
|
REGULATOR_SUPPLY(LDO_CONSUMER_NAME, NULL),
|
|
|
|
};
|
|
|
|
|
2011-02-28 14:33:01 +00:00
|
|
|
static struct regulator_init_data ldo_init_data = {
|
2011-02-23 18:08:21 +00:00
|
|
|
.constraints = {
|
2012-04-03 21:05:20 +00:00
|
|
|
.min_uV = 1200000,
|
|
|
|
.max_uV = 1200000,
|
2011-02-23 18:08:21 +00:00
|
|
|
.valid_modes_mask = REGULATOR_MODE_NORMAL,
|
|
|
|
.valid_ops_mask = REGULATOR_CHANGE_STATUS,
|
|
|
|
},
|
|
|
|
.num_consumer_supplies = 1,
|
|
|
|
.consumer_supplies = &ldo_consumer[0],
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sgtl5000 internal ldo regulator,
|
|
|
|
* enabled when VDDD not provided
|
|
|
|
*/
|
|
|
|
struct ldo_regulator {
|
|
|
|
struct regulator_desc desc;
|
|
|
|
struct regulator_dev *dev;
|
|
|
|
int voltage;
|
|
|
|
void *codec_data;
|
|
|
|
bool enabled;
|
|
|
|
};
|
|
|
|
|
2014-10-14 06:43:11 +00:00
|
|
|
enum sgtl5000_micbias_resistor {
|
|
|
|
SGTL5000_MICBIAS_OFF = 0,
|
|
|
|
SGTL5000_MICBIAS_2K = 2,
|
|
|
|
SGTL5000_MICBIAS_4K = 4,
|
|
|
|
SGTL5000_MICBIAS_8K = 8,
|
|
|
|
};
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
/* sgtl5000 private structure in codec */
|
|
|
|
struct sgtl5000_priv {
|
|
|
|
int sysclk; /* sysclk rate */
|
|
|
|
int master; /* i2s master or not */
|
|
|
|
int fmt; /* i2s data format */
|
|
|
|
struct regulator_bulk_data supplies[SGTL5000_SUPPLY_NUM];
|
|
|
|
struct ldo_regulator *ldo;
|
2013-05-04 18:39:34 +00:00
|
|
|
struct regmap *regmap;
|
2013-06-10 01:07:46 +00:00
|
|
|
struct clk *mclk;
|
2013-12-13 06:43:02 +00:00
|
|
|
int revision;
|
2014-10-14 06:43:11 +00:00
|
|
|
u8 micbias_resistor;
|
2014-10-14 06:43:12 +00:00
|
|
|
u8 micbias_voltage;
|
2011-02-23 18:08:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mic_bias power on/off share the same register bits with
|
|
|
|
* output impedance of mic bias, when power on mic bias, we
|
|
|
|
* need reclaim it to impedance value.
|
|
|
|
* 0x0 = Powered off
|
|
|
|
* 0x1 = 2Kohm
|
|
|
|
* 0x2 = 4Kohm
|
|
|
|
* 0x3 = 8Kohm
|
|
|
|
*/
|
|
|
|
static int mic_bias_event(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
2014-10-14 06:43:11 +00:00
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(w->codec);
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
switch (event) {
|
|
|
|
case SND_SOC_DAPM_POST_PMU:
|
2014-10-14 06:43:11 +00:00
|
|
|
/* change mic bias resistor */
|
2011-02-23 18:08:21 +00:00
|
|
|
snd_soc_update_bits(w->codec, SGTL5000_CHIP_MIC_CTRL,
|
2014-10-14 06:43:11 +00:00
|
|
|
SGTL5000_BIAS_R_MASK,
|
|
|
|
sgtl5000->micbias_resistor << SGTL5000_BIAS_R_SHIFT);
|
2011-02-23 18:08:21 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_DAPM_PRE_PMD:
|
|
|
|
snd_soc_update_bits(w->codec, SGTL5000_CHIP_MIC_CTRL,
|
2011-10-19 03:00:42 +00:00
|
|
|
SGTL5000_BIAS_R_MASK, 0);
|
2011-02-23 18:08:21 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-29 16:13:02 +00:00
|
|
|
* As manual described, ADC/DAC only works when VAG powerup,
|
|
|
|
* So enabled VAG before ADC/DAC up.
|
|
|
|
* In power down case, we need wait 400ms when vag fully ramped down.
|
2011-02-23 18:08:21 +00:00
|
|
|
*/
|
2012-03-29 16:13:02 +00:00
|
|
|
static int power_vag_event(struct snd_soc_dapm_widget *w,
|
2011-02-23 18:08:21 +00:00
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
2013-07-31 14:44:29 +00:00
|
|
|
const u32 mask = SGTL5000_DAC_POWERUP | SGTL5000_ADC_POWERUP;
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
switch (event) {
|
2013-05-28 18:55:56 +00:00
|
|
|
case SND_SOC_DAPM_POST_PMU:
|
2011-02-23 18:08:21 +00:00
|
|
|
snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_VAG_POWERUP, SGTL5000_VAG_POWERUP);
|
|
|
|
break;
|
|
|
|
|
2013-05-28 18:55:56 +00:00
|
|
|
case SND_SOC_DAPM_PRE_PMD:
|
2013-07-31 14:44:29 +00:00
|
|
|
/*
|
|
|
|
* Don't clear VAG_POWERUP, when both DAC and ADC are
|
|
|
|
* operational to prevent inadvertently starving the
|
|
|
|
* other one of them.
|
|
|
|
*/
|
|
|
|
if ((snd_soc_read(w->codec, SGTL5000_CHIP_ANA_POWER) &
|
|
|
|
mask) != mask) {
|
|
|
|
snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_VAG_POWERUP, 0);
|
|
|
|
msleep(400);
|
|
|
|
}
|
2011-02-23 18:08:21 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* input sources for ADC */
|
|
|
|
static const char *adc_mux_text[] = {
|
|
|
|
"MIC_IN", "LINE_IN"
|
|
|
|
};
|
|
|
|
|
2014-02-18 09:16:31 +00:00
|
|
|
static SOC_ENUM_SINGLE_DECL(adc_enum,
|
|
|
|
SGTL5000_CHIP_ANA_CTRL, 2,
|
|
|
|
adc_mux_text);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
static const struct snd_kcontrol_new adc_mux =
|
|
|
|
SOC_DAPM_ENUM("Capture Mux", adc_enum);
|
|
|
|
|
|
|
|
/* input sources for DAC */
|
|
|
|
static const char *dac_mux_text[] = {
|
|
|
|
"DAC", "LINE_IN"
|
|
|
|
};
|
|
|
|
|
2014-02-18 09:16:31 +00:00
|
|
|
static SOC_ENUM_SINGLE_DECL(dac_enum,
|
|
|
|
SGTL5000_CHIP_ANA_CTRL, 6,
|
|
|
|
dac_mux_text);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
static const struct snd_kcontrol_new dac_mux =
|
|
|
|
SOC_DAPM_ENUM("Headphone Mux", dac_enum);
|
|
|
|
|
|
|
|
static const struct snd_soc_dapm_widget sgtl5000_dapm_widgets[] = {
|
|
|
|
SND_SOC_DAPM_INPUT("LINE_IN"),
|
|
|
|
SND_SOC_DAPM_INPUT("MIC_IN"),
|
|
|
|
|
|
|
|
SND_SOC_DAPM_OUTPUT("HP_OUT"),
|
|
|
|
SND_SOC_DAPM_OUTPUT("LINE_OUT"),
|
|
|
|
|
2012-03-28 19:51:43 +00:00
|
|
|
SND_SOC_DAPM_SUPPLY("Mic Bias", SGTL5000_CHIP_MIC_CTRL, 8, 0,
|
|
|
|
mic_bias_event,
|
|
|
|
SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
|
2011-02-23 18:08:21 +00:00
|
|
|
|
2012-03-29 16:13:02 +00:00
|
|
|
SND_SOC_DAPM_PGA("HP", SGTL5000_CHIP_ANA_POWER, 4, 0, NULL, 0),
|
|
|
|
SND_SOC_DAPM_PGA("LO", SGTL5000_CHIP_ANA_POWER, 0, 0, NULL, 0),
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
SND_SOC_DAPM_MUX("Capture Mux", SND_SOC_NOPM, 0, 0, &adc_mux),
|
|
|
|
SND_SOC_DAPM_MUX("Headphone Mux", SND_SOC_NOPM, 0, 0, &dac_mux),
|
|
|
|
|
|
|
|
/* aif for i2s input */
|
|
|
|
SND_SOC_DAPM_AIF_IN("AIFIN", "Playback",
|
|
|
|
0, SGTL5000_CHIP_DIG_POWER,
|
|
|
|
0, 0),
|
|
|
|
|
|
|
|
/* aif for i2s output */
|
|
|
|
SND_SOC_DAPM_AIF_OUT("AIFOUT", "Capture",
|
|
|
|
0, SGTL5000_CHIP_DIG_POWER,
|
|
|
|
1, 0),
|
|
|
|
|
2012-03-29 16:13:02 +00:00
|
|
|
SND_SOC_DAPM_ADC("ADC", "Capture", SGTL5000_CHIP_ANA_POWER, 1, 0),
|
2011-02-23 18:08:21 +00:00
|
|
|
SND_SOC_DAPM_DAC("DAC", "Playback", SGTL5000_CHIP_ANA_POWER, 3, 0),
|
2013-05-28 18:55:56 +00:00
|
|
|
|
|
|
|
SND_SOC_DAPM_PRE("VAG_POWER_PRE", power_vag_event),
|
|
|
|
SND_SOC_DAPM_POST("VAG_POWER_POST", power_vag_event),
|
2011-02-23 18:08:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* routes for sgtl5000 */
|
2012-01-22 16:49:42 +00:00
|
|
|
static const struct snd_soc_dapm_route sgtl5000_dapm_routes[] = {
|
2011-02-23 18:08:21 +00:00
|
|
|
{"Capture Mux", "LINE_IN", "LINE_IN"}, /* line_in --> adc_mux */
|
|
|
|
{"Capture Mux", "MIC_IN", "MIC_IN"}, /* mic_in --> adc_mux */
|
|
|
|
|
|
|
|
{"ADC", NULL, "Capture Mux"}, /* adc_mux --> adc */
|
|
|
|
{"AIFOUT", NULL, "ADC"}, /* adc --> i2s_out */
|
|
|
|
|
|
|
|
{"DAC", NULL, "AIFIN"}, /* i2s-->dac,skip audio mux */
|
|
|
|
{"Headphone Mux", "DAC", "DAC"}, /* dac --> hp_mux */
|
|
|
|
{"LO", NULL, "DAC"}, /* dac --> line_out */
|
|
|
|
|
|
|
|
{"Headphone Mux", "LINE_IN", "LINE_IN"},/* line_in --> hp_mux */
|
|
|
|
{"HP", NULL, "Headphone Mux"}, /* hp_mux --> hp */
|
|
|
|
|
|
|
|
{"LINE_OUT", NULL, "LO"},
|
|
|
|
{"HP_OUT", NULL, "HP"},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* custom function to fetch info of PCM playback volume */
|
|
|
|
static int dac_info_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = 2;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = 0xfc - 0x3c;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* custom function to get of PCM playback volume
|
|
|
|
*
|
|
|
|
* dac volume register
|
|
|
|
* 15-------------8-7--------------0
|
|
|
|
* | R channel vol | L channel vol |
|
|
|
|
* -------------------------------
|
|
|
|
*
|
|
|
|
* PCM volume with 0.5017 dB steps from 0 to -90 dB
|
|
|
|
*
|
|
|
|
* register values map to dB
|
|
|
|
* 0x3B and less = Reserved
|
|
|
|
* 0x3C = 0 dB
|
|
|
|
* 0x3D = -0.5 dB
|
|
|
|
* 0xF0 = -90 dB
|
|
|
|
* 0xFC and greater = Muted
|
|
|
|
*
|
|
|
|
* register value map to userspace value
|
|
|
|
*
|
|
|
|
* register value 0x3c(0dB) 0xf0(-90dB)0xfc
|
|
|
|
* ------------------------------
|
|
|
|
* userspace value 0xc0 0
|
|
|
|
*/
|
|
|
|
static int dac_get_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2014-03-18 08:02:04 +00:00
|
|
|
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
|
2011-02-23 18:08:21 +00:00
|
|
|
int reg;
|
|
|
|
int l;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
reg = snd_soc_read(codec, SGTL5000_CHIP_DAC_VOL);
|
|
|
|
|
|
|
|
/* get left channel volume */
|
|
|
|
l = (reg & SGTL5000_DAC_VOL_LEFT_MASK) >> SGTL5000_DAC_VOL_LEFT_SHIFT;
|
|
|
|
|
|
|
|
/* get right channel volume */
|
|
|
|
r = (reg & SGTL5000_DAC_VOL_RIGHT_MASK) >> SGTL5000_DAC_VOL_RIGHT_SHIFT;
|
|
|
|
|
|
|
|
/* make sure value fall in (0x3c,0xfc) */
|
|
|
|
l = clamp(l, 0x3c, 0xfc);
|
|
|
|
r = clamp(r, 0x3c, 0xfc);
|
|
|
|
|
|
|
|
/* invert it and map to userspace value */
|
|
|
|
l = 0xfc - l;
|
|
|
|
r = 0xfc - r;
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] = l;
|
|
|
|
ucontrol->value.integer.value[1] = r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* custom function to put of PCM playback volume
|
|
|
|
*
|
|
|
|
* dac volume register
|
|
|
|
* 15-------------8-7--------------0
|
|
|
|
* | R channel vol | L channel vol |
|
|
|
|
* -------------------------------
|
|
|
|
*
|
|
|
|
* PCM volume with 0.5017 dB steps from 0 to -90 dB
|
|
|
|
*
|
|
|
|
* register values map to dB
|
|
|
|
* 0x3B and less = Reserved
|
|
|
|
* 0x3C = 0 dB
|
|
|
|
* 0x3D = -0.5 dB
|
|
|
|
* 0xF0 = -90 dB
|
|
|
|
* 0xFC and greater = Muted
|
|
|
|
*
|
|
|
|
* userspace value map to register value
|
|
|
|
*
|
|
|
|
* userspace value 0xc0 0
|
|
|
|
* ------------------------------
|
|
|
|
* register value 0x3c(0dB) 0xf0(-90dB)0xfc
|
|
|
|
*/
|
|
|
|
static int dac_put_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2014-03-18 08:02:04 +00:00
|
|
|
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
|
2011-02-23 18:08:21 +00:00
|
|
|
int reg;
|
|
|
|
int l;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
l = ucontrol->value.integer.value[0];
|
|
|
|
r = ucontrol->value.integer.value[1];
|
|
|
|
|
|
|
|
/* make sure userspace volume fall in (0, 0xfc-0x3c) */
|
|
|
|
l = clamp(l, 0, 0xfc - 0x3c);
|
|
|
|
r = clamp(r, 0, 0xfc - 0x3c);
|
|
|
|
|
|
|
|
/* invert it, get the value can be set to register */
|
|
|
|
l = 0xfc - l;
|
|
|
|
r = 0xfc - r;
|
|
|
|
|
|
|
|
/* shift to get the register value */
|
|
|
|
reg = l << SGTL5000_DAC_VOL_LEFT_SHIFT |
|
|
|
|
r << SGTL5000_DAC_VOL_RIGHT_SHIFT;
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_DAC_VOL, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const DECLARE_TLV_DB_SCALE(capture_6db_attenuate, -600, 600, 0);
|
|
|
|
|
|
|
|
/* tlv for mic gain, 0db 20db 30db 40db */
|
|
|
|
static const unsigned int mic_gain_tlv[] = {
|
2011-11-20 14:12:26 +00:00
|
|
|
TLV_DB_RANGE_HEAD(2),
|
2011-02-23 18:08:21 +00:00
|
|
|
0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
|
|
|
|
1, 3, TLV_DB_SCALE_ITEM(2000, 1000, 0),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* tlv for hp volume, -51.5db to 12.0db, step .5db */
|
|
|
|
static const DECLARE_TLV_DB_SCALE(headphone_volume, -5150, 50, 0);
|
|
|
|
|
|
|
|
static const struct snd_kcontrol_new sgtl5000_snd_controls[] = {
|
|
|
|
/* SOC_DOUBLE_S8_TLV with invert */
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "PCM Playback Volume",
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,
|
|
|
|
.info = dac_info_volsw,
|
|
|
|
.get = dac_get_volsw,
|
|
|
|
.put = dac_put_volsw,
|
|
|
|
},
|
|
|
|
|
|
|
|
SOC_DOUBLE("Capture Volume", SGTL5000_CHIP_ANA_ADC_CTRL, 0, 4, 0xf, 0),
|
|
|
|
SOC_SINGLE_TLV("Capture Attenuate Switch (-6dB)",
|
|
|
|
SGTL5000_CHIP_ANA_ADC_CTRL,
|
2013-07-31 14:44:30 +00:00
|
|
|
8, 1, 0, capture_6db_attenuate),
|
2011-02-23 18:08:21 +00:00
|
|
|
SOC_SINGLE("Capture ZC Switch", SGTL5000_CHIP_ANA_CTRL, 1, 1, 0),
|
|
|
|
|
|
|
|
SOC_DOUBLE_TLV("Headphone Playback Volume",
|
|
|
|
SGTL5000_CHIP_ANA_HP_CTRL,
|
|
|
|
0, 8,
|
|
|
|
0x7f, 1,
|
|
|
|
headphone_volume),
|
|
|
|
SOC_SINGLE("Headphone Playback ZC Switch", SGTL5000_CHIP_ANA_CTRL,
|
|
|
|
5, 1, 0),
|
|
|
|
|
|
|
|
SOC_SINGLE_TLV("Mic Volume", SGTL5000_CHIP_MIC_CTRL,
|
2012-12-23 17:45:31 +00:00
|
|
|
0, 3, 0, mic_gain_tlv),
|
2011-02-23 18:08:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* mute the codec used by alsa core */
|
|
|
|
static int sgtl5000_digital_mute(struct snd_soc_dai *codec_dai, int mute)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
|
|
|
u16 adcdac_ctrl = SGTL5000_DAC_MUTE_LEFT | SGTL5000_DAC_MUTE_RIGHT;
|
|
|
|
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ADCDAC_CTRL,
|
|
|
|
adcdac_ctrl, mute ? adcdac_ctrl : 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set codec format */
|
|
|
|
static int sgtl5000_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
u16 i2sctl = 0;
|
|
|
|
|
|
|
|
sgtl5000->master = 0;
|
|
|
|
/*
|
|
|
|
* i2s clock and frame master setting.
|
|
|
|
* ONLY support:
|
|
|
|
* - clock and frame slave,
|
|
|
|
* - clock and frame master
|
|
|
|
*/
|
|
|
|
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFS:
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFM:
|
|
|
|
i2sctl |= SGTL5000_I2S_MASTER;
|
|
|
|
sgtl5000->master = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* setting i2s data format */
|
|
|
|
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_DSP_A:
|
|
|
|
i2sctl |= SGTL5000_I2S_MODE_PCM;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_DSP_B:
|
|
|
|
i2sctl |= SGTL5000_I2S_MODE_PCM;
|
|
|
|
i2sctl |= SGTL5000_I2S_LRALIGN;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_I2S:
|
|
|
|
i2sctl |= SGTL5000_I2S_MODE_I2S_LJ;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_RIGHT_J:
|
|
|
|
i2sctl |= SGTL5000_I2S_MODE_RJ;
|
|
|
|
i2sctl |= SGTL5000_I2S_LRPOL;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_LEFT_J:
|
|
|
|
i2sctl |= SGTL5000_I2S_MODE_I2S_LJ;
|
|
|
|
i2sctl |= SGTL5000_I2S_LRALIGN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sgtl5000->fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
|
|
|
|
|
|
|
|
/* Clock inversion */
|
|
|
|
switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_NB_NF:
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_IB_NF:
|
|
|
|
i2sctl |= SGTL5000_I2S_SCLK_INV;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_I2S_CTRL, i2sctl);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set codec sysclk */
|
|
|
|
static int sgtl5000_set_dai_sysclk(struct snd_soc_dai *codec_dai,
|
|
|
|
int clk_id, unsigned int freq, int dir)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = codec_dai->codec;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
|
|
|
|
switch (clk_id) {
|
|
|
|
case SGTL5000_SYSCLK:
|
|
|
|
sgtl5000->sysclk = freq;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set clock according to i2s frame clock,
|
2014-10-07 13:50:56 +00:00
|
|
|
* sgtl5000 provides 2 clock sources:
|
|
|
|
* 1. sys_mclk: sample freq can only be configured to
|
2011-02-23 18:08:21 +00:00
|
|
|
* 1/256, 1/384, 1/512 of sys_mclk.
|
2014-10-07 13:50:56 +00:00
|
|
|
* 2. pll: can derive any audio clocks.
|
2011-02-23 18:08:21 +00:00
|
|
|
*
|
|
|
|
* clock setting rules:
|
2014-10-07 13:50:56 +00:00
|
|
|
* 1. in slave mode, only sys_mclk can be used
|
|
|
|
* 2. as constraint by sys_mclk, sample freq should be set to 32 kHz, 44.1 kHz
|
|
|
|
* and above.
|
|
|
|
* 3. usage of sys_mclk is preferred over pll to save power.
|
2011-02-23 18:08:21 +00:00
|
|
|
*/
|
|
|
|
static int sgtl5000_set_clock(struct snd_soc_codec *codec, int frame_rate)
|
|
|
|
{
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
int clk_ctl = 0;
|
|
|
|
int sys_fs; /* sample freq */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sample freq should be divided by frame clock,
|
2014-10-07 13:50:56 +00:00
|
|
|
* if frame clock is lower than 44.1 kHz, sample freq should be set to
|
|
|
|
* 32 kHz or 44.1 kHz.
|
2011-02-23 18:08:21 +00:00
|
|
|
*/
|
|
|
|
switch (frame_rate) {
|
|
|
|
case 8000:
|
|
|
|
case 16000:
|
|
|
|
sys_fs = 32000;
|
|
|
|
break;
|
|
|
|
case 11025:
|
|
|
|
case 22050:
|
|
|
|
sys_fs = 44100;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
sys_fs = frame_rate;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set divided factor of frame clock */
|
|
|
|
switch (sys_fs / frame_rate) {
|
|
|
|
case 4:
|
|
|
|
clk_ctl |= SGTL5000_RATE_MODE_DIV_4 << SGTL5000_RATE_MODE_SHIFT;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
clk_ctl |= SGTL5000_RATE_MODE_DIV_2 << SGTL5000_RATE_MODE_SHIFT;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
clk_ctl |= SGTL5000_RATE_MODE_DIV_1 << SGTL5000_RATE_MODE_SHIFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the sys_fs according to frame rate */
|
|
|
|
switch (sys_fs) {
|
|
|
|
case 32000:
|
|
|
|
clk_ctl |= SGTL5000_SYS_FS_32k << SGTL5000_SYS_FS_SHIFT;
|
|
|
|
break;
|
|
|
|
case 44100:
|
|
|
|
clk_ctl |= SGTL5000_SYS_FS_44_1k << SGTL5000_SYS_FS_SHIFT;
|
|
|
|
break;
|
|
|
|
case 48000:
|
|
|
|
clk_ctl |= SGTL5000_SYS_FS_48k << SGTL5000_SYS_FS_SHIFT;
|
|
|
|
break;
|
|
|
|
case 96000:
|
|
|
|
clk_ctl |= SGTL5000_SYS_FS_96k << SGTL5000_SYS_FS_SHIFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(codec->dev, "frame rate %d not supported\n",
|
|
|
|
frame_rate);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* calculate the divider of mclk/sample_freq,
|
2014-10-07 13:50:56 +00:00
|
|
|
* factor of freq = 96 kHz can only be 256, since mclk is in the range
|
|
|
|
* of 8 MHz - 27 MHz
|
2011-02-23 18:08:21 +00:00
|
|
|
*/
|
ASoC: sgtl5000: Allow 8kHz playback in codec slave mode
When trying to play a 8kHz file with codec in slave mode we get the following
error on a mx28evk:
$ aplay -Dhw:0,0 stereo_8k.wav
Playing WAVE 'stereo_8k.wav' : Signed 16 bit Little Endian, Rate 8000 Hz, Stereo
[ 21.218647] sgtl5000 0-000a: PLL not supported in slave mode
[ 21.224559] sgtl5000 0-000a: 128 ratio is not supported. SYS_MCLK needs to be 256, 384 or 512 * fs
[ 21.233687] sgtl5000 0-000a: ASoC: can't set sgtl5000 hw params: -22
aplay: set_params:1123: Unable to install hw params:
This error happens because we are using 'sys_fs' instead of 'frame_rate' in the
valid ratio check.
Use the real'frame_rate' so that the ratio is correctly calculated and the
playback can run.
sgtl5000 codec manual states that in 'Synchronous SYS_MCLK input' mode that the
following SYS_CLK frequencies are allowed: 256*fs, 384*fs, 512*fs.
, where fs is the sampling frequency, which can be in the range of:
8, 11.025, 16, 22.5, 32, 44.1, 48, 96 kHz.
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-11-27 15:02:01 +00:00
|
|
|
switch (sgtl5000->sysclk / frame_rate) {
|
2011-02-23 18:08:21 +00:00
|
|
|
case 256:
|
|
|
|
clk_ctl |= SGTL5000_MCLK_FREQ_256FS <<
|
|
|
|
SGTL5000_MCLK_FREQ_SHIFT;
|
|
|
|
break;
|
|
|
|
case 384:
|
|
|
|
clk_ctl |= SGTL5000_MCLK_FREQ_384FS <<
|
|
|
|
SGTL5000_MCLK_FREQ_SHIFT;
|
|
|
|
break;
|
|
|
|
case 512:
|
|
|
|
clk_ctl |= SGTL5000_MCLK_FREQ_512FS <<
|
|
|
|
SGTL5000_MCLK_FREQ_SHIFT;
|
|
|
|
break;
|
|
|
|
default:
|
2014-10-07 13:50:56 +00:00
|
|
|
/* if mclk does not satisfy the divider, use pll */
|
2011-02-23 18:08:21 +00:00
|
|
|
if (sgtl5000->master) {
|
|
|
|
clk_ctl |= SGTL5000_MCLK_FREQ_PLL <<
|
|
|
|
SGTL5000_MCLK_FREQ_SHIFT;
|
|
|
|
} else {
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"PLL not supported in slave mode\n");
|
2014-10-02 19:16:50 +00:00
|
|
|
dev_err(codec->dev, "%d ratio is not supported. "
|
|
|
|
"SYS_MCLK needs to be 256, 384 or 512 * fs\n",
|
ASoC: sgtl5000: Allow 8kHz playback in codec slave mode
When trying to play a 8kHz file with codec in slave mode we get the following
error on a mx28evk:
$ aplay -Dhw:0,0 stereo_8k.wav
Playing WAVE 'stereo_8k.wav' : Signed 16 bit Little Endian, Rate 8000 Hz, Stereo
[ 21.218647] sgtl5000 0-000a: PLL not supported in slave mode
[ 21.224559] sgtl5000 0-000a: 128 ratio is not supported. SYS_MCLK needs to be 256, 384 or 512 * fs
[ 21.233687] sgtl5000 0-000a: ASoC: can't set sgtl5000 hw params: -22
aplay: set_params:1123: Unable to install hw params:
This error happens because we are using 'sys_fs' instead of 'frame_rate' in the
valid ratio check.
Use the real'frame_rate' so that the ratio is correctly calculated and the
playback can run.
sgtl5000 codec manual states that in 'Synchronous SYS_MCLK input' mode that the
following SYS_CLK frequencies are allowed: 256*fs, 384*fs, 512*fs.
, where fs is the sampling frequency, which can be in the range of:
8, 11.025, 16, 22.5, 32, 44.1, 48, 96 kHz.
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-11-27 15:02:01 +00:00
|
|
|
sgtl5000->sysclk / frame_rate);
|
2011-02-23 18:08:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if using pll, please check manual 6.4.2 for detail */
|
|
|
|
if ((clk_ctl & SGTL5000_MCLK_FREQ_MASK) == SGTL5000_MCLK_FREQ_PLL) {
|
|
|
|
u64 out, t;
|
|
|
|
int div2;
|
|
|
|
int pll_ctl;
|
|
|
|
unsigned int in, int_div, frac_div;
|
|
|
|
|
|
|
|
if (sgtl5000->sysclk > 17000000) {
|
|
|
|
div2 = 1;
|
|
|
|
in = sgtl5000->sysclk / 2;
|
|
|
|
} else {
|
|
|
|
div2 = 0;
|
|
|
|
in = sgtl5000->sysclk;
|
|
|
|
}
|
|
|
|
if (sys_fs == 44100)
|
|
|
|
out = 180633600;
|
|
|
|
else
|
|
|
|
out = 196608000;
|
|
|
|
t = do_div(out, in);
|
|
|
|
int_div = out;
|
|
|
|
t *= 2048;
|
|
|
|
do_div(t, in);
|
|
|
|
frac_div = t;
|
|
|
|
pll_ctl = int_div << SGTL5000_PLL_INT_DIV_SHIFT |
|
|
|
|
frac_div << SGTL5000_PLL_FRAC_DIV_SHIFT;
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_PLL_CTRL, pll_ctl);
|
|
|
|
if (div2)
|
|
|
|
snd_soc_update_bits(codec,
|
|
|
|
SGTL5000_CHIP_CLK_TOP_CTRL,
|
|
|
|
SGTL5000_INPUT_FREQ_DIV2,
|
|
|
|
SGTL5000_INPUT_FREQ_DIV2);
|
|
|
|
else
|
|
|
|
snd_soc_update_bits(codec,
|
|
|
|
SGTL5000_CHIP_CLK_TOP_CTRL,
|
|
|
|
SGTL5000_INPUT_FREQ_DIV2,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* power up pll */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP,
|
|
|
|
SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP);
|
2013-08-05 07:36:02 +00:00
|
|
|
|
|
|
|
/* if using pll, clk_ctrl must be set after pll power up */
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_CLK_CTRL, clk_ctl);
|
2011-02-23 18:08:21 +00:00
|
|
|
} else {
|
2013-08-05 07:36:02 +00:00
|
|
|
/* otherwise, clk_ctrl must be set before pll power down */
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_CLK_CTRL, clk_ctl);
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
/* power down pll */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set PCM DAI bit size and sample rate.
|
|
|
|
* input: params_rate, params_fmt
|
|
|
|
*/
|
|
|
|
static int sgtl5000_pcm_hw_params(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *params,
|
|
|
|
struct snd_soc_dai *dai)
|
|
|
|
{
|
2012-04-04 14:58:16 +00:00
|
|
|
struct snd_soc_codec *codec = dai->codec;
|
2011-02-23 18:08:21 +00:00
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
int channels = params_channels(params);
|
|
|
|
int i2s_ctl = 0;
|
|
|
|
int stereo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* sysclk should already set */
|
|
|
|
if (!sgtl5000->sysclk) {
|
|
|
|
dev_err(codec->dev, "%s: set sysclk first!\n", __func__);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
|
|
stereo = SGTL5000_DAC_STEREO;
|
|
|
|
else
|
|
|
|
stereo = SGTL5000_ADC_STEREO;
|
|
|
|
|
|
|
|
/* set mono to save power */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER, stereo,
|
|
|
|
channels == 1 ? 0 : stereo);
|
|
|
|
|
|
|
|
/* set codec clock base on lrclk */
|
|
|
|
ret = sgtl5000_set_clock(codec, params_rate(params));
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* set i2s data format */
|
2014-07-31 11:46:05 +00:00
|
|
|
switch (params_width(params)) {
|
|
|
|
case 16:
|
2011-02-23 18:08:21 +00:00
|
|
|
if (sgtl5000->fmt == SND_SOC_DAIFMT_RIGHT_J)
|
|
|
|
return -EINVAL;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_DLEN_16 << SGTL5000_I2S_DLEN_SHIFT;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_32FS <<
|
|
|
|
SGTL5000_I2S_SCLKFREQ_SHIFT;
|
|
|
|
break;
|
2014-07-31 11:46:05 +00:00
|
|
|
case 20:
|
2011-02-23 18:08:21 +00:00
|
|
|
i2s_ctl |= SGTL5000_I2S_DLEN_20 << SGTL5000_I2S_DLEN_SHIFT;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
|
|
|
|
SGTL5000_I2S_SCLKFREQ_SHIFT;
|
|
|
|
break;
|
2014-07-31 11:46:05 +00:00
|
|
|
case 24:
|
2011-02-23 18:08:21 +00:00
|
|
|
i2s_ctl |= SGTL5000_I2S_DLEN_24 << SGTL5000_I2S_DLEN_SHIFT;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
|
|
|
|
SGTL5000_I2S_SCLKFREQ_SHIFT;
|
|
|
|
break;
|
2014-07-31 11:46:05 +00:00
|
|
|
case 32:
|
2011-02-23 18:08:21 +00:00
|
|
|
if (sgtl5000->fmt == SND_SOC_DAIFMT_RIGHT_J)
|
|
|
|
return -EINVAL;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_DLEN_32 << SGTL5000_I2S_DLEN_SHIFT;
|
|
|
|
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
|
|
|
|
SGTL5000_I2S_SCLKFREQ_SHIFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-10-21 01:54:43 +00:00
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_I2S_CTRL,
|
|
|
|
SGTL5000_I2S_DLEN_MASK | SGTL5000_I2S_SCLKFREQ_MASK,
|
|
|
|
i2s_ctl);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-22 12:02:33 +00:00
|
|
|
#ifdef CONFIG_REGULATOR
|
2011-02-23 18:08:21 +00:00
|
|
|
static int ldo_regulator_is_enabled(struct regulator_dev *dev)
|
|
|
|
{
|
|
|
|
struct ldo_regulator *ldo = rdev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return ldo->enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ldo_regulator_enable(struct regulator_dev *dev)
|
|
|
|
{
|
|
|
|
struct ldo_regulator *ldo = rdev_get_drvdata(dev);
|
|
|
|
struct snd_soc_codec *codec = (struct snd_soc_codec *)ldo->codec_data;
|
|
|
|
int reg;
|
|
|
|
|
|
|
|
if (ldo_regulator_is_enabled(dev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* set regulator value firstly */
|
|
|
|
reg = (1600 - ldo->voltage / 1000) / 50;
|
|
|
|
reg = clamp(reg, 0x0, 0xf);
|
|
|
|
|
|
|
|
/* amend the voltage value, unit: uV */
|
|
|
|
ldo->voltage = (1600 - reg * 50) * 1000;
|
|
|
|
|
|
|
|
/* set voltage to register */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
|
2011-10-20 10:49:29 +00:00
|
|
|
SGTL5000_LINREG_VDDD_MASK, reg);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_LINEREG_D_POWERUP,
|
|
|
|
SGTL5000_LINEREG_D_POWERUP);
|
|
|
|
|
2014-10-07 13:50:56 +00:00
|
|
|
/* when internal ldo is enabled, simple digital power can be disabled */
|
2011-02-23 18:08:21 +00:00
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_LINREG_SIMPLE_POWERUP,
|
|
|
|
0);
|
|
|
|
|
|
|
|
ldo->enabled = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ldo_regulator_disable(struct regulator_dev *dev)
|
|
|
|
{
|
|
|
|
struct ldo_regulator *ldo = rdev_get_drvdata(dev);
|
|
|
|
struct snd_soc_codec *codec = (struct snd_soc_codec *)ldo->codec_data;
|
|
|
|
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_LINEREG_D_POWERUP,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* clear voltage info */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
|
2011-10-20 10:49:29 +00:00
|
|
|
SGTL5000_LINREG_VDDD_MASK, 0);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
ldo->enabled = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ldo_regulator_get_voltage(struct regulator_dev *dev)
|
|
|
|
{
|
|
|
|
struct ldo_regulator *ldo = rdev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return ldo->voltage;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct regulator_ops ldo_regulator_ops = {
|
|
|
|
.is_enabled = ldo_regulator_is_enabled,
|
|
|
|
.enable = ldo_regulator_enable,
|
|
|
|
.disable = ldo_regulator_disable,
|
|
|
|
.get_voltage = ldo_regulator_get_voltage,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ldo_regulator_register(struct snd_soc_codec *codec,
|
|
|
|
struct regulator_init_data *init_data,
|
|
|
|
int voltage)
|
|
|
|
{
|
|
|
|
struct ldo_regulator *ldo;
|
2011-10-20 10:32:59 +00:00
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
2012-04-03 23:50:22 +00:00
|
|
|
struct regulator_config config = { };
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
ldo = kzalloc(sizeof(struct ldo_regulator), GFP_KERNEL);
|
|
|
|
|
2014-06-20 09:58:59 +00:00
|
|
|
if (!ldo)
|
2011-02-23 18:08:21 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ldo->desc.name = kstrdup(dev_name(codec->dev), GFP_KERNEL);
|
|
|
|
if (!ldo->desc.name) {
|
|
|
|
kfree(ldo);
|
|
|
|
dev_err(codec->dev, "failed to allocate decs name memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
ldo->desc.type = REGULATOR_VOLTAGE;
|
|
|
|
ldo->desc.owner = THIS_MODULE;
|
|
|
|
ldo->desc.ops = &ldo_regulator_ops;
|
|
|
|
ldo->desc.n_voltages = 1;
|
|
|
|
|
|
|
|
ldo->codec_data = codec;
|
|
|
|
ldo->voltage = voltage;
|
|
|
|
|
2012-04-03 23:50:22 +00:00
|
|
|
config.dev = codec->dev;
|
|
|
|
config.driver_data = ldo;
|
|
|
|
config.init_data = init_data;
|
|
|
|
|
|
|
|
ldo->dev = regulator_register(&ldo->desc, &config);
|
2011-02-23 18:08:21 +00:00
|
|
|
if (IS_ERR(ldo->dev)) {
|
2011-03-08 11:39:24 +00:00
|
|
|
int ret = PTR_ERR(ldo->dev);
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
dev_err(codec->dev, "failed to register regulator\n");
|
|
|
|
kfree(ldo->desc.name);
|
|
|
|
kfree(ldo);
|
|
|
|
|
2011-03-08 11:39:24 +00:00
|
|
|
return ret;
|
2011-02-23 18:08:21 +00:00
|
|
|
}
|
2011-10-20 10:32:59 +00:00
|
|
|
sgtl5000->ldo = ldo;
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ldo_regulator_remove(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
struct ldo_regulator *ldo = sgtl5000->ldo;
|
|
|
|
|
|
|
|
if (!ldo)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
regulator_unregister(ldo->dev);
|
|
|
|
kfree(ldo->desc.name);
|
|
|
|
kfree(ldo);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-03-22 12:02:33 +00:00
|
|
|
#else
|
|
|
|
static int ldo_regulator_register(struct snd_soc_codec *codec,
|
|
|
|
struct regulator_init_data *init_data,
|
|
|
|
int voltage)
|
|
|
|
{
|
2011-07-18 15:53:04 +00:00
|
|
|
dev_err(codec->dev, "this setup needs regulator support in the kernel\n");
|
2011-03-22 12:02:33 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ldo_regulator_remove(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* set dac bias
|
|
|
|
* common state changes:
|
|
|
|
* startup:
|
|
|
|
* off --> standby --> prepare --> on
|
|
|
|
* standby --> prepare --> on
|
|
|
|
*
|
|
|
|
* stop:
|
|
|
|
* on --> prepare --> standby
|
|
|
|
*/
|
|
|
|
static int sgtl5000_set_bias_level(struct snd_soc_codec *codec,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
|
|
|
|
switch (level) {
|
|
|
|
case SND_SOC_BIAS_ON:
|
|
|
|
case SND_SOC_BIAS_PREPARE:
|
|
|
|
break;
|
|
|
|
case SND_SOC_BIAS_STANDBY:
|
|
|
|
if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
|
|
|
|
ret = regulator_bulk_enable(
|
|
|
|
ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
udelay(10);
|
2013-06-03 09:20:39 +00:00
|
|
|
|
|
|
|
regcache_cache_only(sgtl5000->regmap, false);
|
|
|
|
|
|
|
|
ret = regcache_sync(sgtl5000->regmap);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"Failed to restore cache: %d\n", ret);
|
|
|
|
|
|
|
|
regcache_cache_only(sgtl5000->regmap, true);
|
|
|
|
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2011-02-23 18:08:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case SND_SOC_BIAS_OFF:
|
2013-06-03 09:20:39 +00:00
|
|
|
regcache_cache_only(sgtl5000->regmap, true);
|
2011-02-23 18:08:21 +00:00
|
|
|
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->dapm.bias_level = level;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SGTL5000_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
|
|
|
|
SNDRV_PCM_FMTBIT_S20_3LE |\
|
|
|
|
SNDRV_PCM_FMTBIT_S24_LE |\
|
|
|
|
SNDRV_PCM_FMTBIT_S32_LE)
|
|
|
|
|
2011-11-23 10:40:40 +00:00
|
|
|
static const struct snd_soc_dai_ops sgtl5000_ops = {
|
2011-02-23 18:08:21 +00:00
|
|
|
.hw_params = sgtl5000_pcm_hw_params,
|
|
|
|
.digital_mute = sgtl5000_digital_mute,
|
|
|
|
.set_fmt = sgtl5000_set_dai_fmt,
|
|
|
|
.set_sysclk = sgtl5000_set_dai_sysclk,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_soc_dai_driver sgtl5000_dai = {
|
|
|
|
.name = "sgtl5000",
|
|
|
|
.playback = {
|
|
|
|
.stream_name = "Playback",
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
/*
|
|
|
|
* only support 8~48K + 96K,
|
|
|
|
* TODO modify hw_param to support more
|
|
|
|
*/
|
|
|
|
.rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_96000,
|
|
|
|
.formats = SGTL5000_FORMATS,
|
|
|
|
},
|
|
|
|
.capture = {
|
|
|
|
.stream_name = "Capture",
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_96000,
|
|
|
|
.formats = SGTL5000_FORMATS,
|
|
|
|
},
|
|
|
|
.ops = &sgtl5000_ops,
|
|
|
|
.symmetric_rates = 1,
|
|
|
|
};
|
|
|
|
|
2013-05-04 18:39:34 +00:00
|
|
|
static bool sgtl5000_volatile(struct device *dev, unsigned int reg)
|
2011-02-23 18:08:21 +00:00
|
|
|
{
|
|
|
|
switch (reg) {
|
|
|
|
case SGTL5000_CHIP_ID:
|
|
|
|
case SGTL5000_CHIP_ADCDAC_CTRL:
|
|
|
|
case SGTL5000_CHIP_ANA_STATUS:
|
2013-05-04 18:39:34 +00:00
|
|
|
return true;
|
2011-02-23 18:08:21 +00:00
|
|
|
}
|
|
|
|
|
2013-05-04 18:39:34 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool sgtl5000_readable(struct device *dev, unsigned int reg)
|
|
|
|
{
|
|
|
|
switch (reg) {
|
|
|
|
case SGTL5000_CHIP_ID:
|
|
|
|
case SGTL5000_CHIP_DIG_POWER:
|
|
|
|
case SGTL5000_CHIP_CLK_CTRL:
|
|
|
|
case SGTL5000_CHIP_I2S_CTRL:
|
|
|
|
case SGTL5000_CHIP_SSS_CTRL:
|
|
|
|
case SGTL5000_CHIP_ADCDAC_CTRL:
|
|
|
|
case SGTL5000_CHIP_DAC_VOL:
|
|
|
|
case SGTL5000_CHIP_PAD_STRENGTH:
|
|
|
|
case SGTL5000_CHIP_ANA_ADC_CTRL:
|
|
|
|
case SGTL5000_CHIP_ANA_HP_CTRL:
|
|
|
|
case SGTL5000_CHIP_ANA_CTRL:
|
|
|
|
case SGTL5000_CHIP_LINREG_CTRL:
|
|
|
|
case SGTL5000_CHIP_REF_CTRL:
|
|
|
|
case SGTL5000_CHIP_MIC_CTRL:
|
|
|
|
case SGTL5000_CHIP_LINE_OUT_CTRL:
|
|
|
|
case SGTL5000_CHIP_LINE_OUT_VOL:
|
|
|
|
case SGTL5000_CHIP_ANA_POWER:
|
|
|
|
case SGTL5000_CHIP_PLL_CTRL:
|
|
|
|
case SGTL5000_CHIP_CLK_TOP_CTRL:
|
|
|
|
case SGTL5000_CHIP_ANA_STATUS:
|
|
|
|
case SGTL5000_CHIP_SHORT_CTRL:
|
|
|
|
case SGTL5000_CHIP_ANA_TEST2:
|
|
|
|
case SGTL5000_DAP_CTRL:
|
|
|
|
case SGTL5000_DAP_PEQ:
|
|
|
|
case SGTL5000_DAP_BASS_ENHANCE:
|
|
|
|
case SGTL5000_DAP_BASS_ENHANCE_CTRL:
|
|
|
|
case SGTL5000_DAP_AUDIO_EQ:
|
|
|
|
case SGTL5000_DAP_SURROUND:
|
|
|
|
case SGTL5000_DAP_FLT_COEF_ACCESS:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B0_MSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B0_LSB:
|
|
|
|
case SGTL5000_DAP_EQ_BASS_BAND0:
|
|
|
|
case SGTL5000_DAP_EQ_BASS_BAND1:
|
|
|
|
case SGTL5000_DAP_EQ_BASS_BAND2:
|
|
|
|
case SGTL5000_DAP_EQ_BASS_BAND3:
|
|
|
|
case SGTL5000_DAP_EQ_BASS_BAND4:
|
|
|
|
case SGTL5000_DAP_MAIN_CHAN:
|
|
|
|
case SGTL5000_DAP_MIX_CHAN:
|
|
|
|
case SGTL5000_DAP_AVC_CTRL:
|
|
|
|
case SGTL5000_DAP_AVC_THRESHOLD:
|
|
|
|
case SGTL5000_DAP_AVC_ATTACK:
|
|
|
|
case SGTL5000_DAP_AVC_DECAY:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B1_MSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B1_LSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B2_MSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_B2_LSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_A1_MSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_A1_LSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_A2_MSB:
|
|
|
|
case SGTL5000_DAP_COEF_WR_A2_LSB:
|
|
|
|
return true;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2011-02-23 18:08:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sgtl5000 has 3 internal power supplies:
|
|
|
|
* 1. VAG, normally set to vdda/2
|
2014-10-07 13:50:56 +00:00
|
|
|
* 2. charge pump, set to different value
|
2011-02-23 18:08:21 +00:00
|
|
|
* according to voltage of vdda and vddio
|
|
|
|
* 3. line out VAG, normally set to vddio/2
|
|
|
|
*
|
|
|
|
* and should be set according to:
|
|
|
|
* 1. vddd provided by external or not
|
|
|
|
* 2. vdda and vddio voltage value. > 3.1v or not
|
|
|
|
* 3. chip revision >=0x11 or not. If >=0x11, not use external vddd.
|
|
|
|
*/
|
|
|
|
static int sgtl5000_set_power_regs(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int vddd;
|
|
|
|
int vdda;
|
|
|
|
int vddio;
|
|
|
|
u16 ana_pwr;
|
|
|
|
u16 lreg_ctrl;
|
|
|
|
int vag;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
|
|
|
|
vdda = regulator_get_voltage(sgtl5000->supplies[VDDA].consumer);
|
|
|
|
vddio = regulator_get_voltage(sgtl5000->supplies[VDDIO].consumer);
|
|
|
|
vddd = regulator_get_voltage(sgtl5000->supplies[VDDD].consumer);
|
|
|
|
|
|
|
|
vdda = vdda / 1000;
|
|
|
|
vddio = vddio / 1000;
|
|
|
|
vddd = vddd / 1000;
|
|
|
|
|
|
|
|
if (vdda <= 0 || vddio <= 0 || vddd < 0) {
|
|
|
|
dev_err(codec->dev, "regulator voltage not set correctly\n");
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* according to datasheet, maximum voltage of supplies */
|
|
|
|
if (vdda > 3600 || vddio > 3600 || vddd > 1980) {
|
|
|
|
dev_err(codec->dev,
|
2011-12-28 11:55:15 +00:00
|
|
|
"exceed max voltage vdda %dmV vddio %dmV vddd %dmV\n",
|
2011-02-23 18:08:21 +00:00
|
|
|
vdda, vddio, vddd);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reset value */
|
|
|
|
ana_pwr = snd_soc_read(codec, SGTL5000_CHIP_ANA_POWER);
|
|
|
|
ana_pwr |= SGTL5000_DAC_STEREO |
|
|
|
|
SGTL5000_ADC_STEREO |
|
|
|
|
SGTL5000_REFTOP_POWERUP;
|
|
|
|
lreg_ctrl = snd_soc_read(codec, SGTL5000_CHIP_LINREG_CTRL);
|
|
|
|
|
|
|
|
if (vddio < 3100 && vdda < 3100) {
|
|
|
|
/* enable internal oscillator used for charge pump */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_CLK_TOP_CTRL,
|
|
|
|
SGTL5000_INT_OSC_EN,
|
|
|
|
SGTL5000_INT_OSC_EN);
|
|
|
|
/* Enable VDDC charge pump */
|
|
|
|
ana_pwr |= SGTL5000_VDDC_CHRGPMP_POWERUP;
|
|
|
|
} else if (vddio >= 3100 && vdda >= 3100) {
|
|
|
|
/*
|
|
|
|
* if vddio and vddd > 3.1v,
|
|
|
|
* charge pump should be clean before set ana_pwr
|
|
|
|
*/
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_VDDC_CHRGPMP_POWERUP, 0);
|
|
|
|
|
|
|
|
/* VDDC use VDDIO rail */
|
|
|
|
lreg_ctrl |= SGTL5000_VDDC_ASSN_OVRD;
|
|
|
|
lreg_ctrl |= SGTL5000_VDDC_MAN_ASSN_VDDIO <<
|
|
|
|
SGTL5000_VDDC_MAN_ASSN_SHIFT;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_LINREG_CTRL, lreg_ctrl);
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_ANA_POWER, ana_pwr);
|
|
|
|
|
|
|
|
/* set voltage to register */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
|
2011-10-20 10:49:29 +00:00
|
|
|
SGTL5000_LINREG_VDDD_MASK, 0x8);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if vddd linear reg has been enabled,
|
|
|
|
* simple digital supply should be clear to get
|
|
|
|
* proper VDDD voltage.
|
|
|
|
*/
|
|
|
|
if (ana_pwr & SGTL5000_LINEREG_D_POWERUP)
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_LINREG_SIMPLE_POWERUP,
|
|
|
|
0);
|
|
|
|
else
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
|
|
|
|
SGTL5000_LINREG_SIMPLE_POWERUP |
|
|
|
|
SGTL5000_STARTUP_POWERUP,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set ADC/DAC VAG to vdda / 2,
|
|
|
|
* should stay in range (0.8v, 1.575v)
|
|
|
|
*/
|
|
|
|
vag = vdda / 2;
|
|
|
|
if (vag <= SGTL5000_ANA_GND_BASE)
|
|
|
|
vag = 0;
|
|
|
|
else if (vag >= SGTL5000_ANA_GND_BASE + SGTL5000_ANA_GND_STP *
|
|
|
|
(SGTL5000_ANA_GND_MASK >> SGTL5000_ANA_GND_SHIFT))
|
|
|
|
vag = SGTL5000_ANA_GND_MASK >> SGTL5000_ANA_GND_SHIFT;
|
|
|
|
else
|
|
|
|
vag = (vag - SGTL5000_ANA_GND_BASE) / SGTL5000_ANA_GND_STP;
|
|
|
|
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_REF_CTRL,
|
2011-10-21 01:54:43 +00:00
|
|
|
SGTL5000_ANA_GND_MASK, vag << SGTL5000_ANA_GND_SHIFT);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
/* set line out VAG to vddio / 2, in range (0.8v, 1.675v) */
|
|
|
|
vag = vddio / 2;
|
|
|
|
if (vag <= SGTL5000_LINE_OUT_GND_BASE)
|
|
|
|
vag = 0;
|
|
|
|
else if (vag >= SGTL5000_LINE_OUT_GND_BASE +
|
|
|
|
SGTL5000_LINE_OUT_GND_STP * SGTL5000_LINE_OUT_GND_MAX)
|
|
|
|
vag = SGTL5000_LINE_OUT_GND_MAX;
|
|
|
|
else
|
|
|
|
vag = (vag - SGTL5000_LINE_OUT_GND_BASE) /
|
|
|
|
SGTL5000_LINE_OUT_GND_STP;
|
|
|
|
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_LINE_OUT_CTRL,
|
2011-10-21 01:54:43 +00:00
|
|
|
SGTL5000_LINE_OUT_CURRENT_MASK |
|
|
|
|
SGTL5000_LINE_OUT_GND_MASK,
|
2011-02-23 18:08:21 +00:00
|
|
|
vag << SGTL5000_LINE_OUT_GND_SHIFT |
|
|
|
|
SGTL5000_LINE_OUT_CURRENT_360u <<
|
|
|
|
SGTL5000_LINE_OUT_CURRENT_SHIFT);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-18 15:53:03 +00:00
|
|
|
static int sgtl5000_replace_vddd_with_ldo(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* set internal ldo to 1.2v */
|
|
|
|
ret = ldo_regulator_register(codec, &ldo_init_data, LDO_VOLTAGE);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"Failed to register vddd internal supplies: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
sgtl5000->supplies[VDDD].supply = LDO_CONSUMER_NAME;
|
|
|
|
|
|
|
|
dev_info(codec->dev, "Using internal LDO instead of VDDD\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
static int sgtl5000_enable_regulators(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
int external_vddd = 0;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
ASoC: sgtl5000: clean up sgtl5000_enable_regulators()
Function sgtl5000_enable_regulators() is somehow odd in handling the
optional external VDDD supply. The driver can only enable this supply
on SGTL5000 chip before revision 0x11, and of course when this external
VDDD is present. It currently does something like below.
1. Check if regulator_bulk_get() on VDDA, VDDIO and VDDD will fail. If
it fails, VDDD must be absent and it falls on internal LDO by calling
sgtl5000_replace_vddd_with_ldo(). Otherwise, VDDD is used. And in
either case, regulator_bulk_enable() will be called to enable
3 supplies.
2. In case that SGTL5000 revision is later than 0x11, even if external
VDDD is present, it has to roll back the 'enable' and 'get' calls
with regulator_bulk_disable() and regulator_bulk_free(), and starts
over again by calling sgtl5000_replace_vddd_with_ldo() and
regulator_bulk_enable().
Such back and forth calls sequence is complicated and unnecessary.
Also, since commit 4ddfebd (regulator: core: Provide a dummy regulator
with full constraints), regulator_bulk_get() will always succeeds
because of the dummy regulator. Thus the VDDD detection is broken.
The patch changes the flow to something like the following, which should
be more reasonable and clear, and also fix the VDDD detection breakage.
1. Check if we're running a chip before revision 0x11, on which an
external VDDD can possibly be an option.
2. If it is an early revision, call regulator_get_optional() to detect
whether an external VDDD supply is available.
3. If external VDDD is present, call sgtl5000_replace_vddd_with_ldo() to
update sgtl5000->supplies info.
4. Drop regulator_bulk_get() call in sgtl5000_replace_vddd_with_ldo(),
and call it in sgtl5000_enable_regulators() no matter it's an
external VDDD or internal LDO.
5. Call regulator_bulk_enable() to enable these 3 regulators.
Signed-off-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-12-13 06:43:03 +00:00
|
|
|
struct regulator *vddd;
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sgtl5000->supplies); i++)
|
|
|
|
sgtl5000->supplies[i].supply = supply_names[i];
|
|
|
|
|
ASoC: sgtl5000: clean up sgtl5000_enable_regulators()
Function sgtl5000_enable_regulators() is somehow odd in handling the
optional external VDDD supply. The driver can only enable this supply
on SGTL5000 chip before revision 0x11, and of course when this external
VDDD is present. It currently does something like below.
1. Check if regulator_bulk_get() on VDDA, VDDIO and VDDD will fail. If
it fails, VDDD must be absent and it falls on internal LDO by calling
sgtl5000_replace_vddd_with_ldo(). Otherwise, VDDD is used. And in
either case, regulator_bulk_enable() will be called to enable
3 supplies.
2. In case that SGTL5000 revision is later than 0x11, even if external
VDDD is present, it has to roll back the 'enable' and 'get' calls
with regulator_bulk_disable() and regulator_bulk_free(), and starts
over again by calling sgtl5000_replace_vddd_with_ldo() and
regulator_bulk_enable().
Such back and forth calls sequence is complicated and unnecessary.
Also, since commit 4ddfebd (regulator: core: Provide a dummy regulator
with full constraints), regulator_bulk_get() will always succeeds
because of the dummy regulator. Thus the VDDD detection is broken.
The patch changes the flow to something like the following, which should
be more reasonable and clear, and also fix the VDDD detection breakage.
1. Check if we're running a chip before revision 0x11, on which an
external VDDD can possibly be an option.
2. If it is an early revision, call regulator_get_optional() to detect
whether an external VDDD supply is available.
3. If external VDDD is present, call sgtl5000_replace_vddd_with_ldo() to
update sgtl5000->supplies info.
4. Drop regulator_bulk_get() call in sgtl5000_replace_vddd_with_ldo(),
and call it in sgtl5000_enable_regulators() no matter it's an
external VDDD or internal LDO.
5. Call regulator_bulk_enable() to enable these 3 regulators.
Signed-off-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-12-13 06:43:03 +00:00
|
|
|
/* External VDDD only works before revision 0x11 */
|
|
|
|
if (sgtl5000->revision < 0x11) {
|
|
|
|
vddd = regulator_get_optional(codec->dev, "VDDD");
|
|
|
|
if (IS_ERR(vddd)) {
|
|
|
|
/* See if it's just not registered yet */
|
|
|
|
if (PTR_ERR(vddd) == -EPROBE_DEFER)
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
} else {
|
|
|
|
external_vddd = 1;
|
|
|
|
regulator_put(vddd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!external_vddd) {
|
2011-07-18 15:53:03 +00:00
|
|
|
ret = sgtl5000_replace_vddd_with_ldo(codec);
|
|
|
|
if (ret)
|
2011-02-23 18:08:21 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
ASoC: sgtl5000: Fix driver unbound
Using the sgtl5000 codec driver as a module and trying to remove it causes the
followig kernel oops:
root@freescale /$ rmmod snd-soc-imx-sgtl5000
[ 117.122920] ------------[ cut here ]------------
[ 117.127609] WARNING: CPU: 0 PID: 631 at drivers/regulator/core.c:3604 regula)
[ 117.137046] Modules linked in: snd_soc_imx_sgtl5000(-) snd_soc_sgtl5000 evbug
[ 117.144315] CPU: 0 PID: 631 Comm: rmmod Not tainted 3.16.0-rc3-next-201407043
[ 117.153366] Backtrace:
[ 117.155865] [<80011e5c>] (dump_backtrace) from [<80011ff8>] (show_stack+0x18)
[ 117.163484] r6:802fcc48 r5:00000000 r4:00000000 r3:00000000
[ 117.169228] [<80011fe0>] (show_stack) from [<80668cc0>] (dump_stack+0x88/0xa)
[ 117.176508] [<80668c38>] (dump_stack) from [<80029a38>] (warn_slowpath_commo)
[ 117.184696] r5:00000009 r4:00000000
[ 117.188322] [<800299c8>] (warn_slowpath_common) from [<80029a80>] (warn_slow)
[ 117.197150] r8:dd60d600 r7:ddfa6d00 r6:dd5d9064 r5:dd5e0f90 r4:dd5d9400
[ 117.203983] [<80029a5c>] (warn_slowpath_null) from [<802fcc48>] (regulator_u)
[ 117.212828] [<802fcb74>] (regulator_unregister) from [<7f0047c4>] (ldo_regul)
[ 117.223475] r4:dd59e300 r3:dd5e0f90
[ 117.227100] [<7f00479c>] (ldo_regulator_remove [snd_soc_sgtl5000]) from [<7f)
[ 117.238959] r4:dd5d8000 r3:ddd51420
[ 117.242623] [<7f0047dc>] (sgtl5000_remove [snd_soc_sgtl5000]) from [<804e5b1)
[ 117.252489] r5:00000000 r4:dd5d8000
[ 117.256111] [<804e5af8>] (soc_remove_codec) from [<804e5ed4>] (soc_remove_da)
[ 117.264933] r4:ddfb640c r3:00000000
[ 117.268555] [<804e5c10>] (soc_remove_dai_links) from [<804e5fbc>] (snd_soc_u)
[ 117.277810] r10:80359e48 r9:dd684000 r8:dd5ca800 r7:dd685e60 r6:00000001 r5c
[ 117.285761] r4:dd5d9064
[ 117.288329] [<804e5f28>] (snd_soc_unregister_card) from [<804f29f0>] (devm_c)
[ 117.297324] r6:00000004 r5:ddd0fc10 r4:dd5a7980 r3:804f29dc
[ 117.303095] [<804f29dc>] (devm_card_release) from [<8035a418>] (release_node)
[ 117.311369] [<8035a2a8>] (release_nodes) from [<8035aab4>] (devres_release_a)
[ 117.319583] r10:00000000 r9:dd684000 r8:8000ed64 r7:00000081 r6:ddd0fc44 r54
[ 117.327543] r4:ddd0fc10
[ 117.330108] [<8035aa7c>] (devres_release_all) from [<803571c8>] (__device_re)
[ 117.339214] r4:ddd0fc10 r3:dd5d9010
[ 117.342989] [<80357148>] (__device_release_driver) from [<80357a48>] (driver)
[ 117.351607] r5:7f00c9e4 r4:ddd0fc10
[ 117.355285] [<8035798c>] (driver_detach) from [<80357030>] (bus_remove_drive)
[ 117.363454] r6:00000880 r5:00000000 r4:7f00c9e4 r3:dd6c3a80
[ 117.369195] [<80356fdc>] (bus_remove_driver) from [<803580b8>] (driver_unreg)
[ 117.377683] r4:7f00c9e4 r3:dd60d480
[ 117.381305] [<80358088>] (driver_unregister) from [<80358bb4>] (platform_dri)
[ 117.390642] r4:7f00ca28 r3:7f00c35c
[ 117.394309] [<80358ba0>] (platform_driver_unregister) from [<7f00c370>] (imx)
[ 117.406188] [<7f00c35c>] (imx_sgtl5000_driver_exit [snd_soc_imx_sgtl5000]) f)
[ 117.417452] [<8008c2b8>] (SyS_delete_module) from [<8000eba0>] (ret_fast_sys)
[ 117.425753] r6:5f636f73 r5:5f646e73 r4:00016f40
[ 117.430428] ---[ end trace 8fd8a5cb39e46d0e ]---
This problem is well explained by Russell King:
"The sgtl5000 uses a two-stage initialisation process. The first stage
is when the platform driver is probed, where some resources are found
and initialised. The second stage is via the codec driver's probe
function, where regulators are found and initialised using the managed
resource support.
The problem here is that this works fine until the codec driver is
unbound. When this occurs, sgtl5000_remove() is called which is a no-op
as far as the managed resource code is concerned. The regulators remain
allocated, and their pointers in sgtl5000_priv remain valid.
If the codec is now re-probed, it will again try and find the regulators,
which will now be busy. This will fail.
That's not the only problem - if using the LDO regulator, the regulator
is unregistered from the regulator core code, but it still has a user.
When the user is cleaned up (eg, by removing the module) it hits the
free'd regulator, and this can oops the kernel.
This bug was originally introduced by 63e54cd9caa3ce ("ASoC: sgtl5000:
Use devm_regulator_bulk_get()")."
This reverts commit 63e54cd9caa3ce.
Tested on a imx53-qsb board.
Reported-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-07-07 17:26:48 +00:00
|
|
|
ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
|
ASoC: sgtl5000: clean up sgtl5000_enable_regulators()
Function sgtl5000_enable_regulators() is somehow odd in handling the
optional external VDDD supply. The driver can only enable this supply
on SGTL5000 chip before revision 0x11, and of course when this external
VDDD is present. It currently does something like below.
1. Check if regulator_bulk_get() on VDDA, VDDIO and VDDD will fail. If
it fails, VDDD must be absent and it falls on internal LDO by calling
sgtl5000_replace_vddd_with_ldo(). Otherwise, VDDD is used. And in
either case, regulator_bulk_enable() will be called to enable
3 supplies.
2. In case that SGTL5000 revision is later than 0x11, even if external
VDDD is present, it has to roll back the 'enable' and 'get' calls
with regulator_bulk_disable() and regulator_bulk_free(), and starts
over again by calling sgtl5000_replace_vddd_with_ldo() and
regulator_bulk_enable().
Such back and forth calls sequence is complicated and unnecessary.
Also, since commit 4ddfebd (regulator: core: Provide a dummy regulator
with full constraints), regulator_bulk_get() will always succeeds
because of the dummy regulator. Thus the VDDD detection is broken.
The patch changes the flow to something like the following, which should
be more reasonable and clear, and also fix the VDDD detection breakage.
1. Check if we're running a chip before revision 0x11, on which an
external VDDD can possibly be an option.
2. If it is an early revision, call regulator_get_optional() to detect
whether an external VDDD supply is available.
3. If external VDDD is present, call sgtl5000_replace_vddd_with_ldo() to
update sgtl5000->supplies info.
4. Drop regulator_bulk_get() call in sgtl5000_replace_vddd_with_ldo(),
and call it in sgtl5000_enable_regulators() no matter it's an
external VDDD or internal LDO.
5. Call regulator_bulk_enable() to enable these 3 regulators.
Signed-off-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-12-13 06:43:03 +00:00
|
|
|
sgtl5000->supplies);
|
|
|
|
if (ret)
|
|
|
|
goto err_ldo_remove;
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
ret = regulator_bulk_enable(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
|
|
|
if (ret)
|
ASoC: sgtl5000: Fix driver unbound
Using the sgtl5000 codec driver as a module and trying to remove it causes the
followig kernel oops:
root@freescale /$ rmmod snd-soc-imx-sgtl5000
[ 117.122920] ------------[ cut here ]------------
[ 117.127609] WARNING: CPU: 0 PID: 631 at drivers/regulator/core.c:3604 regula)
[ 117.137046] Modules linked in: snd_soc_imx_sgtl5000(-) snd_soc_sgtl5000 evbug
[ 117.144315] CPU: 0 PID: 631 Comm: rmmod Not tainted 3.16.0-rc3-next-201407043
[ 117.153366] Backtrace:
[ 117.155865] [<80011e5c>] (dump_backtrace) from [<80011ff8>] (show_stack+0x18)
[ 117.163484] r6:802fcc48 r5:00000000 r4:00000000 r3:00000000
[ 117.169228] [<80011fe0>] (show_stack) from [<80668cc0>] (dump_stack+0x88/0xa)
[ 117.176508] [<80668c38>] (dump_stack) from [<80029a38>] (warn_slowpath_commo)
[ 117.184696] r5:00000009 r4:00000000
[ 117.188322] [<800299c8>] (warn_slowpath_common) from [<80029a80>] (warn_slow)
[ 117.197150] r8:dd60d600 r7:ddfa6d00 r6:dd5d9064 r5:dd5e0f90 r4:dd5d9400
[ 117.203983] [<80029a5c>] (warn_slowpath_null) from [<802fcc48>] (regulator_u)
[ 117.212828] [<802fcb74>] (regulator_unregister) from [<7f0047c4>] (ldo_regul)
[ 117.223475] r4:dd59e300 r3:dd5e0f90
[ 117.227100] [<7f00479c>] (ldo_regulator_remove [snd_soc_sgtl5000]) from [<7f)
[ 117.238959] r4:dd5d8000 r3:ddd51420
[ 117.242623] [<7f0047dc>] (sgtl5000_remove [snd_soc_sgtl5000]) from [<804e5b1)
[ 117.252489] r5:00000000 r4:dd5d8000
[ 117.256111] [<804e5af8>] (soc_remove_codec) from [<804e5ed4>] (soc_remove_da)
[ 117.264933] r4:ddfb640c r3:00000000
[ 117.268555] [<804e5c10>] (soc_remove_dai_links) from [<804e5fbc>] (snd_soc_u)
[ 117.277810] r10:80359e48 r9:dd684000 r8:dd5ca800 r7:dd685e60 r6:00000001 r5c
[ 117.285761] r4:dd5d9064
[ 117.288329] [<804e5f28>] (snd_soc_unregister_card) from [<804f29f0>] (devm_c)
[ 117.297324] r6:00000004 r5:ddd0fc10 r4:dd5a7980 r3:804f29dc
[ 117.303095] [<804f29dc>] (devm_card_release) from [<8035a418>] (release_node)
[ 117.311369] [<8035a2a8>] (release_nodes) from [<8035aab4>] (devres_release_a)
[ 117.319583] r10:00000000 r9:dd684000 r8:8000ed64 r7:00000081 r6:ddd0fc44 r54
[ 117.327543] r4:ddd0fc10
[ 117.330108] [<8035aa7c>] (devres_release_all) from [<803571c8>] (__device_re)
[ 117.339214] r4:ddd0fc10 r3:dd5d9010
[ 117.342989] [<80357148>] (__device_release_driver) from [<80357a48>] (driver)
[ 117.351607] r5:7f00c9e4 r4:ddd0fc10
[ 117.355285] [<8035798c>] (driver_detach) from [<80357030>] (bus_remove_drive)
[ 117.363454] r6:00000880 r5:00000000 r4:7f00c9e4 r3:dd6c3a80
[ 117.369195] [<80356fdc>] (bus_remove_driver) from [<803580b8>] (driver_unreg)
[ 117.377683] r4:7f00c9e4 r3:dd60d480
[ 117.381305] [<80358088>] (driver_unregister) from [<80358bb4>] (platform_dri)
[ 117.390642] r4:7f00ca28 r3:7f00c35c
[ 117.394309] [<80358ba0>] (platform_driver_unregister) from [<7f00c370>] (imx)
[ 117.406188] [<7f00c35c>] (imx_sgtl5000_driver_exit [snd_soc_imx_sgtl5000]) f)
[ 117.417452] [<8008c2b8>] (SyS_delete_module) from [<8000eba0>] (ret_fast_sys)
[ 117.425753] r6:5f636f73 r5:5f646e73 r4:00016f40
[ 117.430428] ---[ end trace 8fd8a5cb39e46d0e ]---
This problem is well explained by Russell King:
"The sgtl5000 uses a two-stage initialisation process. The first stage
is when the platform driver is probed, where some resources are found
and initialised. The second stage is via the codec driver's probe
function, where regulators are found and initialised using the managed
resource support.
The problem here is that this works fine until the codec driver is
unbound. When this occurs, sgtl5000_remove() is called which is a no-op
as far as the managed resource code is concerned. The regulators remain
allocated, and their pointers in sgtl5000_priv remain valid.
If the codec is now re-probed, it will again try and find the regulators,
which will now be busy. This will fail.
That's not the only problem - if using the LDO regulator, the regulator
is unregistered from the regulator core code, but it still has a user.
When the user is cleaned up (eg, by removing the module) it hits the
free'd regulator, and this can oops the kernel.
This bug was originally introduced by 63e54cd9caa3ce ("ASoC: sgtl5000:
Use devm_regulator_bulk_get()")."
This reverts commit 63e54cd9caa3ce.
Tested on a imx53-qsb board.
Reported-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-07-07 17:26:48 +00:00
|
|
|
goto err_regulator_free;
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
/* wait for all power rails bring up */
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
ASoC: sgtl5000: Fix driver unbound
Using the sgtl5000 codec driver as a module and trying to remove it causes the
followig kernel oops:
root@freescale /$ rmmod snd-soc-imx-sgtl5000
[ 117.122920] ------------[ cut here ]------------
[ 117.127609] WARNING: CPU: 0 PID: 631 at drivers/regulator/core.c:3604 regula)
[ 117.137046] Modules linked in: snd_soc_imx_sgtl5000(-) snd_soc_sgtl5000 evbug
[ 117.144315] CPU: 0 PID: 631 Comm: rmmod Not tainted 3.16.0-rc3-next-201407043
[ 117.153366] Backtrace:
[ 117.155865] [<80011e5c>] (dump_backtrace) from [<80011ff8>] (show_stack+0x18)
[ 117.163484] r6:802fcc48 r5:00000000 r4:00000000 r3:00000000
[ 117.169228] [<80011fe0>] (show_stack) from [<80668cc0>] (dump_stack+0x88/0xa)
[ 117.176508] [<80668c38>] (dump_stack) from [<80029a38>] (warn_slowpath_commo)
[ 117.184696] r5:00000009 r4:00000000
[ 117.188322] [<800299c8>] (warn_slowpath_common) from [<80029a80>] (warn_slow)
[ 117.197150] r8:dd60d600 r7:ddfa6d00 r6:dd5d9064 r5:dd5e0f90 r4:dd5d9400
[ 117.203983] [<80029a5c>] (warn_slowpath_null) from [<802fcc48>] (regulator_u)
[ 117.212828] [<802fcb74>] (regulator_unregister) from [<7f0047c4>] (ldo_regul)
[ 117.223475] r4:dd59e300 r3:dd5e0f90
[ 117.227100] [<7f00479c>] (ldo_regulator_remove [snd_soc_sgtl5000]) from [<7f)
[ 117.238959] r4:dd5d8000 r3:ddd51420
[ 117.242623] [<7f0047dc>] (sgtl5000_remove [snd_soc_sgtl5000]) from [<804e5b1)
[ 117.252489] r5:00000000 r4:dd5d8000
[ 117.256111] [<804e5af8>] (soc_remove_codec) from [<804e5ed4>] (soc_remove_da)
[ 117.264933] r4:ddfb640c r3:00000000
[ 117.268555] [<804e5c10>] (soc_remove_dai_links) from [<804e5fbc>] (snd_soc_u)
[ 117.277810] r10:80359e48 r9:dd684000 r8:dd5ca800 r7:dd685e60 r6:00000001 r5c
[ 117.285761] r4:dd5d9064
[ 117.288329] [<804e5f28>] (snd_soc_unregister_card) from [<804f29f0>] (devm_c)
[ 117.297324] r6:00000004 r5:ddd0fc10 r4:dd5a7980 r3:804f29dc
[ 117.303095] [<804f29dc>] (devm_card_release) from [<8035a418>] (release_node)
[ 117.311369] [<8035a2a8>] (release_nodes) from [<8035aab4>] (devres_release_a)
[ 117.319583] r10:00000000 r9:dd684000 r8:8000ed64 r7:00000081 r6:ddd0fc44 r54
[ 117.327543] r4:ddd0fc10
[ 117.330108] [<8035aa7c>] (devres_release_all) from [<803571c8>] (__device_re)
[ 117.339214] r4:ddd0fc10 r3:dd5d9010
[ 117.342989] [<80357148>] (__device_release_driver) from [<80357a48>] (driver)
[ 117.351607] r5:7f00c9e4 r4:ddd0fc10
[ 117.355285] [<8035798c>] (driver_detach) from [<80357030>] (bus_remove_drive)
[ 117.363454] r6:00000880 r5:00000000 r4:7f00c9e4 r3:dd6c3a80
[ 117.369195] [<80356fdc>] (bus_remove_driver) from [<803580b8>] (driver_unreg)
[ 117.377683] r4:7f00c9e4 r3:dd60d480
[ 117.381305] [<80358088>] (driver_unregister) from [<80358bb4>] (platform_dri)
[ 117.390642] r4:7f00ca28 r3:7f00c35c
[ 117.394309] [<80358ba0>] (platform_driver_unregister) from [<7f00c370>] (imx)
[ 117.406188] [<7f00c35c>] (imx_sgtl5000_driver_exit [snd_soc_imx_sgtl5000]) f)
[ 117.417452] [<8008c2b8>] (SyS_delete_module) from [<8000eba0>] (ret_fast_sys)
[ 117.425753] r6:5f636f73 r5:5f646e73 r4:00016f40
[ 117.430428] ---[ end trace 8fd8a5cb39e46d0e ]---
This problem is well explained by Russell King:
"The sgtl5000 uses a two-stage initialisation process. The first stage
is when the platform driver is probed, where some resources are found
and initialised. The second stage is via the codec driver's probe
function, where regulators are found and initialised using the managed
resource support.
The problem here is that this works fine until the codec driver is
unbound. When this occurs, sgtl5000_remove() is called which is a no-op
as far as the managed resource code is concerned. The regulators remain
allocated, and their pointers in sgtl5000_priv remain valid.
If the codec is now re-probed, it will again try and find the regulators,
which will now be busy. This will fail.
That's not the only problem - if using the LDO regulator, the regulator
is unregistered from the regulator core code, but it still has a user.
When the user is cleaned up (eg, by removing the module) it hits the
free'd regulator, and this can oops the kernel.
This bug was originally introduced by 63e54cd9caa3ce ("ASoC: sgtl5000:
Use devm_regulator_bulk_get()")."
This reverts commit 63e54cd9caa3ce.
Tested on a imx53-qsb board.
Reported-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-07-07 17:26:48 +00:00
|
|
|
err_regulator_free:
|
|
|
|
regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
ASoC: sgtl5000: clean up sgtl5000_enable_regulators()
Function sgtl5000_enable_regulators() is somehow odd in handling the
optional external VDDD supply. The driver can only enable this supply
on SGTL5000 chip before revision 0x11, and of course when this external
VDDD is present. It currently does something like below.
1. Check if regulator_bulk_get() on VDDA, VDDIO and VDDD will fail. If
it fails, VDDD must be absent and it falls on internal LDO by calling
sgtl5000_replace_vddd_with_ldo(). Otherwise, VDDD is used. And in
either case, regulator_bulk_enable() will be called to enable
3 supplies.
2. In case that SGTL5000 revision is later than 0x11, even if external
VDDD is present, it has to roll back the 'enable' and 'get' calls
with regulator_bulk_disable() and regulator_bulk_free(), and starts
over again by calling sgtl5000_replace_vddd_with_ldo() and
regulator_bulk_enable().
Such back and forth calls sequence is complicated and unnecessary.
Also, since commit 4ddfebd (regulator: core: Provide a dummy regulator
with full constraints), regulator_bulk_get() will always succeeds
because of the dummy regulator. Thus the VDDD detection is broken.
The patch changes the flow to something like the following, which should
be more reasonable and clear, and also fix the VDDD detection breakage.
1. Check if we're running a chip before revision 0x11, on which an
external VDDD can possibly be an option.
2. If it is an early revision, call regulator_get_optional() to detect
whether an external VDDD supply is available.
3. If external VDDD is present, call sgtl5000_replace_vddd_with_ldo() to
update sgtl5000->supplies info.
4. Drop regulator_bulk_get() call in sgtl5000_replace_vddd_with_ldo(),
and call it in sgtl5000_enable_regulators() no matter it's an
external VDDD or internal LDO.
5. Call regulator_bulk_enable() to enable these 3 regulators.
Signed-off-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-12-13 06:43:03 +00:00
|
|
|
err_ldo_remove:
|
|
|
|
if (!external_vddd)
|
2011-02-23 18:08:21 +00:00
|
|
|
ldo_regulator_remove(codec);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sgtl5000_probe(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
|
|
|
|
ret = sgtl5000_enable_regulators(codec);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* power up sgtl5000 */
|
|
|
|
ret = sgtl5000_set_power_regs(codec);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* enable small pop, introduce 400ms delay in turning off */
|
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_REF_CTRL,
|
2014-11-14 04:14:47 +00:00
|
|
|
SGTL5000_SMALL_POP, 1);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
/* disable short cut detector */
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_SHORT_CTRL, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set i2s as default input of sound switch
|
|
|
|
* TODO: add sound switch to control and dapm widge.
|
|
|
|
*/
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_SSS_CTRL,
|
|
|
|
SGTL5000_DAC_SEL_I2S_IN << SGTL5000_DAC_SEL_SHIFT);
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_DIG_POWER,
|
|
|
|
SGTL5000_ADC_EN | SGTL5000_DAC_EN);
|
|
|
|
|
|
|
|
/* enable dac volume ramp by default */
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_ADCDAC_CTRL,
|
|
|
|
SGTL5000_DAC_VOL_RAMP_EN |
|
|
|
|
SGTL5000_DAC_MUTE_RIGHT |
|
|
|
|
SGTL5000_DAC_MUTE_LEFT);
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_PAD_STRENGTH, 0x015f);
|
|
|
|
|
|
|
|
snd_soc_write(codec, SGTL5000_CHIP_ANA_CTRL,
|
|
|
|
SGTL5000_HP_ZCD_EN |
|
|
|
|
SGTL5000_ADC_ZCD_EN);
|
|
|
|
|
2014-10-14 06:43:11 +00:00
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
|
|
|
|
SGTL5000_BIAS_R_MASK,
|
|
|
|
sgtl5000->micbias_resistor << SGTL5000_BIAS_R_SHIFT);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
2014-10-14 06:43:12 +00:00
|
|
|
snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
|
|
|
|
SGTL5000_BIAS_R_MASK,
|
|
|
|
sgtl5000->micbias_voltage << SGTL5000_BIAS_R_SHIFT);
|
2011-02-23 18:08:21 +00:00
|
|
|
/*
|
|
|
|
* disable DAP
|
|
|
|
* TODO:
|
|
|
|
* Enable DAP in kcontrol and dapm.
|
|
|
|
*/
|
|
|
|
snd_soc_write(codec, SGTL5000_DAP_CTRL, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
ASoC: sgtl5000: Fix driver unbound
Using the sgtl5000 codec driver as a module and trying to remove it causes the
followig kernel oops:
root@freescale /$ rmmod snd-soc-imx-sgtl5000
[ 117.122920] ------------[ cut here ]------------
[ 117.127609] WARNING: CPU: 0 PID: 631 at drivers/regulator/core.c:3604 regula)
[ 117.137046] Modules linked in: snd_soc_imx_sgtl5000(-) snd_soc_sgtl5000 evbug
[ 117.144315] CPU: 0 PID: 631 Comm: rmmod Not tainted 3.16.0-rc3-next-201407043
[ 117.153366] Backtrace:
[ 117.155865] [<80011e5c>] (dump_backtrace) from [<80011ff8>] (show_stack+0x18)
[ 117.163484] r6:802fcc48 r5:00000000 r4:00000000 r3:00000000
[ 117.169228] [<80011fe0>] (show_stack) from [<80668cc0>] (dump_stack+0x88/0xa)
[ 117.176508] [<80668c38>] (dump_stack) from [<80029a38>] (warn_slowpath_commo)
[ 117.184696] r5:00000009 r4:00000000
[ 117.188322] [<800299c8>] (warn_slowpath_common) from [<80029a80>] (warn_slow)
[ 117.197150] r8:dd60d600 r7:ddfa6d00 r6:dd5d9064 r5:dd5e0f90 r4:dd5d9400
[ 117.203983] [<80029a5c>] (warn_slowpath_null) from [<802fcc48>] (regulator_u)
[ 117.212828] [<802fcb74>] (regulator_unregister) from [<7f0047c4>] (ldo_regul)
[ 117.223475] r4:dd59e300 r3:dd5e0f90
[ 117.227100] [<7f00479c>] (ldo_regulator_remove [snd_soc_sgtl5000]) from [<7f)
[ 117.238959] r4:dd5d8000 r3:ddd51420
[ 117.242623] [<7f0047dc>] (sgtl5000_remove [snd_soc_sgtl5000]) from [<804e5b1)
[ 117.252489] r5:00000000 r4:dd5d8000
[ 117.256111] [<804e5af8>] (soc_remove_codec) from [<804e5ed4>] (soc_remove_da)
[ 117.264933] r4:ddfb640c r3:00000000
[ 117.268555] [<804e5c10>] (soc_remove_dai_links) from [<804e5fbc>] (snd_soc_u)
[ 117.277810] r10:80359e48 r9:dd684000 r8:dd5ca800 r7:dd685e60 r6:00000001 r5c
[ 117.285761] r4:dd5d9064
[ 117.288329] [<804e5f28>] (snd_soc_unregister_card) from [<804f29f0>] (devm_c)
[ 117.297324] r6:00000004 r5:ddd0fc10 r4:dd5a7980 r3:804f29dc
[ 117.303095] [<804f29dc>] (devm_card_release) from [<8035a418>] (release_node)
[ 117.311369] [<8035a2a8>] (release_nodes) from [<8035aab4>] (devres_release_a)
[ 117.319583] r10:00000000 r9:dd684000 r8:8000ed64 r7:00000081 r6:ddd0fc44 r54
[ 117.327543] r4:ddd0fc10
[ 117.330108] [<8035aa7c>] (devres_release_all) from [<803571c8>] (__device_re)
[ 117.339214] r4:ddd0fc10 r3:dd5d9010
[ 117.342989] [<80357148>] (__device_release_driver) from [<80357a48>] (driver)
[ 117.351607] r5:7f00c9e4 r4:ddd0fc10
[ 117.355285] [<8035798c>] (driver_detach) from [<80357030>] (bus_remove_drive)
[ 117.363454] r6:00000880 r5:00000000 r4:7f00c9e4 r3:dd6c3a80
[ 117.369195] [<80356fdc>] (bus_remove_driver) from [<803580b8>] (driver_unreg)
[ 117.377683] r4:7f00c9e4 r3:dd60d480
[ 117.381305] [<80358088>] (driver_unregister) from [<80358bb4>] (platform_dri)
[ 117.390642] r4:7f00ca28 r3:7f00c35c
[ 117.394309] [<80358ba0>] (platform_driver_unregister) from [<7f00c370>] (imx)
[ 117.406188] [<7f00c35c>] (imx_sgtl5000_driver_exit [snd_soc_imx_sgtl5000]) f)
[ 117.417452] [<8008c2b8>] (SyS_delete_module) from [<8000eba0>] (ret_fast_sys)
[ 117.425753] r6:5f636f73 r5:5f646e73 r4:00016f40
[ 117.430428] ---[ end trace 8fd8a5cb39e46d0e ]---
This problem is well explained by Russell King:
"The sgtl5000 uses a two-stage initialisation process. The first stage
is when the platform driver is probed, where some resources are found
and initialised. The second stage is via the codec driver's probe
function, where regulators are found and initialised using the managed
resource support.
The problem here is that this works fine until the codec driver is
unbound. When this occurs, sgtl5000_remove() is called which is a no-op
as far as the managed resource code is concerned. The regulators remain
allocated, and their pointers in sgtl5000_priv remain valid.
If the codec is now re-probed, it will again try and find the regulators,
which will now be busy. This will fail.
That's not the only problem - if using the LDO regulator, the regulator
is unregistered from the regulator core code, but it still has a user.
When the user is cleaned up (eg, by removing the module) it hits the
free'd regulator, and this can oops the kernel.
This bug was originally introduced by 63e54cd9caa3ce ("ASoC: sgtl5000:
Use devm_regulator_bulk_get()")."
This reverts commit 63e54cd9caa3ce.
Tested on a imx53-qsb board.
Reported-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-07-07 17:26:48 +00:00
|
|
|
regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
2011-02-23 18:08:21 +00:00
|
|
|
ldo_regulator_remove(codec);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sgtl5000_remove(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
|
|
|
|
|
|
|
|
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
ASoC: sgtl5000: Fix driver unbound
Using the sgtl5000 codec driver as a module and trying to remove it causes the
followig kernel oops:
root@freescale /$ rmmod snd-soc-imx-sgtl5000
[ 117.122920] ------------[ cut here ]------------
[ 117.127609] WARNING: CPU: 0 PID: 631 at drivers/regulator/core.c:3604 regula)
[ 117.137046] Modules linked in: snd_soc_imx_sgtl5000(-) snd_soc_sgtl5000 evbug
[ 117.144315] CPU: 0 PID: 631 Comm: rmmod Not tainted 3.16.0-rc3-next-201407043
[ 117.153366] Backtrace:
[ 117.155865] [<80011e5c>] (dump_backtrace) from [<80011ff8>] (show_stack+0x18)
[ 117.163484] r6:802fcc48 r5:00000000 r4:00000000 r3:00000000
[ 117.169228] [<80011fe0>] (show_stack) from [<80668cc0>] (dump_stack+0x88/0xa)
[ 117.176508] [<80668c38>] (dump_stack) from [<80029a38>] (warn_slowpath_commo)
[ 117.184696] r5:00000009 r4:00000000
[ 117.188322] [<800299c8>] (warn_slowpath_common) from [<80029a80>] (warn_slow)
[ 117.197150] r8:dd60d600 r7:ddfa6d00 r6:dd5d9064 r5:dd5e0f90 r4:dd5d9400
[ 117.203983] [<80029a5c>] (warn_slowpath_null) from [<802fcc48>] (regulator_u)
[ 117.212828] [<802fcb74>] (regulator_unregister) from [<7f0047c4>] (ldo_regul)
[ 117.223475] r4:dd59e300 r3:dd5e0f90
[ 117.227100] [<7f00479c>] (ldo_regulator_remove [snd_soc_sgtl5000]) from [<7f)
[ 117.238959] r4:dd5d8000 r3:ddd51420
[ 117.242623] [<7f0047dc>] (sgtl5000_remove [snd_soc_sgtl5000]) from [<804e5b1)
[ 117.252489] r5:00000000 r4:dd5d8000
[ 117.256111] [<804e5af8>] (soc_remove_codec) from [<804e5ed4>] (soc_remove_da)
[ 117.264933] r4:ddfb640c r3:00000000
[ 117.268555] [<804e5c10>] (soc_remove_dai_links) from [<804e5fbc>] (snd_soc_u)
[ 117.277810] r10:80359e48 r9:dd684000 r8:dd5ca800 r7:dd685e60 r6:00000001 r5c
[ 117.285761] r4:dd5d9064
[ 117.288329] [<804e5f28>] (snd_soc_unregister_card) from [<804f29f0>] (devm_c)
[ 117.297324] r6:00000004 r5:ddd0fc10 r4:dd5a7980 r3:804f29dc
[ 117.303095] [<804f29dc>] (devm_card_release) from [<8035a418>] (release_node)
[ 117.311369] [<8035a2a8>] (release_nodes) from [<8035aab4>] (devres_release_a)
[ 117.319583] r10:00000000 r9:dd684000 r8:8000ed64 r7:00000081 r6:ddd0fc44 r54
[ 117.327543] r4:ddd0fc10
[ 117.330108] [<8035aa7c>] (devres_release_all) from [<803571c8>] (__device_re)
[ 117.339214] r4:ddd0fc10 r3:dd5d9010
[ 117.342989] [<80357148>] (__device_release_driver) from [<80357a48>] (driver)
[ 117.351607] r5:7f00c9e4 r4:ddd0fc10
[ 117.355285] [<8035798c>] (driver_detach) from [<80357030>] (bus_remove_drive)
[ 117.363454] r6:00000880 r5:00000000 r4:7f00c9e4 r3:dd6c3a80
[ 117.369195] [<80356fdc>] (bus_remove_driver) from [<803580b8>] (driver_unreg)
[ 117.377683] r4:7f00c9e4 r3:dd60d480
[ 117.381305] [<80358088>] (driver_unregister) from [<80358bb4>] (platform_dri)
[ 117.390642] r4:7f00ca28 r3:7f00c35c
[ 117.394309] [<80358ba0>] (platform_driver_unregister) from [<7f00c370>] (imx)
[ 117.406188] [<7f00c35c>] (imx_sgtl5000_driver_exit [snd_soc_imx_sgtl5000]) f)
[ 117.417452] [<8008c2b8>] (SyS_delete_module) from [<8000eba0>] (ret_fast_sys)
[ 117.425753] r6:5f636f73 r5:5f646e73 r4:00016f40
[ 117.430428] ---[ end trace 8fd8a5cb39e46d0e ]---
This problem is well explained by Russell King:
"The sgtl5000 uses a two-stage initialisation process. The first stage
is when the platform driver is probed, where some resources are found
and initialised. The second stage is via the codec driver's probe
function, where regulators are found and initialised using the managed
resource support.
The problem here is that this works fine until the codec driver is
unbound. When this occurs, sgtl5000_remove() is called which is a no-op
as far as the managed resource code is concerned. The regulators remain
allocated, and their pointers in sgtl5000_priv remain valid.
If the codec is now re-probed, it will again try and find the regulators,
which will now be busy. This will fail.
That's not the only problem - if using the LDO regulator, the regulator
is unregistered from the regulator core code, but it still has a user.
When the user is cleaned up (eg, by removing the module) it hits the
free'd regulator, and this can oops the kernel.
This bug was originally introduced by 63e54cd9caa3ce ("ASoC: sgtl5000:
Use devm_regulator_bulk_get()")."
This reverts commit 63e54cd9caa3ce.
Tested on a imx53-qsb board.
Reported-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Fabio Estevam <fabio.estevam@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-07-07 17:26:48 +00:00
|
|
|
regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
|
|
|
|
sgtl5000->supplies);
|
2011-02-23 18:08:21 +00:00
|
|
|
ldo_regulator_remove(codec);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-28 14:33:01 +00:00
|
|
|
static struct snd_soc_codec_driver sgtl5000_driver = {
|
2011-02-23 18:08:21 +00:00
|
|
|
.probe = sgtl5000_probe,
|
|
|
|
.remove = sgtl5000_remove,
|
|
|
|
.set_bias_level = sgtl5000_set_bias_level,
|
2014-09-06 12:29:35 +00:00
|
|
|
.suspend_bias_off = true,
|
2012-01-22 16:49:42 +00:00
|
|
|
.controls = sgtl5000_snd_controls,
|
|
|
|
.num_controls = ARRAY_SIZE(sgtl5000_snd_controls),
|
2012-01-23 10:16:31 +00:00
|
|
|
.dapm_widgets = sgtl5000_dapm_widgets,
|
|
|
|
.num_dapm_widgets = ARRAY_SIZE(sgtl5000_dapm_widgets),
|
|
|
|
.dapm_routes = sgtl5000_dapm_routes,
|
|
|
|
.num_dapm_routes = ARRAY_SIZE(sgtl5000_dapm_routes),
|
2011-02-23 18:08:21 +00:00
|
|
|
};
|
|
|
|
|
2013-05-04 18:39:34 +00:00
|
|
|
static const struct regmap_config sgtl5000_regmap = {
|
|
|
|
.reg_bits = 16,
|
|
|
|
.val_bits = 16,
|
2013-07-04 23:01:01 +00:00
|
|
|
.reg_stride = 2,
|
2013-05-04 18:39:34 +00:00
|
|
|
|
|
|
|
.max_register = SGTL5000_MAX_REG_OFFSET,
|
|
|
|
.volatile_reg = sgtl5000_volatile,
|
|
|
|
.readable_reg = sgtl5000_readable,
|
|
|
|
|
|
|
|
.cache_type = REGCACHE_RBTREE,
|
|
|
|
.reg_defaults = sgtl5000_reg_defaults,
|
|
|
|
.num_reg_defaults = ARRAY_SIZE(sgtl5000_reg_defaults),
|
|
|
|
};
|
|
|
|
|
2013-05-10 00:15:47 +00:00
|
|
|
/*
|
|
|
|
* Write all the default values from sgtl5000_reg_defaults[] array into the
|
|
|
|
* sgtl5000 registers, to make sure we always start with the sane registers
|
|
|
|
* values as stated in the datasheet.
|
|
|
|
*
|
|
|
|
* Since sgtl5000 does not have a reset line, nor a reset command in software,
|
|
|
|
* we follow this approach to guarantee we always start from the default values
|
|
|
|
* and avoid problems like, not being able to probe after an audio playback
|
|
|
|
* followed by a system reset or a 'reboot' command in Linux
|
|
|
|
*/
|
|
|
|
static int sgtl5000_fill_defaults(struct sgtl5000_priv *sgtl5000)
|
|
|
|
{
|
|
|
|
int i, ret, val, index;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sgtl5000_reg_defaults); i++) {
|
|
|
|
val = sgtl5000_reg_defaults[i].def;
|
|
|
|
index = sgtl5000_reg_defaults[i].reg;
|
|
|
|
ret = regmap_write(sgtl5000->regmap, index, val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-07 14:26:37 +00:00
|
|
|
static int sgtl5000_i2c_probe(struct i2c_client *client,
|
|
|
|
const struct i2c_device_id *id)
|
2011-02-23 18:08:21 +00:00
|
|
|
{
|
|
|
|
struct sgtl5000_priv *sgtl5000;
|
2013-05-10 00:15:46 +00:00
|
|
|
int ret, reg, rev;
|
2014-10-14 06:43:11 +00:00
|
|
|
struct device_node *np = client->dev.of_node;
|
|
|
|
u32 value;
|
2011-02-23 18:08:21 +00:00
|
|
|
|
2014-10-24 15:01:25 +00:00
|
|
|
sgtl5000 = devm_kzalloc(&client->dev, sizeof(*sgtl5000), GFP_KERNEL);
|
2011-02-23 18:08:21 +00:00
|
|
|
if (!sgtl5000)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-05-04 18:39:34 +00:00
|
|
|
sgtl5000->regmap = devm_regmap_init_i2c(client, &sgtl5000_regmap);
|
|
|
|
if (IS_ERR(sgtl5000->regmap)) {
|
|
|
|
ret = PTR_ERR(sgtl5000->regmap);
|
|
|
|
dev_err(&client->dev, "Failed to allocate regmap: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-10 01:07:46 +00:00
|
|
|
sgtl5000->mclk = devm_clk_get(&client->dev, NULL);
|
|
|
|
if (IS_ERR(sgtl5000->mclk)) {
|
|
|
|
ret = PTR_ERR(sgtl5000->mclk);
|
|
|
|
dev_err(&client->dev, "Failed to get mclock: %d\n", ret);
|
2013-07-16 01:17:27 +00:00
|
|
|
/* Defer the probe to see if the clk will be provided later */
|
|
|
|
if (ret == -ENOENT)
|
|
|
|
return -EPROBE_DEFER;
|
2013-06-10 01:07:46 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = clk_prepare_enable(sgtl5000->mclk);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-05-10 00:15:46 +00:00
|
|
|
/* read chip information */
|
|
|
|
ret = regmap_read(sgtl5000->regmap, SGTL5000_CHIP_ID, ®);
|
|
|
|
if (ret)
|
2013-06-10 01:07:46 +00:00
|
|
|
goto disable_clk;
|
2013-05-10 00:15:46 +00:00
|
|
|
|
|
|
|
if (((reg & SGTL5000_PARTID_MASK) >> SGTL5000_PARTID_SHIFT) !=
|
|
|
|
SGTL5000_PARTID_PART_ID) {
|
|
|
|
dev_err(&client->dev,
|
|
|
|
"Device with ID register %x is not a sgtl5000\n", reg);
|
2013-06-10 01:07:46 +00:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto disable_clk;
|
2013-05-10 00:15:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rev = (reg & SGTL5000_REVID_MASK) >> SGTL5000_REVID_SHIFT;
|
|
|
|
dev_info(&client->dev, "sgtl5000 revision 0x%x\n", rev);
|
2013-12-13 06:43:02 +00:00
|
|
|
sgtl5000->revision = rev;
|
2013-05-10 00:15:46 +00:00
|
|
|
|
2014-10-14 06:43:11 +00:00
|
|
|
if (np) {
|
|
|
|
if (!of_property_read_u32(np,
|
|
|
|
"micbias-resistor-k-ohms", &value)) {
|
|
|
|
switch (value) {
|
|
|
|
case SGTL5000_MICBIAS_OFF:
|
|
|
|
sgtl5000->micbias_resistor = 0;
|
|
|
|
break;
|
|
|
|
case SGTL5000_MICBIAS_2K:
|
|
|
|
sgtl5000->micbias_resistor = 1;
|
|
|
|
break;
|
|
|
|
case SGTL5000_MICBIAS_4K:
|
|
|
|
sgtl5000->micbias_resistor = 2;
|
|
|
|
break;
|
|
|
|
case SGTL5000_MICBIAS_8K:
|
|
|
|
sgtl5000->micbias_resistor = 3;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
sgtl5000->micbias_resistor = 2;
|
|
|
|
dev_err(&client->dev,
|
|
|
|
"Unsuitable MicBias resistor\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* default is 4Kohms */
|
|
|
|
sgtl5000->micbias_resistor = 2;
|
|
|
|
}
|
2014-10-14 06:43:12 +00:00
|
|
|
if (!of_property_read_u32(np,
|
|
|
|
"micbias-voltage-m-volts", &value)) {
|
|
|
|
/* 1250mV => 0 */
|
|
|
|
/* steps of 250mV */
|
|
|
|
if ((value >= 1250) && (value <= 3000))
|
|
|
|
sgtl5000->micbias_voltage = (value / 250) - 5;
|
|
|
|
else {
|
|
|
|
sgtl5000->micbias_voltage = 0;
|
2014-10-14 06:43:11 +00:00
|
|
|
dev_err(&client->dev,
|
|
|
|
"Unsuitable MicBias resistor\n");
|
|
|
|
}
|
|
|
|
} else {
|
2014-10-14 06:43:12 +00:00
|
|
|
sgtl5000->micbias_voltage = 0;
|
2014-10-14 06:43:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
i2c_set_clientdata(client, sgtl5000);
|
|
|
|
|
2013-05-10 00:15:47 +00:00
|
|
|
/* Ensure sgtl5000 will start with sane register values */
|
|
|
|
ret = sgtl5000_fill_defaults(sgtl5000);
|
|
|
|
if (ret)
|
2013-06-10 01:07:46 +00:00
|
|
|
goto disable_clk;
|
2013-05-10 00:15:47 +00:00
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
ret = snd_soc_register_codec(&client->dev,
|
|
|
|
&sgtl5000_driver, &sgtl5000_dai, 1);
|
2013-06-10 01:07:46 +00:00
|
|
|
if (ret)
|
|
|
|
goto disable_clk;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
disable_clk:
|
|
|
|
clk_disable_unprepare(sgtl5000->mclk);
|
2011-12-28 13:30:11 +00:00
|
|
|
return ret;
|
2011-02-23 18:08:21 +00:00
|
|
|
}
|
|
|
|
|
2012-12-07 14:26:37 +00:00
|
|
|
static int sgtl5000_i2c_remove(struct i2c_client *client)
|
2011-02-23 18:08:21 +00:00
|
|
|
{
|
2013-06-10 13:24:41 +00:00
|
|
|
struct sgtl5000_priv *sgtl5000 = i2c_get_clientdata(client);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
2013-06-10 01:07:46 +00:00
|
|
|
snd_soc_unregister_codec(&client->dev);
|
|
|
|
clk_disable_unprepare(sgtl5000->mclk);
|
2011-02-23 18:08:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct i2c_device_id sgtl5000_id[] = {
|
|
|
|
{"sgtl5000", 0},
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(i2c, sgtl5000_id);
|
|
|
|
|
2011-07-21 16:28:51 +00:00
|
|
|
static const struct of_device_id sgtl5000_dt_ids[] = {
|
|
|
|
{ .compatible = "fsl,sgtl5000", },
|
|
|
|
{ /* sentinel */ }
|
|
|
|
};
|
2011-08-11 14:19:16 +00:00
|
|
|
MODULE_DEVICE_TABLE(of, sgtl5000_dt_ids);
|
2011-07-21 16:28:51 +00:00
|
|
|
|
2011-02-23 18:08:21 +00:00
|
|
|
static struct i2c_driver sgtl5000_i2c_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "sgtl5000",
|
|
|
|
.owner = THIS_MODULE,
|
2011-07-21 16:28:51 +00:00
|
|
|
.of_match_table = sgtl5000_dt_ids,
|
2011-02-23 18:08:21 +00:00
|
|
|
},
|
|
|
|
.probe = sgtl5000_i2c_probe,
|
2012-12-07 14:26:37 +00:00
|
|
|
.remove = sgtl5000_i2c_remove,
|
2011-02-23 18:08:21 +00:00
|
|
|
.id_table = sgtl5000_id,
|
|
|
|
};
|
|
|
|
|
2012-04-03 21:35:18 +00:00
|
|
|
module_i2c_driver(sgtl5000_i2c_driver);
|
2011-02-23 18:08:21 +00:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Freescale SGTL5000 ALSA SoC Codec Driver");
|
2012-01-16 07:18:11 +00:00
|
|
|
MODULE_AUTHOR("Zeng Zhaoming <zengzm.kernel@gmail.com>");
|
2011-02-23 18:08:21 +00:00
|
|
|
MODULE_LICENSE("GPL");
|