return ret;
/* set i2s data format */
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
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;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
i2s_ctl |= SGTL5000_I2S_DLEN_20 << SGTL5000_I2S_DLEN_SHIFT;
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
SGTL5000_I2S_SCLKFREQ_SHIFT;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
i2s_ctl |= SGTL5000_I2S_DLEN_24 << SGTL5000_I2S_DLEN_SHIFT;
i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
SGTL5000_I2S_SCLKFREQ_SHIFT;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
if (sgtl5000->fmt == SND_SOC_DAIFMT_RIGHT_J)
return -EINVAL;
i2s_ctl |= SGTL5000_I2S_DLEN_32 << SGTL5000_I2S_DLEN_SHIFT;
ldo = kzalloc(sizeof(struct ldo_regulator), GFP_KERNEL);
----- if (!ldo) {
----- dev_err(codec->dev, "failed to allocate ldo_regulator\n");
+++++ if (!ldo)
return -ENOMEM;
----- }
ldo->desc.name = kstrdup(dev_name(codec->dev), GFP_KERNEL);
if (!ldo->desc.name) {
return ret;
}
----- ret = devm_regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
+++++ ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
sgtl5000->supplies);
if (ret)
goto err_ldo_remove;
ret = regulator_bulk_enable(ARRAY_SIZE(sgtl5000->supplies),
sgtl5000->supplies);
if (ret)
----- goto err_ldo_remove;
+++++ goto err_regulator_free;
/* wait for all power rails bring up */
udelay(10);
return 0;
+++++err_regulator_free:
+++++ regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
+++++ sgtl5000->supplies);
err_ldo_remove:
if (!external_vddd)
ldo_regulator_remove(codec);
err:
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
sgtl5000->supplies);
+++++ regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
+++++ sgtl5000->supplies);
ldo_regulator_remove(codec);
return ret;
regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
sgtl5000->supplies);
+++++ regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
+++++ sgtl5000->supplies);
ldo_regulator_remove(codec);
return 0;
int pdata, play_freq_val, record_freq_val;
int bclk_to_fs_ratio;
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
pdata = 1;
bclk_to_fs_ratio = 0;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
pdata = 2;
bclk_to_fs_ratio = 1;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
pdata = 3;
bclk_to_fs_ratio = 2;
break;
return -EINVAL;
sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL);
----- if (sta529 == NULL) {
----- dev_err(&i2c->dev, "Can not allocate memory\n");
+++++ if (!sta529)
return -ENOMEM;
----- }
sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap);
if (IS_ERR(sta529->regmap)) {
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/regmap.h>
+++++#include <linux/regulator/consumer.h>
#include <linux/spi/spi.h>
#include <linux/of.h>
#include <linux/of_device.h>
return 0;
}
+++++static const char * const supply_names[] = {
+++++ "dvdd", "avdd"
+++++};
+++++
struct tas5086_private {
struct regmap *regmap;
unsigned int mclk, sclk;
int rate;
/* GPIO driving Reset pin, if any */
int gpio_nreset;
+++++ struct regulator_bulk_data supplies[ARRAY_SIZE(supply_names)];
};
static int tas5086_deemph[] = { 0, 32000, 44100, 48000 };
}
/* ... then add the offset for the sample bit depth. */
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
val += 0;
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
val += 1;
break;
-- --- case SNDRV_PCM_FORMAT_S24_3LE:
++ +++ case 24:
val += 2;
break;
default:
if (ret < 0)
return ret;
+++++ regulator_bulk_disable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++
return 0;
}
struct tas5086_private *priv = snd_soc_codec_get_drvdata(codec);
int ret;
+++++ ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++ if (ret < 0)
+++++ return ret;
+++++
tas5086_reset(priv);
regcache_mark_dirty(priv->regmap);
struct tas5086_private *priv = snd_soc_codec_get_drvdata(codec);
int i, ret;
+++++ ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++ if (ret < 0) {
+++++ dev_err(codec->dev, "Failed to enable regulators: %d\n", ret);
+++++ return ret;
+++++ }
+++++
priv->pwm_start_mid_z = 0;
priv->charge_period = 1300000; /* hardware default is 1300 ms */
}
}
+++++ tas5086_reset(priv);
ret = tas5086_init(codec->dev, priv);
if (ret < 0)
----- return ret;
+++++ goto exit_disable_regulators;
/* set master volume to 0 dB */
ret = regmap_write(priv->regmap, TAS5086_MASTER_VOL, 0x30);
if (ret < 0)
----- return ret;
+++++ goto exit_disable_regulators;
return 0;
+++++
+++++exit_disable_regulators:
+++++ regulator_bulk_disable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++
+++++ return ret;
}
static int tas5086_remove(struct snd_soc_codec *codec)
/* Set codec to the reset state */
gpio_set_value(priv->gpio_nreset, 0);
+++++ regulator_bulk_disable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++
return 0;
};
if (!priv)
return -ENOMEM;
+++++ for (i = 0; i < ARRAY_SIZE(supply_names); i++)
+++++ priv->supplies[i].supply = supply_names[i];
+++++
+++++ ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(priv->supplies),
+++++ priv->supplies);
+++++ if (ret < 0) {
+++++ dev_err(dev, "Failed to get regulators: %d\n", ret);
+++++ return ret;
+++++ }
+++++
priv->regmap = devm_regmap_init(dev, NULL, i2c, &tas5086_regmap);
if (IS_ERR(priv->regmap)) {
ret = PTR_ERR(priv->regmap);
gpio_nreset = -EINVAL;
priv->gpio_nreset = gpio_nreset;
+++++
+++++ ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++ if (ret < 0) {
+++++ dev_err(dev, "Failed to enable regulators: %d\n", ret);
+++++ return ret;
+++++ }
+++++
tas5086_reset(priv);
/* The TAS5086 always returns 0x03 in its TAS5086_DEV_ID register */
ret = regmap_read(priv->regmap, TAS5086_DEV_ID, &i);
----- if (ret < 0)
----- return ret;
-----
----- if (i != 0x3) {
+++++ if (ret == 0 && i != 0x3) {
dev_err(dev,
"Failed to identify TAS5086 codec (got %02x)\n", i);
----- return -ENODEV;
+++++ ret = -ENODEV;
}
----- return snd_soc_register_codec(&i2c->dev, &soc_codec_dev_tas5086,
----- &tas5086_dai, 1);
+++++ /*
+++++ * The chip has been identified, so we can turn off the power
+++++ * again until the dai link is set up.
+++++ */
+++++ regulator_bulk_disable(ARRAY_SIZE(priv->supplies), priv->supplies);
+++++
+++++ if (ret == 0)
+++++ ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_tas5086,
+++++ &tas5086_dai, 1);
+++++
+++++ return ret;
}
static int tas5086_i2c_remove(struct i2c_client *i2c)
"Off", "FFR 10 Ohm", "FFR 20 Ohm", "FFR 40 Ohm"
};
-----static const
-----SOC_ENUM_SINGLE_DECL(mic1lp_p_enum, AIC31XX_MICPGAPI, 6, mic_select_text);
-----static const
-----SOC_ENUM_SINGLE_DECL(mic1rp_p_enum, AIC31XX_MICPGAPI, 4, mic_select_text);
-----static const
-----SOC_ENUM_SINGLE_DECL(mic1lm_p_enum, AIC31XX_MICPGAPI, 2, mic_select_text);
-----
-----static const
-----SOC_ENUM_SINGLE_DECL(cm_m_enum, AIC31XX_MICPGAMI, 6, mic_select_text);
-----static const
-----SOC_ENUM_SINGLE_DECL(mic1lm_m_enum, AIC31XX_MICPGAMI, 4, mic_select_text);
+++++static SOC_ENUM_SINGLE_DECL(mic1lp_p_enum, AIC31XX_MICPGAPI, 6,
+++++ mic_select_text);
+++++static SOC_ENUM_SINGLE_DECL(mic1rp_p_enum, AIC31XX_MICPGAPI, 4,
+++++ mic_select_text);
+++++static SOC_ENUM_SINGLE_DECL(mic1lm_p_enum, AIC31XX_MICPGAPI, 2,
+++++ mic_select_text);
+++++
+++++static SOC_ENUM_SINGLE_DECL(cm_m_enum, AIC31XX_MICPGAMI, 6, mic_select_text);
+++++static SOC_ENUM_SINGLE_DECL(mic1lm_m_enum, AIC31XX_MICPGAMI, 4,
+++++ mic_select_text);
static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -6350, 50, 0);
static const DECLARE_TLV_DB_SCALE(adc_fgain_tlv, 0, 10, 0);
unsigned int bits;
int counter = count;
int ret = regmap_read(aic31xx->regmap, reg, &bits);
+++++
while ((bits & mask) != wbits && counter && !ret) {
usleep_range(sleep, sleep * 2);
ret = regmap_read(aic31xx->regmap, reg, &bits);
{
struct snd_soc_codec *codec = w->codec;
struct aic31xx_priv *aic31xx = snd_soc_codec_get_drvdata(codec);
+++++
switch (event) {
case SND_SOC_DAPM_POST_PMU:
/* change mic bias voltage to user defined */
struct snd_soc_codec *codec = dai->codec;
u8 data = 0;
-- --- dev_dbg(codec->dev, "## %s: format %d width %d rate %d\n",
-- --- __func__, params_format(params), params_width(params),
++ +++ dev_dbg(codec->dev, "## %s: width %d rate %d\n",
++ +++ __func__, params_width(params),
params_rate(params));
switch (params_width(params)) {
AIC31XX_IFACE1_DATALEN_SHIFT);
break;
default:
-- --- dev_err(codec->dev, "%s: Unsupported format %d\n",
-- --- __func__, params_format(params));
++ +++ dev_err(codec->dev, "%s: Unsupported width %d\n",
++ +++ __func__, params_width(params));
return -EINVAL;
}
}
#endif /* CONFIG_OF */
-----static void aic31xx_device_init(struct aic31xx_priv *aic31xx)
+++++static int aic31xx_device_init(struct aic31xx_priv *aic31xx)
{
int ret, i;
"aic31xx-reset-pin");
if (ret < 0) {
dev_err(aic31xx->dev, "not able to acquire gpio\n");
----- return;
+++++ return ret;
}
}
if (ret != 0)
dev_err(aic31xx->dev, "Failed to request supplies: %d\n", ret);
+++++ return ret;
}
static int aic31xx_i2c_probe(struct i2c_client *i2c,
aic31xx->pdata.codec_type = id->driver_data;
----- aic31xx_device_init(aic31xx);
+++++ ret = aic31xx_device_init(aic31xx);
+++++ if (ret)
+++++ return ret;
return snd_soc_register_codec(&i2c->dev, &soc_codec_driver_aic31xx,
aic31xx_dai_driver,
data = snd_soc_read(codec, AIC32X4_IFACE1);
data = data & ~(3 << 4);
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
data |= (AIC32X4_WORD_LEN_20BITS << AIC32X4_DOSRMSB_SHIFT);
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
data |= (AIC32X4_WORD_LEN_24BITS << AIC32X4_DOSRMSB_SHIFT);
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
data |= (AIC32X4_WORD_LEN_32BITS << AIC32X4_DOSRMSB_SHIFT);
break;
}
snd_soc_write(codec, AIC32X4_MICBIAS, AIC32X4_MICBIAS_LDOIN |
AIC32X4_MICBIAS_2075V);
}
----- if (aic32x4->power_cfg & AIC32X4_PWR_AVDD_DVDD_WEAK_DISABLE) {
+++++ if (aic32x4->power_cfg & AIC32X4_PWR_AVDD_DVDD_WEAK_DISABLE)
snd_soc_write(codec, AIC32X4_PWRCFG, AIC32X4_AVDDWEAKDISABLE);
----- }
tmp_reg = (aic32x4->power_cfg & AIC32X4_PWR_AIC32X4_LDO_ENABLE) ?
AIC32X4_LDOCTLEN : 0;
snd_soc_write(codec, AIC32X4_LDOCTL, tmp_reg);
tmp_reg = snd_soc_read(codec, AIC32X4_CMMODE);
----- if (aic32x4->power_cfg & AIC32X4_PWR_CMMODE_LDOIN_RANGE_18_36) {
+++++ if (aic32x4->power_cfg & AIC32X4_PWR_CMMODE_LDOIN_RANGE_18_36)
tmp_reg |= AIC32X4_LDOIN_18_36;
----- }
----- if (aic32x4->power_cfg & AIC32X4_PWR_CMMODE_HP_LDOIN_POWERED) {
+++++ if (aic32x4->power_cfg & AIC32X4_PWR_CMMODE_HP_LDOIN_POWERED)
tmp_reg |= AIC32X4_LDOIN2HP;
----- }
snd_soc_write(codec, AIC32X4_CMMODE, tmp_reg);
/* Mic PGA routing */
if (aic32x4->micpga_routing & AIC32X4_MICPGA_ROUTE_LMIC_IN2R_10K)
----- snd_soc_write(codec, AIC32X4_LMICPGANIN, AIC32X4_LMICPGANIN_IN2R_10K);
+++++ snd_soc_write(codec, AIC32X4_LMICPGANIN,
+++++ AIC32X4_LMICPGANIN_IN2R_10K);
else
----- snd_soc_write(codec, AIC32X4_LMICPGANIN, AIC32X4_LMICPGANIN_CM1L_10K);
+++++ snd_soc_write(codec, AIC32X4_LMICPGANIN,
+++++ AIC32X4_LMICPGANIN_CM1L_10K);
if (aic32x4->micpga_routing & AIC32X4_MICPGA_ROUTE_RMIC_IN1L_10K)
----- snd_soc_write(codec, AIC32X4_RMICPGANIN, AIC32X4_RMICPGANIN_IN1L_10K);
+++++ snd_soc_write(codec, AIC32X4_RMICPGANIN,
+++++ AIC32X4_RMICPGANIN_IN1L_10K);
else
----- snd_soc_write(codec, AIC32X4_RMICPGANIN, AIC32X4_RMICPGANIN_CM1R_10K);
+++++ snd_soc_write(codec, AIC32X4_RMICPGANIN,
+++++ AIC32X4_RMICPGANIN_CM1R_10K);
aic32x4_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
/* select data word length */
data = snd_soc_read(codec, AIC3X_ASD_INTF_CTRLB) & (~(0x3 << 4));
- ---- switch (params_format(params)) {
- ---- case SNDRV_PCM_FORMAT_S16_LE:
+ ++++ switch (params_width(params)) {
+ ++++ case 16:
break;
- ---- case SNDRV_PCM_FORMAT_S20_3LE:
+ ++++ case 20:
data |= (0x01 << 4);
break;
- case SNDRV_PCM_FORMAT_S24_3LE:
---- case SNDRV_PCM_FORMAT_S24_LE:
+ ++++ case 24:
data |= (0x02 << 4);
break;
- ---- case SNDRV_PCM_FORMAT_S32_LE:
+ ++++ case 32:
data |= (0x03 << 4);
break;
}
#define AIC3X_RATES SNDRV_PCM_RATE_8000_96000
#define AIC3X_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
- ---- SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S32_LE)
+ ++++ SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE | \
+ ++++ SNDRV_PCM_FMTBIT_S32_LE)
static const struct snd_soc_dai_ops aic3x_dai_ops = {
.hw_params = aic3x_hw_params,
u32 value;
aic3x = devm_kzalloc(&i2c->dev, sizeof(struct aic3x_priv), GFP_KERNEL);
----- if (aic3x == NULL) {
----- dev_err(&i2c->dev, "failed to create private data\n");
+++++ if (!aic3x)
return -ENOMEM;
----- }
aic3x->regmap = devm_regmap_init_i2c(i2c, &aic3x_regmap);
if (IS_ERR(aic3x->regmap)) {
} else if (np) {
ai3x_setup = devm_kzalloc(&i2c->dev, sizeof(*ai3x_setup),
GFP_KERNEL);
----- if (ai3x_setup == NULL) {
----- dev_err(&i2c->dev, "failed to create private data\n");
+++++ if (!ai3x_setup)
return -ENOMEM;
----- }
ret = of_get_named_gpio(np, "gpio-reset", 0);
if (ret >= 0)
return -EINVAL;
}
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
dac33->fifo_size = DAC33_FIFO_SIZE_16BIT;
dac33->burst_rate = CALC_BURST_RATE(dac33->burst_bclkdiv, 32);
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
dac33->fifo_size = DAC33_FIFO_SIZE_24BIT;
dac33->burst_rate = CALC_BURST_RATE(dac33->burst_bclkdiv, 64);
break;
default:
-- --- dev_err(codec->dev, "unsupported format %d\n",
-- --- params_format(params));
++ +++ dev_err(codec->dev, "unsupported width %d\n",
++ +++ params_width(params));
return -EINVAL;
}
if (dac33->irq >= 0) {
ret = request_irq(dac33->irq, dac33_interrupt_handler,
IRQF_TRIGGER_RISING,
----- codec->name, codec);
+++++ codec->component.name, codec);
if (ret < 0) {
dev_err(codec->dev, "Could not request IRQ%d (%d)\n",
dac33->irq, ret);
static void twl4030_apll_enable(struct snd_soc_codec *codec, int enable)
{
struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
----- int status = -1;
if (enable) {
twl4030->apll_enabled++;
if (twl4030->apll_enabled == 1)
----- status = twl4030_audio_enable_resource(
+++++ twl4030_audio_enable_resource(
TWL4030_AUDIO_RES_APLL);
} else {
twl4030->apll_enabled--;
if (!twl4030->apll_enabled)
----- status = twl4030_audio_disable_resource(
+++++ twl4030_audio_disable_resource(
TWL4030_AUDIO_RES_APLL);
}
}
old_format = twl4030_read(codec, TWL4030_REG_AUDIO_IF);
format = old_format;
format &= ~TWL4030_DATA_WIDTH;
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
format |= TWL4030_DATA_WIDTH_16S_16W;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
format |= TWL4030_DATA_WIDTH_32S_24W;
break;
default:
-- --- dev_err(codec->dev, "%s: unknown format %d\n", __func__,
-- --- params_format(params));
++ +++ dev_err(codec->dev, "%s: unsupported bits/sample %d\n",
++ +++ __func__, params_width(params));
return -EINVAL;
}
twl4030 = devm_kzalloc(codec->dev, sizeof(struct twl4030_priv),
GFP_KERNEL);
----- if (twl4030 == NULL) {
----- dev_err(codec->dev, "Can not allocate memory\n");
+++++ if (!twl4030)
return -ENOMEM;
----- }
snd_soc_codec_set_drvdata(codec, twl4030);
/* Set the defaults, and power up the codec */
twl4030->sysclk = twl4030_audio_get_mclk() / 1000;
case SND_SOC_DAIFMT_I2S:
break;
case SND_SOC_DAIFMT_RIGHT_J:
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
hw_params |= (1<<1);
break;
-- --- case SNDRV_PCM_FORMAT_S18_3LE:
++ +++ case 18:
hw_params |= (1<<2);
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
hw_params |= ((1<<2) | (1<<1));
break;
default:
static int uda134x_soc_probe(struct snd_soc_codec *codec)
{
struct uda134x_priv *uda134x;
----- struct uda134x_platform_data *pd = codec->card->dev->platform_data;
+++++ struct uda134x_platform_data *pd = codec->component.card->dev->platform_data;
const struct snd_soc_dapm_widget *widgets;
unsigned num_widgets;
struct wl1273_core *core = wl1273->core;
unsigned int rate, width, r;
-- --- if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) {
-- --- pr_err("Only SNDRV_PCM_FORMAT_S16_LE supported.\n");
++ +++ if (params_width(params) != 16) {
++ +++ dev_err(dai->dev, "%d bits/sample not supported\n",
++ +++ params_width(params));
return -EINVAL;
}
}
wl1273 = kzalloc(sizeof(struct wl1273_priv), GFP_KERNEL);
----- if (wl1273 == NULL) {
----- dev_err(codec->dev, "Cannot allocate memory.\n");
+++++ if (!wl1273)
return -ENOMEM;
----- }
wl1273->mode = WL1273_MODE_BT;
wl1273->core = *core;
static const char *wm0010_state_to_str(enum wm0010_state state)
{
--- -- const char *state_to_str[] = {
+++ ++ static const char * const state_to_str[] = {
"Power off",
"Out of reset",
"Boot ROM",
xfer = kzalloc(sizeof(*xfer), GFP_KERNEL);
if (!xfer) {
----- dev_err(codec->dev, "Failed to allocate xfer\n");
ret = -ENOMEM;
goto abort;
}
out = kzalloc(len, GFP_KERNEL | GFP_DMA);
if (!out) {
----- dev_err(codec->dev,
----- "Failed to allocate RX buffer\n");
ret = -ENOMEM;
goto abort1;
}
img = kzalloc(len, GFP_KERNEL | GFP_DMA);
if (!img) {
----- dev_err(codec->dev,
----- "Failed to allocate image buffer\n");
ret = -ENOMEM;
goto abort1;
}
/* Copy to local buffer first as vmalloc causes problems for dma */
img = kzalloc(fw->size, GFP_KERNEL | GFP_DMA);
if (!img) {
----- dev_err(codec->dev, "Failed to allocate image buffer\n");
ret = -ENOMEM;
goto abort2;
}
out = kzalloc(fw->size, GFP_KERNEL | GFP_DMA);
if (!out) {
----- dev_err(codec->dev, "Failed to allocate output buffer\n");
ret = -ENOMEM;
goto abort1;
}
}
img_swap = kzalloc(len, GFP_KERNEL | GFP_DMA);
----- if (!img_swap) {
----- dev_err(codec->dev,
----- "Failed to allocate image buffer\n");
+++++ if (!img_swap)
goto abort;
----- }
/* We need to re-order for 0010 */
byte_swap_64((u64 *)&pll_rec, img_swap, len);
~WM8350_AIF_WL_MASK;
/* bit size */
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
iface |= 0x1 << 10;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
iface |= 0x2 << 10;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
iface |= 0x3 << 10;
break;
}
{
struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec);
struct wm8350 *wm8350 = priv->wm8350;
----- int irq;
int ena;
switch (which) {
case WM8350_JDL:
priv->hpl.jack = jack;
priv->hpl.report = report;
----- irq = WM8350_IRQ_CODEC_JCK_DET_L;
ena = WM8350_JDL_ENA;
break;
case WM8350_JDR:
priv->hpr.jack = jack;
priv->hpr.report = report;
----- irq = WM8350_IRQ_CODEC_JCK_DET_R;
ena = WM8350_JDR_ENA;
break;
static void wm8903_seq_notifier(struct snd_soc_dapm_context *dapm,
enum snd_soc_dapm_type event, int subseq)
{
----- struct snd_soc_codec *codec = container_of(dapm,
----- struct snd_soc_codec, dapm);
+++++ struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
struct wm8903_priv *wm8903 = snd_soc_codec_get_drvdata(codec);
int dcs_mode = WM8903_DCS_MODE_WRITE_STOP;
int i, val;
aif1 &= ~WM8903_AIF_WL_MASK;
bclk = 2 * fs;
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
bclk *= 16;
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
bclk *= 20;
aif1 |= 0x4;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
bclk *= 24;
aif1 |= 0x8;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
bclk *= 32;
aif1 |= 0xc;
break;
* published by the Free Software Foundation.
*/
++++ +#include <linux/clk.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
/* codec private data */
struct wm8904_priv {
struct regmap *regmap;
++++ + struct clk *mclk;
enum wm8904_type devtype;
wm8904->bclk = snd_soc_params_to_bclk(params);
}
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
aif1 |= 0x40;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
aif1 |= 0x80;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
aif1 |= 0xc0;
break;
default:
switch (level) {
case SND_SOC_BIAS_ON:
++++ + clk_prepare_enable(wm8904->mclk);
break;
case SND_SOC_BIAS_PREPARE:
regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies),
wm8904->supplies);
++++ + clk_disable_unprepare(wm8904->mclk);
break;
}
codec->dapm.bias_level = level;
/* We need an array of texts for the enum API */
wm8904->drc_texts = kmalloc(sizeof(char *)
* pdata->num_drc_cfgs, GFP_KERNEL);
----- if (!wm8904->drc_texts) {
----- dev_err(codec->dev,
----- "Failed to allocate %d DRC config texts\n",
----- pdata->num_drc_cfgs);
+++++ if (!wm8904->drc_texts)
return;
----- }
for (i = 0; i < pdata->num_drc_cfgs; i++)
wm8904->drc_texts[i] = pdata->drc_cfgs[i].name;
if (wm8904 == NULL)
return -ENOMEM;
++++ + wm8904->mclk = devm_clk_get(&i2c->dev, "mclk");
++++ + if (IS_ERR(wm8904->mclk)) {
++++ + ret = PTR_ERR(wm8904->mclk);
++++ + dev_err(&i2c->dev, "Failed to get MCLK\n");
++++ + return ret;
++++ + }
++++ +
wm8904->regmap = devm_regmap_init_i2c(i2c, &wm8904_regmap);
if (IS_ERR(wm8904->regmap)) {
ret = PTR_ERR(wm8904->regmap);
* list each time to find the desired power state do so now
* and save the result.
*/
----- list_for_each_entry(w, &codec->card->widgets, list) {
+++++ list_for_each_entry(w, &codec->component.card->widgets, list) {
if (w->dapm != &codec->dapm)
continue;
if (strcmp(w->name, "LOUT1 PGA") == 0)
struct snd_soc_codec *codec = dai->codec;
struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
u16 iface = snd_soc_read(codec, WM8960_IFACE1) & 0xfff3;
-- --- snd_pcm_format_t format = params_format(params);
int i;
/* bit size */
-- --- switch (format) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
-- --- case SNDRV_PCM_FORMAT_S16_BE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
-- --- case SNDRV_PCM_FORMAT_S20_3BE:
++ +++ case 20:
iface |= 0x0004;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
-- --- case SNDRV_PCM_FORMAT_S24_BE:
++ +++ case 24:
iface |= 0x0008;
break;
default:
-- --- dev_err(codec->dev, "unsupported format %i\n", format);
++ +++ dev_err(codec->dev, "unsupported width %d\n",
++ +++ params_width(params));
return -EINVAL;
}
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
+++++ #include <linux/clk.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/gcd.h>
if (wm8962->lrclk % 8000 == 0)
adctl3 |= WM8962_SAMPLE_RATE_INT_MODE;
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
aif0 |= 0x4;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
aif0 |= 0x8;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
aif0 |= 0xc;
break;
default:
pdata->gpio_init[i] = 0x0;
}
+++++ pdata->mclk = devm_clk_get(&i2c->dev, NULL);
+++++
return 0;
}
return ret;
}
+++++ /* Mark the mclk pointer to NULL if no mclk assigned */
+++++ if (IS_ERR(wm8962->pdata.mclk)) {
+++++ /* But do not ignore the request for probe defer */
+++++ if (PTR_ERR(wm8962->pdata.mclk) == -EPROBE_DEFER)
+++++ return -EPROBE_DEFER;
+++++ wm8962->pdata.mclk = NULL;
+++++ }
+++++
for (i = 0; i < ARRAY_SIZE(wm8962->supplies); i++)
wm8962->supplies[i].supply = wm8962_supply_names[i];
struct wm8962_priv *wm8962 = dev_get_drvdata(dev);
int ret;
+++++ ret = clk_prepare_enable(wm8962->pdata.mclk);
+++++ if (ret) {
+++++ dev_err(dev, "Failed to enable MCLK: %d\n", ret);
+++++ return ret;
+++++ }
+++++
ret = regulator_bulk_enable(ARRAY_SIZE(wm8962->supplies),
wm8962->supplies);
if (ret != 0) {
regulator_bulk_disable(ARRAY_SIZE(wm8962->supplies),
wm8962->supplies);
+++++ clk_disable_unprepare(wm8962->pdata.mclk);
+++++
return 0;
}
#endif
}
bclk_rate = params_rate(params);
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
bclk_rate *= 16;
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
bclk_rate *= 20;
aif1 |= 0x20;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
bclk_rate *= 24;
aif1 |= 0x40;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
bclk_rate *= 32;
aif1 |= 0x60;
break;
return 0;
}
-- --- switch (params_format(params)) {
-- --- case SNDRV_PCM_FORMAT_S16_LE:
++ +++ switch (params_width(params)) {
++ +++ case 16:
break;
-- --- case SNDRV_PCM_FORMAT_S20_3LE:
++ +++ case 20:
aif1 |= 0x20;
break;
-- --- case SNDRV_PCM_FORMAT_S24_LE:
++ +++ case 24:
aif1 |= 0x40;
break;
-- --- case SNDRV_PCM_FORMAT_S32_LE:
++ +++ case 32:
aif1 |= 0x60;
break;
default:
/* We need an array of texts for the enum API */
wm8994->drc_texts = devm_kzalloc(wm8994->hubs.codec->dev,
sizeof(char *) * pdata->num_drc_cfgs, GFP_KERNEL);
----- if (!wm8994->drc_texts) {
----- dev_err(wm8994->hubs.codec->dev,
----- "Failed to allocate %d DRC config texts\n",
----- pdata->num_drc_cfgs);
+++++ if (!wm8994->drc_texts)
return;
----- }
for (i = 0; i < pdata->num_drc_cfgs; i++)
wm8994->drc_texts[i] = pdata->drc_cfgs[i].name;
return IRQ_HANDLED;
}
+++++/* Should be called with accdet_lock held */
static void wm1811_micd_stop(struct snd_soc_codec *codec)
{
struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
if (!wm8994->jackdet)
return;
----- mutex_lock(&wm8994->accdet_lock);
-----
snd_soc_update_bits(codec, WM8958_MIC_DETECT_1, WM8958_MICD_ENA, 0);
wm1811_jackdet_set_mode(codec, WM1811_JACKDET_MODE_JACK);
----- mutex_unlock(&wm8994->accdet_lock);
-----
if (wm8994->wm8994->pdata.jd_ext_cap)
snd_soc_dapm_disable_pin(&codec->dapm,
"MICBIAS2");
open_circuit_work.work);
struct device *dev = wm8994->wm8994->dev;
----- wm1811_micd_stop(wm8994->hubs.codec);
-----
mutex_lock(&wm8994->accdet_lock);
+++++ wm1811_micd_stop(wm8994->hubs.codec);
+++++
dev_dbg(dev, "Reporting open circuit\n");
wm8994->jack_mic = false;