niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

ASoC: twl6040: replace codec to component

Browse source 
Now we can replace Codec to Component. Let's do it.

Note:
	xxx_codec_xxx()		->	xxx_component_xxx()
	.idle_bias_off = 0	->	.idle_bias_on = 1
	.ignore_pmdown_time = 1	->	.use_pmdown_time = 0
	-			->	.endianness = 1
	-			->	.non_legacy_dai_naming = 1

Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Kuninori Morimoto 2018-01-29 04:20:09 +00:00 • committed by Mark Brown
parent 7928b2cbe5
commit 7480389fb0
No known key found for this signature in database
GPG key ID: 24D68B725D5487D0
3 changed files with 139 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

269
sound/soc/codecs/twl6040.c
View file

@ -76,7 +76,7 @@ struct twl6040_data {
unsigned int clk_in; unsigned int clk_in;
unsigned int sysclk; unsigned int sysclk;
struct twl6040_jack_data hs_jack; struct twl6040_jack_data hs_jack;
struct snd_soc_codec *codec; struct snd_soc_component *component;
struct mutex mutex; struct mutex mutex;
}; };
@ -106,12 +106,12 @@ static const struct snd_pcm_hw_constraint_list sysclk_constraints[] = {
{ .count = ARRAY_SIZE(hp_rates), .list = hp_rates, }, { .count = ARRAY_SIZE(hp_rates), .list = hp_rates, },
}; };
#define to_twl6040(codec) dev_get_drvdata((codec)->dev->parent) #define to_twl6040(component) dev_get_drvdata((component)->dev->parent)
static unsigned int twl6040_read(struct snd_soc_codec *codec, unsigned int reg) static unsigned int twl6040_read(struct snd_soc_component *component, unsigned int reg)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
u8 value; u8 value;
if (reg >= TWL6040_CACHEREGNUM) if (reg >= TWL6040_CACHEREGNUM)
@ -133,10 +133,10 @@ static unsigned int twl6040_read(struct snd_soc_codec *codec, unsigned int reg)
return value; return value;
} }
static bool twl6040_can_write_to_chip(struct snd_soc_codec *codec, static bool twl6040_can_write_to_chip(struct snd_soc_component *component,
unsigned int reg) unsigned int reg)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
switch (reg) { switch (reg) {
case TWL6040_REG_HSLCTL: case TWL6040_REG_HSLCTL:
@ -152,10 +152,10 @@ static bool twl6040_can_write_to_chip(struct snd_soc_codec *codec,
} }
} }
static inline void twl6040_update_dl12_cache(struct snd_soc_codec *codec, static inline void twl6040_update_dl12_cache(struct snd_soc_component *component,
u8 reg, u8 value) u8 reg, u8 value)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
switch (reg) { switch (reg) {
case TWL6040_REG_HSLCTL: case TWL6040_REG_HSLCTL:
@ -170,54 +170,54 @@ static inline void twl6040_update_dl12_cache(struct snd_soc_codec *codec,
} }
} }
static int twl6040_write(struct snd_soc_codec *codec, static int twl6040_write(struct snd_soc_component *component,
unsigned int reg, unsigned int value) unsigned int reg, unsigned int value)
{ {
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
if (reg >= TWL6040_CACHEREGNUM) if (reg >= TWL6040_CACHEREGNUM)
return -EIO; return -EIO;
twl6040_update_dl12_cache(codec, reg, value); twl6040_update_dl12_cache(component, reg, value);
if (twl6040_can_write_to_chip(codec, reg)) if (twl6040_can_write_to_chip(component, reg))
return twl6040_reg_write(twl6040, reg, value); return twl6040_reg_write(twl6040, reg, value);
else else
return 0; return 0;
} }
static void twl6040_init_chip(struct snd_soc_codec *codec) static void twl6040_init_chip(struct snd_soc_component *component)
{ {
twl6040_read(codec, TWL6040_REG_TRIM1); twl6040_read(component, TWL6040_REG_TRIM1);
twl6040_read(codec, TWL6040_REG_TRIM2); twl6040_read(component, TWL6040_REG_TRIM2);
twl6040_read(codec, TWL6040_REG_TRIM3); twl6040_read(component, TWL6040_REG_TRIM3);
twl6040_read(codec, TWL6040_REG_HSOTRIM); twl6040_read(component, TWL6040_REG_HSOTRIM);
twl6040_read(codec, TWL6040_REG_HFOTRIM); twl6040_read(component, TWL6040_REG_HFOTRIM);
/* Change chip defaults */ /* Change chip defaults */
/* No imput selected for microphone amplifiers */ /* No imput selected for microphone amplifiers */
twl6040_write(codec, TWL6040_REG_MICLCTL, 0x18); twl6040_write(component, TWL6040_REG_MICLCTL, 0x18);
twl6040_write(codec, TWL6040_REG_MICRCTL, 0x18); twl6040_write(component, TWL6040_REG_MICRCTL, 0x18);
/* /*
* We need to lower the default gain values, so the ramp code * We need to lower the default gain values, so the ramp code
* can work correctly for the first playback. * can work correctly for the first playback.
* This reduces the pop noise heard at the first playback. * This reduces the pop noise heard at the first playback.
*/ */
twl6040_write(codec, TWL6040_REG_HSGAIN, 0xff); twl6040_write(component, TWL6040_REG_HSGAIN, 0xff);
twl6040_write(codec, TWL6040_REG_EARCTL, 0x1e); twl6040_write(component, TWL6040_REG_EARCTL, 0x1e);
twl6040_write(codec, TWL6040_REG_HFLGAIN, 0x1d); twl6040_write(component, TWL6040_REG_HFLGAIN, 0x1d);
twl6040_write(codec, TWL6040_REG_HFRGAIN, 0x1d); twl6040_write(component, TWL6040_REG_HFRGAIN, 0x1d);
twl6040_write(codec, TWL6040_REG_LINEGAIN, 0); twl6040_write(component, TWL6040_REG_LINEGAIN, 0);
} }
/* set headset dac and driver power mode */ /* set headset dac and driver power mode */
static int headset_power_mode(struct snd_soc_codec *codec, int high_perf) static int headset_power_mode(struct snd_soc_component *component, int high_perf)
{ {
int hslctl, hsrctl; int hslctl, hsrctl;
int mask = TWL6040_HSDRVMODE | TWL6040_HSDACMODE; int mask = TWL6040_HSDRVMODE | TWL6040_HSDACMODE;
hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL); hslctl = twl6040_read(component, TWL6040_REG_HSLCTL);
hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL); hsrctl = twl6040_read(component, TWL6040_REG_HSRCTL);
if (high_perf) { if (high_perf) {
hslctl &= ~mask; hslctl &= ~mask;
@ -227,8 +227,8 @@ static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
hsrctl |= mask; hsrctl |= mask;
} }
twl6040_write(codec, TWL6040_REG_HSLCTL, hslctl); twl6040_write(component, TWL6040_REG_HSLCTL, hslctl);
twl6040_write(codec, TWL6040_REG_HSRCTL, hsrctl); twl6040_write(component, TWL6040_REG_HSRCTL, hsrctl);
return 0; return 0;
} }
@ -236,7 +236,7 @@ static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w, static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event) struct snd_kcontrol *kcontrol, int event)
{ {
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
u8 hslctl, hsrctl; u8 hslctl, hsrctl;
/* /*
@ -244,8 +244,8 @@ static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
* Both HS DAC need to be turned on (before the HS driver) and off at * Both HS DAC need to be turned on (before the HS driver) and off at
* the same time. * the same time.
*/ */
hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL); hslctl = twl6040_read(component, TWL6040_REG_HSLCTL);
hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL); hsrctl = twl6040_read(component, TWL6040_REG_HSRCTL);
if (SND_SOC_DAPM_EVENT_ON(event)) { if (SND_SOC_DAPM_EVENT_ON(event)) {
hslctl |= TWL6040_HSDACENA; hslctl |= TWL6040_HSDACENA;
hsrctl |= TWL6040_HSDACENA; hsrctl |= TWL6040_HSDACENA;
@ -253,8 +253,8 @@ static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
hslctl &= ~TWL6040_HSDACENA; hslctl &= ~TWL6040_HSDACENA;
hsrctl &= ~TWL6040_HSDACENA; hsrctl &= ~TWL6040_HSDACENA;
} }
twl6040_write(codec, TWL6040_REG_HSLCTL, hslctl); twl6040_write(component, TWL6040_REG_HSLCTL, hslctl);
twl6040_write(codec, TWL6040_REG_HSRCTL, hsrctl); twl6040_write(component, TWL6040_REG_HSRCTL, hsrctl);
msleep(1); msleep(1);
return 0; return 0;
@ -263,17 +263,17 @@ static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
static int twl6040_ep_drv_event(struct snd_soc_dapm_widget *w, static int twl6040_ep_drv_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event) struct snd_kcontrol *kcontrol, int event)
{ {
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int ret = 0; int ret = 0;
if (SND_SOC_DAPM_EVENT_ON(event)) { if (SND_SOC_DAPM_EVENT_ON(event)) {
/* Earphone doesn't support low power mode */ /* Earphone doesn't support low power mode */
priv->hs_power_mode_locked = 1; priv->hs_power_mode_locked = 1;
ret = headset_power_mode(codec, 1); ret = headset_power_mode(component, 1);
} else { } else {
priv->hs_power_mode_locked = 0; priv->hs_power_mode_locked = 0;
ret = headset_power_mode(codec, priv->hs_power_mode); ret = headset_power_mode(component, priv->hs_power_mode);
} }
msleep(1); msleep(1);
@ -281,16 +281,16 @@ static int twl6040_ep_drv_event(struct snd_soc_dapm_widget *w,
return ret; return ret;
} }
static void twl6040_hs_jack_report(struct snd_soc_codec *codec, static void twl6040_hs_jack_report(struct snd_soc_component *component,
struct snd_soc_jack *jack, int report) struct snd_soc_jack *jack, int report)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int status; int status;
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
/* Sync status */ /* Sync status */
status = twl6040_read(codec, TWL6040_REG_STATUS); status = twl6040_read(component, TWL6040_REG_STATUS);
if (status & TWL6040_PLUGCOMP) if (status & TWL6040_PLUGCOMP)
snd_soc_jack_report(jack, report, report); snd_soc_jack_report(jack, report, report);
else else
@ -299,16 +299,16 @@ static void twl6040_hs_jack_report(struct snd_soc_codec *codec,
mutex_unlock(&priv->mutex); mutex_unlock(&priv->mutex);
} }
void twl6040_hs_jack_detect(struct snd_soc_codec *codec, void twl6040_hs_jack_detect(struct snd_soc_component *component,
struct snd_soc_jack *jack, int report) struct snd_soc_jack *jack, int report)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
struct twl6040_jack_data *hs_jack = &priv->hs_jack; struct twl6040_jack_data *hs_jack = &priv->hs_jack;
hs_jack->jack = jack; hs_jack->jack = jack;
hs_jack->report = report; hs_jack->report = report;
twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report); twl6040_hs_jack_report(component, hs_jack->jack, hs_jack->report);
} }
EXPORT_SYMBOL_GPL(twl6040_hs_jack_detect); EXPORT_SYMBOL_GPL(twl6040_hs_jack_detect);
@ -316,17 +316,17 @@ static void twl6040_accessory_work(struct work_struct *work)
{ {
struct twl6040_data *priv = container_of(work, struct twl6040_data *priv = container_of(work,
struct twl6040_data, hs_jack.work.work); struct twl6040_data, hs_jack.work.work);
struct snd_soc_codec *codec = priv->codec; struct snd_soc_component *component = priv->component;
struct twl6040_jack_data *hs_jack = &priv->hs_jack; struct twl6040_jack_data *hs_jack = &priv->hs_jack;
twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report); twl6040_hs_jack_report(component, hs_jack->jack, hs_jack->report);
} }
/* audio interrupt handler */ /* audio interrupt handler */
static irqreturn_t twl6040_audio_handler(int irq, void *data) static irqreturn_t twl6040_audio_handler(int irq, void *data)
{ {
struct snd_soc_codec *codec = data; struct snd_soc_component *component = data;
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
queue_delayed_work(system_power_efficient_wq, queue_delayed_work(system_power_efficient_wq,
&priv->hs_jack.work, msecs_to_jiffies(200)); &priv->hs_jack.work, msecs_to_jiffies(200));
@ -337,12 +337,12 @@ static irqreturn_t twl6040_audio_handler(int irq, void *data)
static int twl6040_soc_dapm_put_vibra_enum(struct snd_kcontrol *kcontrol, static int twl6040_soc_dapm_put_vibra_enum(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol); struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
unsigned int val; unsigned int val;
/* Do not allow changes while Input/FF efect is running */ /* Do not allow changes while Input/FF efect is running */
val = twl6040_read(codec, e->reg); val = twl6040_read(component, e->reg);
if (val & TWL6040_VIBENA && !(val & TWL6040_VIBSEL)) if (val & TWL6040_VIBENA && !(val & TWL6040_VIBSEL))
return -EBUSY; return -EBUSY;
@ -486,8 +486,8 @@ static SOC_ENUM_SINGLE_EXT_DECL(twl6040_power_mode_enum,
static int twl6040_headset_power_get_enum(struct snd_kcontrol *kcontrol, static int twl6040_headset_power_get_enum(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
ucontrol->value.enumerated.item[0] = priv->hs_power_mode; ucontrol->value.enumerated.item[0] = priv->hs_power_mode;
@ -497,13 +497,13 @@ static int twl6040_headset_power_get_enum(struct snd_kcontrol *kcontrol,
static int twl6040_headset_power_put_enum(struct snd_kcontrol *kcontrol, static int twl6040_headset_power_put_enum(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int high_perf = ucontrol->value.enumerated.item[0]; int high_perf = ucontrol->value.enumerated.item[0];
int ret = 0; int ret = 0;
if (!priv->hs_power_mode_locked) if (!priv->hs_power_mode_locked)
ret = headset_power_mode(codec, high_perf); ret = headset_power_mode(component, high_perf);
if (!ret) if (!ret)
priv->hs_power_mode = high_perf; priv->hs_power_mode = high_perf;
@ -514,8 +514,8 @@ static int twl6040_headset_power_put_enum(struct snd_kcontrol *kcontrol,
static int twl6040_pll_get_enum(struct snd_kcontrol *kcontrol, static int twl6040_pll_get_enum(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
ucontrol->value.enumerated.item[0] = priv->pll_power_mode; ucontrol->value.enumerated.item[0] = priv->pll_power_mode;
@ -525,17 +525,17 @@ static int twl6040_pll_get_enum(struct snd_kcontrol *kcontrol,
static int twl6040_pll_put_enum(struct snd_kcontrol *kcontrol, static int twl6040_pll_put_enum(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) struct snd_ctl_elem_value *ucontrol)
{ {
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
priv->pll_power_mode = ucontrol->value.enumerated.item[0]; priv->pll_power_mode = ucontrol->value.enumerated.item[0];
return 0; return 0;
} }
int twl6040_get_dl1_gain(struct snd_soc_codec *codec) int twl6040_get_dl1_gain(struct snd_soc_component *component)
{ {
struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
if (snd_soc_dapm_get_pin_status(dapm, "EP")) if (snd_soc_dapm_get_pin_status(dapm, "EP"))
return -1; /* -1dB */ return -1; /* -1dB */
@ -543,7 +543,7 @@ int twl6040_get_dl1_gain(struct snd_soc_codec *codec)
if (snd_soc_dapm_get_pin_status(dapm, "HSOR") || if (snd_soc_dapm_get_pin_status(dapm, "HSOR") ||
snd_soc_dapm_get_pin_status(dapm, "HSOL")) { snd_soc_dapm_get_pin_status(dapm, "HSOL")) {
u8 val = twl6040_read(codec, TWL6040_REG_HSLCTL); u8 val = twl6040_read(component, TWL6040_REG_HSLCTL);
if (val & TWL6040_HSDACMODE) if (val & TWL6040_HSDACMODE)
/* HSDACL in LP mode */ /* HSDACL in LP mode */
return -8; /* -8dB */ return -8; /* -8dB */
@ -555,26 +555,26 @@ int twl6040_get_dl1_gain(struct snd_soc_codec *codec)
} }
EXPORT_SYMBOL_GPL(twl6040_get_dl1_gain); EXPORT_SYMBOL_GPL(twl6040_get_dl1_gain);
int twl6040_get_clk_id(struct snd_soc_codec *codec) int twl6040_get_clk_id(struct snd_soc_component *component)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
return priv->pll_power_mode; return priv->pll_power_mode;
} }
EXPORT_SYMBOL_GPL(twl6040_get_clk_id); EXPORT_SYMBOL_GPL(twl6040_get_clk_id);
int twl6040_get_trim_value(struct snd_soc_codec *codec, enum twl6040_trim trim) int twl6040_get_trim_value(struct snd_soc_component *component, enum twl6040_trim trim)
{ {
if (unlikely(trim >= TWL6040_TRIM_INVAL)) if (unlikely(trim >= TWL6040_TRIM_INVAL))
return -EINVAL; return -EINVAL;
return twl6040_read(codec, TWL6040_REG_TRIM1 + trim); return twl6040_read(component, TWL6040_REG_TRIM1 + trim);
} }
EXPORT_SYMBOL_GPL(twl6040_get_trim_value); EXPORT_SYMBOL_GPL(twl6040_get_trim_value);
int twl6040_get_hs_step_size(struct snd_soc_codec *codec) int twl6040_get_hs_step_size(struct snd_soc_component *component)
{ {
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
if (twl6040_get_revid(twl6040) < TWL6040_REV_ES1_3) if (twl6040_get_revid(twl6040) < TWL6040_REV_ES1_3)
/* For ES under ES_1.3 HS step is 2 mV */ /* For ES under ES_1.3 HS step is 2 mV */
@ -829,11 +829,11 @@ static const struct snd_soc_dapm_route intercon[] = {
{"VIBRAR", NULL, "Vibra Right Driver"}, {"VIBRAR", NULL, "Vibra Right Driver"},
}; };
static int twl6040_set_bias_level(struct snd_soc_codec *codec, static int twl6040_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level) enum snd_soc_bias_level level)
{ {
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int ret = 0; int ret = 0;
switch (level) { switch (level) {
@ -856,7 +856,7 @@ static int twl6040_set_bias_level(struct snd_soc_codec *codec,
priv->codec_powered = 1; priv->codec_powered = 1;
/* Set external boost GPO */ /* Set external boost GPO */
twl6040_write(codec, TWL6040_REG_GPOCTL, 0x02); twl6040_write(component, TWL6040_REG_GPOCTL, 0x02);
break; break;
case SND_SOC_BIAS_OFF: case SND_SOC_BIAS_OFF:
if (!priv->codec_powered) if (!priv->codec_powered)
@ -873,8 +873,8 @@ static int twl6040_set_bias_level(struct snd_soc_codec *codec,
static int twl6040_startup(struct snd_pcm_substream *substream, static int twl6040_startup(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
snd_pcm_hw_constraint_list(substream->runtime, 0, snd_pcm_hw_constraint_list(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_RATE, SNDRV_PCM_HW_PARAM_RATE,
@ -887,8 +887,8 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params, struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int rate; int rate;
rate = params_rate(params); rate = params_rate(params);
@ -899,7 +899,7 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
case 88200: case 88200:
/* These rates are not supported when HPPLL is in use */ /* These rates are not supported when HPPLL is in use */
if (unlikely(priv->pll == TWL6040_SYSCLK_SEL_HPPLL)) { if (unlikely(priv->pll == TWL6040_SYSCLK_SEL_HPPLL)) {
dev_err(codec->dev, "HPPLL does not support rate %d\n", dev_err(component->dev, "HPPLL does not support rate %d\n",
rate); rate);
return -EINVAL; return -EINVAL;
} }
@ -913,7 +913,7 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
priv->sysclk = 19200000; priv->sysclk = 19200000;
break; break;
default: default:
dev_err(codec->dev, "unsupported rate %d\n", rate); dev_err(component->dev, "unsupported rate %d\n", rate);
return -EINVAL; return -EINVAL;
} }
@ -923,20 +923,20 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
static int twl6040_prepare(struct snd_pcm_substream *substream, static int twl6040_prepare(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int ret; int ret;
if (!priv->sysclk) { if (!priv->sysclk) {
dev_err(codec->dev, dev_err(component->dev,
"no mclk configured, call set_sysclk() on init\n"); "no mclk configured, call set_sysclk() on init\n");
return -EINVAL; return -EINVAL;
} }
ret = twl6040_set_pll(twl6040, priv->pll, priv->clk_in, priv->sysclk); ret = twl6040_set_pll(twl6040, priv->pll, priv->clk_in, priv->sysclk);
if (ret) { if (ret) {
dev_err(codec->dev, "Can not set PLL (%d)\n", ret); dev_err(component->dev, "Can not set PLL (%d)\n", ret);
return -EPERM; return -EPERM;
} }
@ -946,8 +946,8 @@ static int twl6040_prepare(struct snd_pcm_substream *substream,
static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai,
int clk_id, unsigned int freq, int dir) int clk_id, unsigned int freq, int dir)
{ {
struct snd_soc_codec *codec = codec_dai->codec; struct snd_soc_component *component = codec_dai->component;
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
switch (clk_id) { switch (clk_id) {
case TWL6040_SYSCLK_SEL_LPPLL: case TWL6040_SYSCLK_SEL_LPPLL:
@ -956,26 +956,26 @@ static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai,
priv->clk_in = freq; priv->clk_in = freq;
break; break;
default: default:
dev_err(codec->dev, "unknown clk_id %d\n", clk_id); dev_err(component->dev, "unknown clk_id %d\n", clk_id);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
} }
static void twl6040_mute_path(struct snd_soc_codec *codec, enum twl6040_dai_id id, static void twl6040_mute_path(struct snd_soc_component *component, enum twl6040_dai_id id,
int mute) int mute)
{ {
struct twl6040 *twl6040 = to_twl6040(codec); struct twl6040 *twl6040 = to_twl6040(component);
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
int hslctl, hsrctl, earctl; int hslctl, hsrctl, earctl;
int hflctl, hfrctl; int hflctl, hfrctl;
switch (id) { switch (id) {
case TWL6040_DAI_DL1: case TWL6040_DAI_DL1:
hslctl = twl6040_read(codec, TWL6040_REG_HSLCTL); hslctl = twl6040_read(component, TWL6040_REG_HSLCTL);
hsrctl = twl6040_read(codec, TWL6040_REG_HSRCTL); hsrctl = twl6040_read(component, TWL6040_REG_HSRCTL);
earctl = twl6040_read(codec, TWL6040_REG_EARCTL); earctl = twl6040_read(component, TWL6040_REG_EARCTL);
if (mute) { if (mute) {
/* Power down drivers and DACs */ /* Power down drivers and DACs */
@ -991,8 +991,8 @@ static void twl6040_mute_path(struct snd_soc_codec *codec, enum twl6040_dai_id i
priv->dl1_unmuted = !mute; priv->dl1_unmuted = !mute;
break; break;
case TWL6040_DAI_DL2: case TWL6040_DAI_DL2:
hflctl = twl6040_read(codec, TWL6040_REG_HFLCTL); hflctl = twl6040_read(component, TWL6040_REG_HFLCTL);
hfrctl = twl6040_read(codec, TWL6040_REG_HFRCTL); hfrctl = twl6040_read(component, TWL6040_REG_HFRCTL);
if (mute) { if (mute) {
/* Power down drivers and DACs */ /* Power down drivers and DACs */
@ -1015,12 +1015,12 @@ static int twl6040_digital_mute(struct snd_soc_dai *dai, int mute)
{ {
switch (dai->id) { switch (dai->id) {
case TWL6040_DAI_LEGACY: case TWL6040_DAI_LEGACY:
twl6040_mute_path(dai->codec, TWL6040_DAI_DL1, mute); twl6040_mute_path(dai->component, TWL6040_DAI_DL1, mute);
twl6040_mute_path(dai->codec, TWL6040_DAI_DL2, mute); twl6040_mute_path(dai->component, TWL6040_DAI_DL2, mute);
break; break;
case TWL6040_DAI_DL1: case TWL6040_DAI_DL1:
case TWL6040_DAI_DL2: case TWL6040_DAI_DL2:
twl6040_mute_path(dai->codec, dai->id, mute); twl6040_mute_path(dai->component, dai->id, mute);
break; break;
default: default:
break; break;
@ -1107,23 +1107,23 @@ static struct snd_soc_dai_driver twl6040_dai[] = {
}, },
}; };
static int twl6040_probe(struct snd_soc_codec *codec) static int twl6040_probe(struct snd_soc_component *component)
{ {
struct twl6040_data *priv; struct twl6040_data *priv;
struct platform_device *pdev = to_platform_device(codec->dev); struct platform_device *pdev = to_platform_device(component->dev);
int ret = 0; int ret = 0;
priv = devm_kzalloc(codec->dev, sizeof(*priv), GFP_KERNEL); priv = devm_kzalloc(component->dev, sizeof(*priv), GFP_KERNEL);
if (priv == NULL) if (priv == NULL)
return -ENOMEM; return -ENOMEM;
snd_soc_codec_set_drvdata(codec, priv); snd_soc_component_set_drvdata(component, priv);
priv->codec = codec; priv->component = component;
priv->plug_irq = platform_get_irq(pdev, 0); priv->plug_irq = platform_get_irq(pdev, 0);
if (priv->plug_irq < 0) { if (priv->plug_irq < 0) {
dev_err(codec->dev, "invalid irq: %d\n", priv->plug_irq); dev_err(component->dev, "invalid irq: %d\n", priv->plug_irq);
return priv->plug_irq; return priv->plug_irq;
} }
@ -1134,64 +1134,55 @@ static int twl6040_probe(struct snd_soc_codec *codec)
ret = request_threaded_irq(priv->plug_irq, NULL, ret = request_threaded_irq(priv->plug_irq, NULL,
twl6040_audio_handler, twl6040_audio_handler,
IRQF_NO_SUSPEND | IRQF_ONESHOT, IRQF_NO_SUSPEND | IRQF_ONESHOT,
"twl6040_irq_plug", codec); "twl6040_irq_plug", component);
if (ret) { if (ret) {
dev_err(codec->dev, "PLUG IRQ request failed: %d\n", ret); dev_err(component->dev, "PLUG IRQ request failed: %d\n", ret);
return ret; return ret;
} }
snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY); snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);
twl6040_init_chip(codec); twl6040_init_chip(component);
return 0; return 0;
} }
static int twl6040_remove(struct snd_soc_codec *codec) static void twl6040_remove(struct snd_soc_component *component)
{ {
struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); struct twl6040_data *priv = snd_soc_component_get_drvdata(component);
free_irq(priv->plug_irq, codec); free_irq(priv->plug_irq, component);
return 0;
} }
static const struct snd_soc_codec_driver soc_codec_dev_twl6040 = { static const struct snd_soc_component_driver soc_component_dev_twl6040 = {
.probe = twl6040_probe, .probe = twl6040_probe,
.remove = twl6040_remove, .remove = twl6040_remove,
.read = twl6040_read, .read = twl6040_read,
.write = twl6040_write, .remove = twl6040_remove,
.set_bias_level = twl6040_set_bias_level, .set_bias_level = twl6040_set_bias_level,
.suspend_bias_off = true, .controls = twl6040_snd_controls,
.ignore_pmdown_time = true, .num_controls = ARRAY_SIZE(twl6040_snd_controls),
.dapm_widgets = twl6040_dapm_widgets,
.component_driver = { .num_dapm_widgets = ARRAY_SIZE(twl6040_dapm_widgets),
.controls = twl6040_snd_controls, .dapm_routes = intercon,
.num_controls = ARRAY_SIZE(twl6040_snd_controls), .num_dapm_routes = ARRAY_SIZE(intercon),
.dapm_widgets = twl6040_dapm_widgets, .suspend_bias_off = 1,
.num_dapm_widgets = ARRAY_SIZE(twl6040_dapm_widgets), .idle_bias_on = 1,
.dapm_routes = intercon, .endianness = 1,
.num_dapm_routes = ARRAY_SIZE(intercon), .non_legacy_dai_naming = 1,
},
}; };
static int twl6040_codec_probe(struct platform_device *pdev) static int twl6040_codec_probe(struct platform_device *pdev)
{ {
return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_twl6040, return devm_snd_soc_register_component(&pdev->dev,
&soc_component_dev_twl6040,
twl6040_dai, ARRAY_SIZE(twl6040_dai)); twl6040_dai, ARRAY_SIZE(twl6040_dai));
} }
static int twl6040_codec_remove(struct platform_device *pdev)
{
snd_soc_unregister_codec(&pdev->dev);
return 0;
}
static struct platform_driver twl6040_codec_driver = { static struct platform_driver twl6040_codec_driver = {
.driver = { .driver = {
.name = "twl6040-codec", .name = "twl6040-codec",
}, },
.probe = twl6040_codec_probe, .probe = twl6040_codec_probe,
.remove = twl6040_codec_remove,
}; };
module_platform_driver(twl6040_codec_driver); module_platform_driver(twl6040_codec_driver);

10
sound/soc/codecs/twl6040.h
View file

@ -34,11 +34,11 @@ enum twl6040_trim {
#define TWL6040_HSF_TRIM_LEFT(x) (x & 0x0f) #define TWL6040_HSF_TRIM_LEFT(x) (x & 0x0f)
#define TWL6040_HSF_TRIM_RIGHT(x) ((x >> 4) & 0x0f) #define TWL6040_HSF_TRIM_RIGHT(x) ((x >> 4) & 0x0f)
int twl6040_get_dl1_gain(struct snd_soc_codec *codec); int twl6040_get_dl1_gain(struct snd_soc_component *component);
void twl6040_hs_jack_detect(struct snd_soc_codec *codec, void twl6040_hs_jack_detect(struct snd_soc_component *component,
struct snd_soc_jack *jack, int report); struct snd_soc_jack *jack, int report);
int twl6040_get_clk_id(struct snd_soc_codec *codec); int twl6040_get_clk_id(struct snd_soc_component *component);
int twl6040_get_trim_value(struct snd_soc_codec *codec, enum twl6040_trim trim); int twl6040_get_trim_value(struct snd_soc_component *component, enum twl6040_trim trim);
int twl6040_get_hs_step_size(struct snd_soc_codec *codec); int twl6040_get_hs_step_size(struct snd_soc_component *component);
#endif /* End of __TWL6040_H__ */ #endif /* End of __TWL6040_H__ */

8
sound/soc/omap/omap-abe-twl6040.c
View file

@ -52,7 +52,7 @@ static int omap_abe_hw_params(struct snd_pcm_substream *substream,
int clk_id, freq; int clk_id, freq;
int ret; int ret;
clk_id = twl6040_get_clk_id(rtd->codec); clk_id = twl6040_get_clk_id(codec_dai->component);
if (clk_id == TWL6040_SYSCLK_SEL_HPPLL) if (clk_id == TWL6040_SYSCLK_SEL_HPPLL)
freq = priv->mclk_freq; freq = priv->mclk_freq;
else if (clk_id == TWL6040_SYSCLK_SEL_LPPLL) else if (clk_id == TWL6040_SYSCLK_SEL_LPPLL)
@ -166,7 +166,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
static int omap_abe_twl6040_init(struct snd_soc_pcm_runtime *rtd) static int omap_abe_twl6040_init(struct snd_soc_pcm_runtime *rtd)
{ {
struct snd_soc_codec *codec = rtd->codec; struct snd_soc_component *component = rtd->codec_dai->component;
struct snd_soc_card *card = rtd->card; struct snd_soc_card *card = rtd->card;
struct abe_twl6040 *priv = snd_soc_card_get_drvdata(card); struct abe_twl6040 *priv = snd_soc_card_get_drvdata(card);
int hs_trim; int hs_trim;
@ -176,7 +176,7 @@ static int omap_abe_twl6040_init(struct snd_soc_pcm_runtime *rtd)
* Configure McPDM offset cancellation based on the HSOTRIM value from * Configure McPDM offset cancellation based on the HSOTRIM value from
* twl6040. * twl6040.
*/ */
hs_trim = twl6040_get_trim_value(codec, TWL6040_TRIM_HSOTRIM); hs_trim = twl6040_get_trim_value(component, TWL6040_TRIM_HSOTRIM);
omap_mcpdm_configure_dn_offsets(rtd, TWL6040_HSF_TRIM_LEFT(hs_trim), omap_mcpdm_configure_dn_offsets(rtd, TWL6040_HSF_TRIM_LEFT(hs_trim),
TWL6040_HSF_TRIM_RIGHT(hs_trim)); TWL6040_HSF_TRIM_RIGHT(hs_trim));
@ -189,7 +189,7 @@ static int omap_abe_twl6040_init(struct snd_soc_pcm_runtime *rtd)
if (ret) if (ret)
return ret; return ret;
twl6040_hs_jack_detect(codec, &hs_jack, SND_JACK_HEADSET); twl6040_hs_jack_detect(component, &hs_jack, SND_JACK_HEADSET);
} }
return 0; return 0;