int snd_soc_component_init(struct snd_soc_component *component);
 
 /* component IO */
-int snd_soc_component_read(struct snd_soc_component *component,
-                          unsigned int reg, unsigned int *val);
-unsigned int snd_soc_component_read32(struct snd_soc_component *component,
+#define snd_soc_component_read32 snd_soc_component_read
+unsigned int snd_soc_component_read(struct snd_soc_component *component,
                                      unsigned int reg);
 int snd_soc_component_write(struct snd_soc_component *component,
                            unsigned int reg, unsigned int val);
 
         */
        udelay(5000000 / priv->rate);
 
-       snd_soc_component_read(component, PW_MGMT1, &mgmt1);
-       snd_soc_component_read(component, PW_MGMT3, &mgmt3);
+       mgmt1 = snd_soc_component_read(component, PW_MGMT1);
+       mgmt3 = snd_soc_component_read(component, PW_MGMT3);
 
        snd_soc_component_write(component, PW_MGMT1, mgmt1);
        snd_soc_component_write(component, PW_MGMT3, mgmt3);
 
        struct snd_soc_component *component =
                snd_soc_dapm_to_component(w->dapm);
        unsigned int val;
-       int ret;
 
        switch (w->shift) {
        case MADERA_OUT1L_ENA_SHIFT:
        case MADERA_OUT1R_ENA_SHIFT:
-               ret = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1,
-                                            &val);
-               if (ret) {
-                       dev_err(component->dev,
-                               "Failed to check output enables: %d\n", ret);
-                       return;
-               }
-
+               val = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1);
                val &= (MADERA_OUT1L_ENA | MADERA_OUT1R_ENA);
 
                if (val != (MADERA_OUT1L_ENA | MADERA_OUT1R_ENA))
 
        struct snd_soc_component *component =
                snd_soc_dapm_to_component(w->dapm);
        unsigned int val;
-       int ret;
 
        switch (w->shift) {
        case MADERA_OUT1L_ENA_SHIFT:
        case MADERA_OUT1R_ENA_SHIFT:
-               ret = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1,
-                                            &val);
-               if (ret) {
-                       dev_err(component->dev,
-                               "Failed to check output enables: %d\n", ret);
-                       return;
-               }
-
+               val = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1);
                val &= (MADERA_OUT1L_ENA | MADERA_OUT1R_ENA);
 
                if (val != (MADERA_OUT1L_ENA | MADERA_OUT1R_ENA))
 
                                    struct snd_ctl_elem_value *ucontrol)
 {
        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-       int val, ret, regval;
+       int val, regval;
 
-       ret = snd_soc_component_read(component, INNO_R09, ®val);
-       if (ret)
-               return ret;
+       regval = snd_soc_component_read(component, INNO_R09);
        val = ((regval >> INNO_R09_HPL_ANITPOP_SHIFT) &
               INNO_R09_HP_ANTIPOP_MSK) == INNO_R09_HP_ANTIPOP_ON;
        ucontrol->value.integer.value[0] = val;
 
        struct snd_soc_component *component =
                snd_soc_dapm_kcontrol_component(kcontrol);
        unsigned int val;
-       int ret;
-
-       ret = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1, &val);
-       if (ret)
-               return ret;
 
+       val = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1);
        val &= MADERA_EP_SEL_MASK;
        val >>= MADERA_EP_SEL_SHIFT;
        ucontrol->value.enumerated.item[0] = val;
         */
        mutex_lock(&priv->rate_lock);
 
-       ret = snd_soc_component_read(component, e->reg, &val);
-       if (ret < 0) {
-               dev_warn(priv->madera->dev, "Failed to read 0x%x (%d)\n",
-                        e->reg, ret);
-               goto out;
-       }
+       val = snd_soc_component_read(component, e->reg);
        val >>= e->shift_l;
        val &= e->mask;
        if (snd_soc_enum_item_to_val(e, item) == val) {
 
        snd_soc_dapm_mutex_lock(dapm);
 
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret)
-               goto exit;
-
+       val = snd_soc_component_read(component, reg);
        if (val & MADERA_DFC1_ENA) {
                ret = -EBUSY;
                dev_err(component->dev, "Can't change mode on an active DFC\n");
        snd_soc_dapm_mutex_lock(dapm);
 
        /* Cannot change lp mode on an active input */
-       ret = snd_soc_component_read(component, MADERA_INPUT_ENABLES, &val);
-       if (ret)
-               goto exit;
+       val = snd_soc_component_read(component, MADERA_INPUT_ENABLES);
        mask = (mc->reg - MADERA_ADC_DIGITAL_VOLUME_1L) / 4;
        mask ^= 0x1; /* Flip bottom bit for channel order */
 
        struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
        struct madera_priv *priv = snd_soc_component_get_drvdata(component);
        unsigned int reg, val;
-       int ret;
 
        if (w->shift % 2)
                reg = MADERA_ADC_DIGITAL_VOLUME_1L + ((w->shift / 2) * 8);
                break;
        case SND_SOC_DAPM_POST_PMD:
                /* Disable volume updates if no inputs are enabled */
-               ret = snd_soc_component_read(component, MADERA_INPUT_ENABLES,
-                                            &val);
-               if (!ret && !val)
+               val = snd_soc_component_read(component, MADERA_INPUT_ENABLES);
+               if (!val)
                        madera_in_set_vu(priv, false);
                break;
        default:
                                  int base, int bclk, int lrclk, int frame)
 {
        unsigned int val;
-       int ret;
 
-       ret = snd_soc_component_read(component, base + MADERA_AIF_BCLK_CTRL,
-                                    &val);
-       if (ret)
-               return ret;
+       val = snd_soc_component_read(component, base + MADERA_AIF_BCLK_CTRL);
        if (bclk != (val & MADERA_AIF1_BCLK_FREQ_MASK))
                return 1;
 
-       ret = snd_soc_component_read(component, base + MADERA_AIF_RX_BCLK_RATE,
-                                    &val);
-       if (ret)
-               return ret;
+       val = snd_soc_component_read(component, base + MADERA_AIF_RX_BCLK_RATE);
        if (lrclk != (val & MADERA_AIF1RX_BCPF_MASK))
                return 1;
 
-       ret = snd_soc_component_read(component, base + MADERA_AIF_FRAME_CTRL_1,
-                                    &val);
-       if (ret)
-               return ret;
+       val = snd_soc_component_read(component, base + MADERA_AIF_FRAME_CTRL_1);
        if (frame != (val & (MADERA_AIF1TX_WL_MASK |
                             MADERA_AIF1TX_SLOT_LEN_MASK)))
                return 1;
        }
 
        /* Force multiple of 2 channels for I2S mode */
-       ret = snd_soc_component_read(component, base + MADERA_AIF_FORMAT, &val);
-       if (ret)
-               return ret;
-
+       val = snd_soc_component_read(component, base + MADERA_AIF_FORMAT);
        val &= MADERA_AIF1_FMT_MASK;
        if ((channels & 1) && val == MADERA_FMT_I2S_MODE) {
                madera_aif_dbg(dai, "Forcing stereo mode\n");
 
        unsigned int ctrl_val, bclk_fs, bclk_div;
 
        /* make BCLK and LRC divide configuration if the codec as master. */
-       snd_soc_component_read(component, NAU8822_REG_CLOCKING, &ctrl_val);
+       ctrl_val = snd_soc_component_read(component, NAU8822_REG_CLOCKING);
        if (ctrl_val & NAU8822_CLK_MASTER) {
                /* get the bclk and fs ratio */
                bclk_fs = snd_soc_params_to_bclk(params) / params_rate(params);
 
        struct rt1305_priv *rt1305 = snd_soc_component_get_drvdata(component);
        unsigned int val;
 
-       snd_soc_component_read(component, RT1305_CLK_1, &val);
+       val = snd_soc_component_read(component, RT1305_CLK_1);
 
        if (rt1305->sysclk_src == RT1305_FS_SYS_PRE_S_PLL1 &&
                (val & RT1305_SEL_PLL_SRC_2_RCCLK))
 
        struct snd_soc_component *component = rt5682->component;
        unsigned int bclks_per_wclk;
 
-       snd_soc_component_read(component, RT5682_TDM_TCON_CTRL,
-               &bclks_per_wclk);
+       bclks_per_wclk = snd_soc_component_read(component, RT5682_TDM_TCON_CTRL);
 
        switch (bclks_per_wclk & RT5682_TDM_BCLK_MS1_MASK) {
        case RT5682_TDM_BCLK_MS1_256:
 
        struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
        unsigned int val;
 
-       snd_soc_component_read(component, TAS5720_VOLUME_CTRL_REG, &val);
+       val = snd_soc_component_read(component, TAS5720_VOLUME_CTRL_REG);
        ucontrol->value.integer.value[0] = val << 1;
 
-       snd_soc_component_read(component, TAS5722_DIGITAL_CTRL2_REG, &val);
+       val = snd_soc_component_read(component, TAS5722_DIGITAL_CTRL2_REG);
        ucontrol->value.integer.value[0] |= val & TAS5722_VOL_CONTROL_LSB;
 
        return 0;
 
        int thresh = tvc->thresh;
        unsigned int invert = tvc->invert;
        int val;
-       int ret;
 
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret < 0)
-               return ret;
+       val = snd_soc_component_read(component, reg);
        ucontrol->value.integer.value[0] =
                tda7419_vol_get_value(val, mask, min, thresh, invert);
 
        if (tda7419_vol_is_stereo(tvc)) {
-               ret = snd_soc_component_read(component, rreg, &val);
-               if (ret < 0)
-                       return ret;
+               val = snd_soc_component_read(component, rreg);
                ucontrol->value.integer.value[1] =
                        tda7419_vol_get_value(val, mask, min, thresh, invert);
        }
 
        for (cnt = 0; cnt < coeff_cnt; cnt++, coeff_addr++) {
 
                for (trys = 0; trys < DACCRSTAT_MAX_TRYS; trys++) {
-                       ret = snd_soc_component_read(component, r_stat, &val);
-                       if (ret < 0) {
-                               dev_err(component->dev,
-                                       "Failed to read stat (%d)\n", ret);
-                               return ret;
-                       }
+                       val = snd_soc_component_read(component, r_stat);
                        if (!val)
                                break;
                }
        mutex_lock(&tscs454->pll1.lock);
        mutex_lock(&tscs454->pll2.lock);
 
-       ret = snd_soc_component_read(component, R_PLLSTAT, &val);
-       if (ret < 0) {
-               dev_err(component->dev, "Failed to read PLL status (%d)\n",
-                               ret);
-               goto exit;
-       }
+       val = snd_soc_component_read(component, R_PLLSTAT);
        if (val) { /* PLLs locked */
                ret = write_coeff_ram(component, coeff_ram,
                        r_stat, r_addr, r_wr,
        struct tscs454 *tscs454 = snd_soc_component_get_drvdata(component);
        unsigned int val;
        int bclk_dai;
-       int ret;
 
        dev_dbg(component->dev, "%s(): freq = %u\n", __func__, freq);
 
-       ret = snd_soc_component_read(component, R_PLLCTL, &val);
-       if (ret < 0)
-               return ret;
+       val = snd_soc_component_read(component, R_PLLCTL);
 
        bclk_dai = (val & FM_PLLCTL_BCLKSEL) >> FB_PLLCTL_BCLKSEL;
        if (bclk_dai != dai->id)
        }
 
        if (!aifs_active(&tscs454->aifs_status)) { /* First active aif */
-               ret = snd_soc_component_read(component, R_ISRC, &val);
-               if (ret < 0)
-                       goto exit;
-
+               val = snd_soc_component_read(component, R_ISRC);
                if ((val & FM_ISRC_IBR) == FV_IBR_48)
                        tscs454->internal_rate.pll = &tscs454->pll1;
                else
 
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int *item = ucontrol->value.enumerated.item;
        unsigned int reg_val, val, mix_clk;
-       int ret;
 
        /* Get current state */
-       ret = snd_soc_component_read(comp, FSL_AUDMIX_CTR, ®_val);
-       if (ret)
-               return ret;
-
+       reg_val = snd_soc_component_read(comp, FSL_AUDMIX_CTR);
        mix_clk = ((reg_val & FSL_AUDMIX_CTR_MIXCLK_MASK)
                        >> FSL_AUDMIX_CTR_MIXCLK_SHIFT);
        val = snd_soc_enum_item_to_val(e, item[0]);
        int ret;
 
        /* Get current state */
-       ret = snd_soc_component_read(comp, FSL_AUDMIX_CTR, ®_val);
-       if (ret)
-               return ret;
+       reg_val = snd_soc_component_read(comp, FSL_AUDMIX_CTR);
 
        /* "From" state */
        out_src = ((reg_val & FSL_AUDMIX_CTR_OUTSRC_MASK)
 
        struct soc_mreg_control *mc =
                (struct soc_mreg_control *)kcontrol->private_value;
        unsigned int regval;
-       int ret;
 
-       ret = snd_soc_component_read(component, mc->regbase, ®val);
-       if (ret < 0)
-               return ret;
+       regval = snd_soc_component_read(component, mc->regbase);
 
        ucontrol->value.integer.value[0] = regval;
 
 
 {
        /* Always operate in split (classic interleaved) mode */
        unsigned int desc = AIU_I2S_SOURCE_DESC_MODE_SPLIT;
-       unsigned int val;
 
        /* Reset required to update the pipeline */
        snd_soc_component_write(component, AIU_RST_SOFT, AIU_RST_SOFT_I2S_FAST);
-       snd_soc_component_read(component, AIU_I2S_SYNC, &val);
+       snd_soc_component_read(component, AIU_I2S_SYNC);
 
        switch (params_physical_width(params)) {
        case 16: /* Nothing to do */
 
                                struct snd_soc_dai *dai)
 {
        struct snd_soc_component *component = dai->component;
-       unsigned int val;
 
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                snd_soc_component_write(component, AIU_RST_SOFT,
                                        AIU_RST_SOFT_I2S_FAST);
-               snd_soc_component_read(component, AIU_I2S_SYNC, &val);
+               snd_soc_component_read(component, AIU_I2S_SYNC);
                break;
        }
 
 
        struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned int addr;
 
-       snd_soc_component_read(component, fifo->mem_offset + AIU_MEM_RD,
-                              &addr);
+       addr = snd_soc_component_read(component, fifo->mem_offset + AIU_MEM_RD);
 
        return bytes_to_frames(runtime, addr - (unsigned int)runtime->dma_addr);
 }
 
        struct snd_soc_component *component = gpio_to_component(chip);
        int ret;
 
-       if (snd_soc_component_read(component, AC97_GPIO_STATUS, &ret) < 0)
-               ret = -1;
+       ret = snd_soc_component_read(component, AC97_GPIO_STATUS);
 
        dev_dbg(component->dev, "get gpio %d : %d\n", offset,
-               ret < 0 ? ret : ret & (1 << offset));
+               ret & (1 << offset));
 
-       return ret < 0 ? ret : !!(ret & (1 << offset));
+       return !!(ret & (1 << offset));
 }
 
 static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
 
  * snd_soc_component_read() - Read register value
  * @component: Component to read from
  * @reg: Register to read
- * @val: Pointer to where the read value is stored
  *
- * Return: 0 on success, a negative error code otherwise.
+ * Return: read value
  */
-int snd_soc_component_read(struct snd_soc_component *component,
-                          unsigned int reg, unsigned int *val)
+unsigned int snd_soc_component_read(struct snd_soc_component *component,
+                                   unsigned int reg)
 {
        int ret;
+       unsigned int val = 0;
 
        if (component->regmap)
-               ret = regmap_read(component->regmap, reg, val);
+               ret = regmap_read(component->regmap, reg, &val);
        else if (component->driver->read) {
-               *val = component->driver->read(component, reg);
                ret = 0;
+               val = component->driver->read(component, reg);
        }
        else
                ret = -EIO;
 
-       return soc_component_ret(component, ret);
-}
-EXPORT_SYMBOL_GPL(snd_soc_component_read);
-
-unsigned int snd_soc_component_read32(struct snd_soc_component *component,
-                                     unsigned int reg)
-{
-       unsigned int val;
-       int ret;
-
-       ret = snd_soc_component_read(component, reg, &val);
        if (ret < 0)
-               return soc_component_ret(component, -1);
+               soc_component_ret(component, ret);
 
        return val;
 }
-EXPORT_SYMBOL_GPL(snd_soc_component_read32);
+EXPORT_SYMBOL_GPL(snd_soc_component_read);
 
 /**
  * snd_soc_component_write() - Write register value
        unsigned int mask, unsigned int val, bool *change)
 {
        unsigned int old, new;
-       int ret;
+       int ret = 0;
 
        mutex_lock(&component->io_mutex);
 
-       ret = snd_soc_component_read(component, reg, &old);
-       if (ret < 0)
-               goto out_unlock;
+       old = snd_soc_component_read(component, reg);
 
        new = (old & ~mask) | (val & mask);
        *change = old != new;
        if (*change)
                ret = snd_soc_component_write(component, reg, new);
-out_unlock:
+
        mutex_unlock(&component->io_mutex);
 
        return soc_component_ret(component, ret);
                                unsigned int reg, unsigned int mask, unsigned int value)
 {
        unsigned int old, new;
-       int ret;
 
-       ret = snd_soc_component_read(component, reg, &old);
-       if (ret < 0)
-               return soc_component_ret(component, ret);
+       old = snd_soc_component_read(component, reg);
        new = (old & ~mask) | value;
        return old != new;
 }
 
        return dapm->component->name_prefix;
 }
 
-static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
-       unsigned int *value)
+static unsigned int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg)
 {
        if (!dapm->component)
                return -EIO;
-       return snd_soc_component_read(dapm->component, reg, value);
+       return  snd_soc_component_read(dapm->component, reg);
 }
 
 static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
        int i;
 
        if (e->reg != SND_SOC_NOPM) {
-               soc_dapm_read(dapm, e->reg, &val);
+               val = soc_dapm_read(dapm, e->reg);
                val = (val >> e->shift_l) & e->mask;
                item = snd_soc_enum_val_to_item(e, val);
        } else {
        unsigned int val;
 
        if (reg != SND_SOC_NOPM) {
-               soc_dapm_read(p->sink->dapm, reg, &val);
+               val = soc_dapm_read(p->sink->dapm, reg);
                /*
                 * The nth_path argument allows this function to know
                 * which path of a kcontrol it is setting the initial
                 */
                if (snd_soc_volsw_is_stereo(mc) && nth_path > 0) {
                        if (reg != mc->rreg)
-                               soc_dapm_read(p->sink->dapm, mc->rreg, &val);
+                               val = soc_dapm_read(p->sink->dapm, mc->rreg);
                        val = (val >> mc->rshift) & mask;
                } else {
                        val = (val >> shift) & mask;
 
                /* Read the initial power state from the device */
                if (w->reg >= 0) {
-                       soc_dapm_read(w->dapm, w->reg, &val);
+                       val = soc_dapm_read(w->dapm, w->reg);
                        val = val >> w->shift;
                        val &= w->mask;
                        if (val == w->on_val)
        unsigned int mask = (1 << fls(max)) - 1;
        unsigned int invert = mc->invert;
        unsigned int reg_val, val, rval = 0;
-       int ret = 0;
 
        mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
        if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
-               ret = soc_dapm_read(dapm, reg, ®_val);
+               reg_val = soc_dapm_read(dapm, reg);
                val = (reg_val >> shift) & mask;
 
-               if (ret == 0 && reg != mc->rreg)
-                       ret = soc_dapm_read(dapm, mc->rreg, ®_val);
+               if (reg != mc->rreg)
+                       reg_val = soc_dapm_read(dapm, mc->rreg);
 
                if (snd_soc_volsw_is_stereo(mc))
                        rval = (reg_val >> mc->rshift) & mask;
        }
        mutex_unlock(&card->dapm_mutex);
 
-       if (ret)
-               return ret;
-
        if (invert)
                ucontrol->value.integer.value[0] = max - val;
        else
                        ucontrol->value.integer.value[1] = rval;
        }
 
-       return ret;
+       return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
 
 
        mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
        if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
-               int ret = soc_dapm_read(dapm, e->reg, ®_val);
-               if (ret) {
-                       mutex_unlock(&card->dapm_mutex);
-                       return ret;
-               }
+               reg_val = soc_dapm_read(dapm, e->reg);
        } else {
                reg_val = dapm_kcontrol_get_value(kcontrol);
        }
 
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int val, item;
        unsigned int reg_val;
-       int ret;
 
-       ret = snd_soc_component_read(component, e->reg, ®_val);
-       if (ret)
-               return ret;
+       reg_val = snd_soc_component_read(component, e->reg);
        val = (reg_val >> e->shift_l) & e->mask;
        item = snd_soc_enum_val_to_item(e, val);
        ucontrol->value.enumerated.item[0] = item;
        int ret;
        unsigned int val;
 
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret < 0)
-               return ret;
-
+       val = snd_soc_component_read(component, reg);
        val = (val >> shift) & mask;
 
        if (!sign_bit) {
        int min = mc->min;
        unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
        unsigned int val;
-       int ret;
-
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret < 0)
-               return ret;
 
+       val = snd_soc_component_read(component, reg);
        ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
 
        if (snd_soc_volsw_is_stereo(mc)) {
-               ret = snd_soc_component_read(component, reg2, &val);
-               if (ret < 0)
-                       return ret;
-
+               val = snd_soc_component_read(component, reg2);
                val = ((val >> rshift) - min) & mask;
                ucontrol->value.integer.value[1] = val;
        }
        unsigned int mask = (1 << fls(max)) - 1;
        unsigned int invert = mc->invert;
        unsigned int val;
-       int ret;
-
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret)
-               return ret;
 
+       val = snd_soc_component_read(component, reg);
        ucontrol->value.integer.value[0] = (val >> shift) & mask;
        if (invert)
                ucontrol->value.integer.value[0] =
                        ucontrol->value.integer.value[0] - min;
 
        if (snd_soc_volsw_is_stereo(mc)) {
-               ret = snd_soc_component_read(component, rreg, &val);
-               if (ret)
-                       return ret;
-
+               val = snd_soc_component_read(component, rreg);
                ucontrol->value.integer.value[1] = (val >> shift) & mask;
                if (invert)
                        ucontrol->value.integer.value[1] =
        long val = 0;
        unsigned int regval;
        unsigned int i;
-       int ret;
 
        for (i = 0; i < regcount; i++) {
-               ret = snd_soc_component_read(component, regbase+i, ®val);
-               if (ret)
-                       return ret;
+               regval = snd_soc_component_read(component, regbase+i);
                val |= (regval & regwmask) << (regwshift*(regcount-i-1));
        }
        val &= mask;
        unsigned int mask = 1 << shift;
        unsigned int invert = mc->invert != 0;
        unsigned int val;
-       int ret;
-
-       ret = snd_soc_component_read(component, reg, &val);
-       if (ret)
-               return ret;
 
+       val = snd_soc_component_read(component, reg);
        val &= mask;
 
        if (shift != 0 && val != 0)