sound/soc/codecs/cs35l35.c

   1 /*
   2  * cs35l35.c -- CS35L35 ALSA SoC audio driver
   3  *
   4  * Copyright 2017 Cirrus Logic, Inc.
   5  *
   6  * Author: Brian Austin <brian.austin@cirrus.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/version.h>
  17 #include <linux/kernel.h>
  18 #include <linux/init.h>
  19 #include <linux/delay.h>
  20 #include <linux/i2c.h>
  21 #include <linux/slab.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/regulator/consumer.h>
  24 #include <linux/gpio/consumer.h>
  25 #include <linux/of_device.h>
  26 #include <linux/of_gpio.h>
  27 #include <linux/regmap.h>
  28 #include <sound/core.h>
  29 #include <sound/pcm.h>
  30 #include <sound/pcm_params.h>
  31 #include <sound/soc.h>
  32 #include <sound/soc-dapm.h>
  33 #include <linux/gpio.h>
  34 #include <sound/initval.h>
  35 #include <sound/tlv.h>
  36 #include <sound/cs35l35.h>
  37 #include <linux/of_irq.h>
  38 #include <linux/completion.h>
  39
  40 #include "cs35l35.h"
  41
  42 /*
  43  * Some fields take zero as a valid value so use a high bit flag that won't
  44  * get written to the device to mark those.
  45  */
  46 #define CS35L35_VALID_PDATA 0x80000000
  47
  48 static const struct reg_default cs35l35_reg[] = {
  49         {CS35L35_PWRCTL1,               0x01},
  50         {CS35L35_PWRCTL2,               0x11},
  51         {CS35L35_PWRCTL3,               0x00},
  52         {CS35L35_CLK_CTL1,              0x04},
  53         {CS35L35_CLK_CTL2,              0x12},
  54         {CS35L35_CLK_CTL3,              0xCF},
  55         {CS35L35_SP_FMT_CTL1,           0x20},
  56         {CS35L35_SP_FMT_CTL2,           0x00},
  57         {CS35L35_SP_FMT_CTL3,           0x02},
  58         {CS35L35_MAG_COMP_CTL,          0x00},
  59         {CS35L35_AMP_INP_DRV_CTL,       0x01},
  60         {CS35L35_AMP_DIG_VOL_CTL,       0x12},
  61         {CS35L35_AMP_DIG_VOL,           0x00},
  62         {CS35L35_ADV_DIG_VOL,           0x00},
  63         {CS35L35_PROTECT_CTL,           0x06},
  64         {CS35L35_AMP_GAIN_AUD_CTL,      0x13},
  65         {CS35L35_AMP_GAIN_PDM_CTL,      0x00},
  66         {CS35L35_AMP_GAIN_ADV_CTL,      0x00},
  67         {CS35L35_GPI_CTL,               0x00},
  68         {CS35L35_BST_CVTR_V_CTL,        0x00},
  69         {CS35L35_BST_PEAK_I,            0x07},
  70         {CS35L35_BST_RAMP_CTL,          0x85},
  71         {CS35L35_BST_CONV_COEF_1,       0x24},
  72         {CS35L35_BST_CONV_COEF_2,       0x24},
  73         {CS35L35_BST_CONV_SLOPE_COMP,   0x4E},
  74         {CS35L35_BST_CONV_SW_FREQ,      0x04},
  75         {CS35L35_CLASS_H_CTL,           0x0B},
  76         {CS35L35_CLASS_H_HEADRM_CTL,    0x0B},
  77         {CS35L35_CLASS_H_RELEASE_RATE,  0x08},
  78         {CS35L35_CLASS_H_FET_DRIVE_CTL, 0x41},
  79         {CS35L35_CLASS_H_VP_CTL,        0xC5},
  80         {CS35L35_VPBR_CTL,              0x0A},
  81         {CS35L35_VPBR_VOL_CTL,          0x90},
  82         {CS35L35_VPBR_TIMING_CTL,       0x6A},
  83         {CS35L35_VPBR_MODE_VOL_CTL,     0x00},
  84         {CS35L35_SPKR_MON_CTL,          0xC0},
  85         {CS35L35_IMON_SCALE_CTL,        0x30},
  86         {CS35L35_AUDIN_RXLOC_CTL,       0x00},
  87         {CS35L35_ADVIN_RXLOC_CTL,       0x80},
  88         {CS35L35_VMON_TXLOC_CTL,        0x00},
  89         {CS35L35_IMON_TXLOC_CTL,        0x80},
  90         {CS35L35_VPMON_TXLOC_CTL,       0x04},
  91         {CS35L35_VBSTMON_TXLOC_CTL,     0x84},
  92         {CS35L35_VPBR_STATUS_TXLOC_CTL, 0x04},
  93         {CS35L35_ZERO_FILL_LOC_CTL,     0x00},
  94         {CS35L35_AUDIN_DEPTH_CTL,       0x0F},
  95         {CS35L35_SPKMON_DEPTH_CTL,      0x0F},
  96         {CS35L35_SUPMON_DEPTH_CTL,      0x0F},
  97         {CS35L35_ZEROFILL_DEPTH_CTL,    0x00},
  98         {CS35L35_MULT_DEV_SYNCH1,       0x02},
  99         {CS35L35_MULT_DEV_SYNCH2,       0x80},
 100         {CS35L35_PROT_RELEASE_CTL,      0x00},
 101         {CS35L35_DIAG_MODE_REG_LOCK,    0x00},
 102         {CS35L35_DIAG_MODE_CTL_1,       0x40},
 103         {CS35L35_DIAG_MODE_CTL_2,       0x00},
 104         {CS35L35_INT_MASK_1,            0xFF},
 105         {CS35L35_INT_MASK_2,            0xFF},
 106         {CS35L35_INT_MASK_3,            0xFF},
 107         {CS35L35_INT_MASK_4,            0xFF},
 108
 109 };
 110
 111 static bool cs35l35_volatile_register(struct device *dev, unsigned int reg)
 112 {
 113         switch (reg) {
 114         case CS35L35_INT_STATUS_1:
 115         case CS35L35_INT_STATUS_2:
 116         case CS35L35_INT_STATUS_3:
 117         case CS35L35_INT_STATUS_4:
 118         case CS35L35_PLL_STATUS:
 119         case CS35L35_OTP_TRIM_STATUS:
 120                 return true;
 121         default:
 122                 return false;
 123         }
 124 }
 125
 126 static bool cs35l35_readable_register(struct device *dev, unsigned int reg)
 127 {
 128         switch (reg) {
 129         case CS35L35_DEVID_AB ... CS35L35_PWRCTL3:
 130         case CS35L35_CLK_CTL1 ... CS35L35_SP_FMT_CTL3:
 131         case CS35L35_MAG_COMP_CTL ... CS35L35_AMP_GAIN_AUD_CTL:
 132         case CS35L35_AMP_GAIN_PDM_CTL ... CS35L35_BST_PEAK_I:
 133         case CS35L35_BST_RAMP_CTL ... CS35L35_BST_CONV_SW_FREQ:
 134         case CS35L35_CLASS_H_CTL ... CS35L35_CLASS_H_VP_CTL:
 135         case CS35L35_CLASS_H_STATUS:
 136         case CS35L35_VPBR_CTL ... CS35L35_VPBR_MODE_VOL_CTL:
 137         case CS35L35_VPBR_ATTEN_STATUS:
 138         case CS35L35_SPKR_MON_CTL:
 139         case CS35L35_IMON_SCALE_CTL ... CS35L35_ZEROFILL_DEPTH_CTL:
 140         case CS35L35_MULT_DEV_SYNCH1 ... CS35L35_PROT_RELEASE_CTL:
 141         case CS35L35_DIAG_MODE_REG_LOCK ... CS35L35_DIAG_MODE_CTL_2:
 142         case CS35L35_INT_MASK_1 ... CS35L35_PLL_STATUS:
 143         case CS35L35_OTP_TRIM_STATUS:
 144                 return true;
 145         default:
 146                 return false;
 147         }
 148 }
 149
 150 static bool cs35l35_precious_register(struct device *dev, unsigned int reg)
 151 {
 152         switch (reg) {
 153         case CS35L35_INT_STATUS_1:
 154         case CS35L35_INT_STATUS_2:
 155         case CS35L35_INT_STATUS_3:
 156         case CS35L35_INT_STATUS_4:
 157         case CS35L35_PLL_STATUS:
 158         case CS35L35_OTP_TRIM_STATUS:
 159                 return true;
 160         default:
 161                 return false;
 162         }
 163 }
 164
 165 static int cs35l35_wait_for_pdn(struct cs35l35_private *cs35l35)
 166 {
 167         int ret;
 168
 169         if (cs35l35->pdata.ext_bst) {
 170                 usleep_range(5000, 5500);
 171                 return 0;
 172         }
 173
 174         reinit_completion(&cs35l35->pdn_done);
 175
 176         ret = wait_for_completion_timeout(&cs35l35->pdn_done,
 177                                           msecs_to_jiffies(100));
 178         if (ret == 0) {
 179                 dev_err(cs35l35->dev, "PDN_DONE did not complete\n");
 180                 return -ETIMEDOUT;
 181         }
 182
 183         return 0;
 184 }
 185
 186 static int cs35l35_sdin_event(struct snd_soc_dapm_widget *w,
 187                 struct snd_kcontrol *kcontrol, int event)
 188 {
 189         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 190         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 191         int ret = 0;
 192
 193         switch (event) {
 194         case SND_SOC_DAPM_PRE_PMU:
 195                 regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 196                                         CS35L35_MCLK_DIS_MASK,
 197                                         0 << CS35L35_MCLK_DIS_SHIFT);
 198                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
 199                                         CS35L35_DISCHG_FILT_MASK,
 200                                         0 << CS35L35_DISCHG_FILT_SHIFT);
 201                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
 202                                         CS35L35_PDN_ALL_MASK, 0);
 203                 break;
 204         case SND_SOC_DAPM_POST_PMD:
 205                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
 206                                         CS35L35_DISCHG_FILT_MASK,
 207                                         1 << CS35L35_DISCHG_FILT_SHIFT);
 208                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
 209                                           CS35L35_PDN_ALL_MASK, 1);
 210
 211                 /* Already muted, so disable volume ramp for faster shutdown */
 212                 regmap_update_bits(cs35l35->regmap, CS35L35_AMP_DIG_VOL_CTL,
 213                                    CS35L35_AMP_DIGSFT_MASK, 0);
 214
 215                 ret = cs35l35_wait_for_pdn(cs35l35);
 216
 217                 regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 218                                         CS35L35_MCLK_DIS_MASK,
 219                                         1 << CS35L35_MCLK_DIS_SHIFT);
 220
 221                 regmap_update_bits(cs35l35->regmap, CS35L35_AMP_DIG_VOL_CTL,
 222                                    CS35L35_AMP_DIGSFT_MASK,
 223                                    1 << CS35L35_AMP_DIGSFT_SHIFT);
 224                 break;
 225         default:
 226                 dev_err(codec->dev, "Invalid event = 0x%x\n", event);
 227                 ret = -EINVAL;
 228         }
 229         return ret;
 230 }
 231
 232 static int cs35l35_main_amp_event(struct snd_soc_dapm_widget *w,
 233                 struct snd_kcontrol *kcontrol, int event)
 234 {
 235         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 236         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 237         unsigned int reg[4];
 238         int i;
 239
 240         switch (event) {
 241         case SND_SOC_DAPM_PRE_PMU:
 242                 if (cs35l35->pdata.bst_pdn_fet_on)
 243                         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
 244                                 CS35L35_PDN_BST_MASK,
 245                                 0 << CS35L35_PDN_BST_FETON_SHIFT);
 246                 else
 247                         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
 248                                 CS35L35_PDN_BST_MASK,
 249                                 0 << CS35L35_PDN_BST_FETOFF_SHIFT);
 250                 break;
 251         case SND_SOC_DAPM_POST_PMU:
 252                 usleep_range(5000, 5100);
 253                 /* If in PDM mode we must use VP for Voltage control */
 254                 if (cs35l35->pdm_mode)
 255                         regmap_update_bits(cs35l35->regmap,
 256                                         CS35L35_BST_CVTR_V_CTL,
 257                                         CS35L35_BST_CTL_MASK,
 258                                         0 << CS35L35_BST_CTL_SHIFT);
 259
 260                 regmap_update_bits(cs35l35->regmap, CS35L35_PROTECT_CTL,
 261                         CS35L35_AMP_MUTE_MASK, 0);
 262
 263                 for (i = 0; i < 2; i++)
 264                         regmap_bulk_read(cs35l35->regmap, CS35L35_INT_STATUS_1,
 265                                         &reg, ARRAY_SIZE(reg));
 266
 267                 break;
 268         case SND_SOC_DAPM_PRE_PMD:
 269                 regmap_update_bits(cs35l35->regmap, CS35L35_PROTECT_CTL,
 270                                 CS35L35_AMP_MUTE_MASK,
 271                                 1 << CS35L35_AMP_MUTE_SHIFT);
 272                 if (cs35l35->pdata.bst_pdn_fet_on)
 273                         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
 274                                 CS35L35_PDN_BST_MASK,
 275                                 1 << CS35L35_PDN_BST_FETON_SHIFT);
 276                 else
 277                         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
 278                                 CS35L35_PDN_BST_MASK,
 279                                 1 << CS35L35_PDN_BST_FETOFF_SHIFT);
 280                 break;
 281         case SND_SOC_DAPM_POST_PMD:
 282                 usleep_range(5000, 5100);
 283                 /*
 284                  * If PDM mode we should switch back to pdata value
 285                  * for Voltage control when we go down
 286                  */
 287                 if (cs35l35->pdm_mode)
 288                         regmap_update_bits(cs35l35->regmap,
 289                                         CS35L35_BST_CVTR_V_CTL,
 290                                         CS35L35_BST_CTL_MASK,
 291                                         cs35l35->pdata.bst_vctl
 292                                         << CS35L35_BST_CTL_SHIFT);
 293
 294                 break;
 295         default:
 296                 dev_err(codec->dev, "Invalid event = 0x%x\n", event);
 297         }
 298         return 0;
 299 }
 300
 301 static DECLARE_TLV_DB_SCALE(amp_gain_tlv, 0, 1, 1);
 302 static DECLARE_TLV_DB_SCALE(dig_vol_tlv, -10200, 50, 0);
 303
 304 static const struct snd_kcontrol_new cs35l35_aud_controls[] = {
 305         SOC_SINGLE_SX_TLV("Digital Audio Volume", CS35L35_AMP_DIG_VOL,
 306                       0, 0x34, 0xE4, dig_vol_tlv),
 307         SOC_SINGLE_TLV("Analog Audio Volume", CS35L35_AMP_GAIN_AUD_CTL, 0, 19, 0,
 308                         amp_gain_tlv),
 309         SOC_SINGLE_TLV("PDM Volume", CS35L35_AMP_GAIN_PDM_CTL, 0, 19, 0,
 310                         amp_gain_tlv),
 311 };
 312
 313 static const struct snd_kcontrol_new cs35l35_adv_controls[] = {
 314         SOC_SINGLE_SX_TLV("Digital Advisory Volume", CS35L35_ADV_DIG_VOL,
 315                       0, 0x34, 0xE4, dig_vol_tlv),
 316         SOC_SINGLE_TLV("Analog Advisory Volume", CS35L35_AMP_GAIN_ADV_CTL, 0, 19, 0,
 317                         amp_gain_tlv),
 318 };
 319
 320 static const struct snd_soc_dapm_widget cs35l35_dapm_widgets[] = {
 321         SND_SOC_DAPM_AIF_IN_E("SDIN", NULL, 0, CS35L35_PWRCTL3, 1, 1,
 322                                 cs35l35_sdin_event, SND_SOC_DAPM_PRE_PMU |
 323                                 SND_SOC_DAPM_POST_PMD),
 324         SND_SOC_DAPM_AIF_OUT("SDOUT", NULL, 0, CS35L35_PWRCTL3, 2, 1),
 325
 326         SND_SOC_DAPM_OUTPUT("SPK"),
 327
 328         SND_SOC_DAPM_INPUT("VP"),
 329         SND_SOC_DAPM_INPUT("VBST"),
 330         SND_SOC_DAPM_INPUT("ISENSE"),
 331         SND_SOC_DAPM_INPUT("VSENSE"),
 332
 333         SND_SOC_DAPM_ADC("VMON ADC", NULL, CS35L35_PWRCTL2, 7, 1),
 334         SND_SOC_DAPM_ADC("IMON ADC", NULL, CS35L35_PWRCTL2, 6, 1),
 335         SND_SOC_DAPM_ADC("VPMON ADC", NULL, CS35L35_PWRCTL3, 3, 1),
 336         SND_SOC_DAPM_ADC("VBSTMON ADC", NULL, CS35L35_PWRCTL3, 4, 1),
 337         SND_SOC_DAPM_ADC("CLASS H", NULL, CS35L35_PWRCTL2, 5, 1),
 338
 339         SND_SOC_DAPM_OUT_DRV_E("Main AMP", CS35L35_PWRCTL2, 0, 1, NULL, 0,
 340                 cs35l35_main_amp_event, SND_SOC_DAPM_PRE_PMU |
 341                                 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU |
 342                                 SND_SOC_DAPM_PRE_PMD),
 343 };
 344
 345 static const struct snd_soc_dapm_route cs35l35_audio_map[] = {
 346         {"VPMON ADC", NULL, "VP"},
 347         {"VBSTMON ADC", NULL, "VBST"},
 348         {"IMON ADC", NULL, "ISENSE"},
 349         {"VMON ADC", NULL, "VSENSE"},
 350         {"SDOUT", NULL, "IMON ADC"},
 351         {"SDOUT", NULL, "VMON ADC"},
 352         {"SDOUT", NULL, "VBSTMON ADC"},
 353         {"SDOUT", NULL, "VPMON ADC"},
 354         {"AMP Capture", NULL, "SDOUT"},
 355
 356         {"SDIN", NULL, "AMP Playback"},
 357         {"CLASS H", NULL, "SDIN"},
 358         {"Main AMP", NULL, "CLASS H"},
 359         {"SPK", NULL, "Main AMP"},
 360 };
 361
 362 static int cs35l35_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
 363 {
 364         struct snd_soc_codec *codec = codec_dai->codec;
 365         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 366
 367         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 368         case SND_SOC_DAIFMT_CBM_CFM:
 369                 regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 370                                     CS35L35_MS_MASK, 1 << CS35L35_MS_SHIFT);
 371                 cs35l35->slave_mode = false;
 372                 break;
 373         case SND_SOC_DAIFMT_CBS_CFS:
 374                 regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 375                                     CS35L35_MS_MASK, 0 << CS35L35_MS_SHIFT);
 376                 cs35l35->slave_mode = true;
 377                 break;
 378         default:
 379                 return -EINVAL;
 380         }
 381
 382         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 383         case SND_SOC_DAIFMT_I2S:
 384                 cs35l35->i2s_mode = true;
 385                 cs35l35->pdm_mode = false;
 386                 break;
 387         case SND_SOC_DAIFMT_PDM:
 388                 cs35l35->pdm_mode = true;
 389                 cs35l35->i2s_mode = false;
 390                 break;
 391         default:
 392                 return -EINVAL;
 393         }
 394
 395         return 0;
 396 }
 397
 398 struct cs35l35_sysclk_config {
 399         int sysclk;
 400         int srate;
 401         u8 clk_cfg;
 402 };
 403
 404 static struct cs35l35_sysclk_config cs35l35_clk_ctl[] = {
 405
 406         /* SYSCLK, Sample Rate, Serial Port Cfg */
 407         {5644800, 44100, 0x00},
 408         {5644800, 88200, 0x40},
 409         {6144000, 48000, 0x10},
 410         {6144000, 96000, 0x50},
 411         {11289600, 44100, 0x01},
 412         {11289600, 88200, 0x41},
 413         {11289600, 176400, 0x81},
 414         {12000000, 44100, 0x03},
 415         {12000000, 48000, 0x13},
 416         {12000000, 88200, 0x43},
 417         {12000000, 96000, 0x53},
 418         {12000000, 176400, 0x83},
 419         {12000000, 192000, 0x93},
 420         {12288000, 48000, 0x11},
 421         {12288000, 96000, 0x51},
 422         {12288000, 192000, 0x91},
 423         {13000000, 44100, 0x07},
 424         {13000000, 48000, 0x17},
 425         {13000000, 88200, 0x47},
 426         {13000000, 96000, 0x57},
 427         {13000000, 176400, 0x87},
 428         {13000000, 192000, 0x97},
 429         {22579200, 44100, 0x02},
 430         {22579200, 88200, 0x42},
 431         {22579200, 176400, 0x82},
 432         {24000000, 44100, 0x0B},
 433         {24000000, 48000, 0x1B},
 434         {24000000, 88200, 0x4B},
 435         {24000000, 96000, 0x5B},
 436         {24000000, 176400, 0x8B},
 437         {24000000, 192000, 0x9B},
 438         {24576000, 48000, 0x12},
 439         {24576000, 96000, 0x52},
 440         {24576000, 192000, 0x92},
 441         {26000000, 44100, 0x0F},
 442         {26000000, 48000, 0x1F},
 443         {26000000, 88200, 0x4F},
 444         {26000000, 96000, 0x5F},
 445         {26000000, 176400, 0x8F},
 446         {26000000, 192000, 0x9F},
 447 };
 448
 449 static int cs35l35_get_clk_config(int sysclk, int srate)
 450 {
 451         int i;
 452
 453         for (i = 0; i < ARRAY_SIZE(cs35l35_clk_ctl); i++) {
 454                 if (cs35l35_clk_ctl[i].sysclk == sysclk &&
 455                         cs35l35_clk_ctl[i].srate == srate)
 456                         return cs35l35_clk_ctl[i].clk_cfg;
 457         }
 458         return -EINVAL;
 459 }
 460
 461 static int cs35l35_hw_params(struct snd_pcm_substream *substream,
 462                                  struct snd_pcm_hw_params *params,
 463                                  struct snd_soc_dai *dai)
 464 {
 465         struct snd_soc_codec *codec = dai->codec;
 466         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 467         struct classh_cfg *classh = &cs35l35->pdata.classh_algo;
 468         int srate = params_rate(params);
 469         int ret = 0;
 470         u8 sp_sclks;
 471         int audin_format;
 472         int errata_chk;
 473
 474         int clk_ctl = cs35l35_get_clk_config(cs35l35->sysclk, srate);
 475
 476         if (clk_ctl < 0) {
 477                 dev_err(codec->dev, "Invalid CLK:Rate %d:%d\n",
 478                         cs35l35->sysclk, srate);
 479                 return -EINVAL;
 480         }
 481
 482         ret = regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL2,
 483                           CS35L35_CLK_CTL2_MASK, clk_ctl);
 484         if (ret != 0) {
 485                 dev_err(codec->dev, "Failed to set port config %d\n", ret);
 486                 return ret;
 487         }
 488
 489         /*
 490          * Rev A0 Errata
 491          * When configured for the weak-drive detection path (CH_WKFET_DIS = 0)
 492          * the Class H algorithm does not enable weak-drive operation for
 493          * nonzero values of CH_WKFET_DELAY if SP_RATE = 01 or 10
 494          */
 495         errata_chk = clk_ctl & CS35L35_SP_RATE_MASK;
 496
 497         if (classh->classh_wk_fet_disable == 0x00 &&
 498                 (errata_chk == 0x01 || errata_chk == 0x03)) {
 499                 ret = regmap_update_bits(cs35l35->regmap,
 500                                         CS35L35_CLASS_H_FET_DRIVE_CTL,
 501                                         CS35L35_CH_WKFET_DEL_MASK,
 502                                         0 << CS35L35_CH_WKFET_DEL_SHIFT);
 503                 if (ret != 0) {
 504                         dev_err(codec->dev, "Failed to set fet config %d\n",
 505                                 ret);
 506                         return ret;
 507                 }
 508         }
 509
 510         /*
 511          * You can pull more Monitor data from the SDOUT pin than going to SDIN
 512          * Just make sure your SCLK is fast enough to fill the frame
 513          */
 514         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 515                 switch (params_width(params)) {
 516                 case 8:
 517                         audin_format = CS35L35_SDIN_DEPTH_8;
 518                         break;
 519                 case 16:
 520                         audin_format = CS35L35_SDIN_DEPTH_16;
 521                         break;
 522                 case 24:
 523                         audin_format = CS35L35_SDIN_DEPTH_24;
 524                         break;
 525                 default:
 526                         dev_err(codec->dev, "Unsupported Width %d\n",
 527                                 params_width(params));
 528                         return -EINVAL;
 529                 }
 530                 regmap_update_bits(cs35l35->regmap,
 531                                 CS35L35_AUDIN_DEPTH_CTL,
 532                                 CS35L35_AUDIN_DEPTH_MASK,
 533                                 audin_format <<
 534                                 CS35L35_AUDIN_DEPTH_SHIFT);
 535                 if (cs35l35->pdata.stereo) {
 536                         regmap_update_bits(cs35l35->regmap,
 537                                         CS35L35_AUDIN_DEPTH_CTL,
 538                                         CS35L35_ADVIN_DEPTH_MASK,
 539                                         audin_format <<
 540                                         CS35L35_ADVIN_DEPTH_SHIFT);
 541                 }
 542         }
 543
 544         if (cs35l35->i2s_mode) {
 545                 /* We have to take the SCLK to derive num sclks
 546                  * to configure the CLOCK_CTL3 register correctly
 547                  */
 548                 if ((cs35l35->sclk / srate) % 4) {
 549                         dev_err(codec->dev, "Unsupported sclk/fs ratio %d:%d\n",
 550                                         cs35l35->sclk, srate);
 551                         return -EINVAL;
 552                 }
 553                 sp_sclks = ((cs35l35->sclk / srate) / 4) - 1;
 554
 555                 /* Only certain ratios are supported in I2S Slave Mode */
 556                 if (cs35l35->slave_mode) {
 557                         switch (sp_sclks) {
 558                         case CS35L35_SP_SCLKS_32FS:
 559                         case CS35L35_SP_SCLKS_48FS:
 560                         case CS35L35_SP_SCLKS_64FS:
 561                                 break;
 562                         default:
 563                                 dev_err(codec->dev, "ratio not supported\n");
 564                                 return -EINVAL;
 565                         }
 566                 } else {
 567                         /* Only certain ratios supported in I2S MASTER Mode */
 568                         switch (sp_sclks) {
 569                         case CS35L35_SP_SCLKS_32FS:
 570                         case CS35L35_SP_SCLKS_64FS:
 571                                 break;
 572                         default:
 573                                 dev_err(codec->dev, "ratio not supported\n");
 574                                 return -EINVAL;
 575                         }
 576                 }
 577                 ret = regmap_update_bits(cs35l35->regmap,
 578                                         CS35L35_CLK_CTL3,
 579                                         CS35L35_SP_SCLKS_MASK, sp_sclks <<
 580                                         CS35L35_SP_SCLKS_SHIFT);
 581                 if (ret != 0) {
 582                         dev_err(codec->dev, "Failed to set fsclk %d\n", ret);
 583                         return ret;
 584                 }
 585         }
 586
 587         return ret;
 588 }
 589
 590 static const unsigned int cs35l35_src_rates[] = {
 591         44100, 48000, 88200, 96000, 176400, 192000
 592 };
 593
 594 static const struct snd_pcm_hw_constraint_list cs35l35_constraints = {
 595         .count  = ARRAY_SIZE(cs35l35_src_rates),
 596         .list   = cs35l35_src_rates,
 597 };
 598
 599 static int cs35l35_pcm_startup(struct snd_pcm_substream *substream,
 600                                struct snd_soc_dai *dai)
 601 {
 602         struct snd_soc_codec *codec = dai->codec;
 603         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 604
 605         if (!substream->runtime)
 606                 return 0;
 607
 608         snd_pcm_hw_constraint_list(substream->runtime, 0,
 609                                 SNDRV_PCM_HW_PARAM_RATE, &cs35l35_constraints);
 610
 611         regmap_update_bits(cs35l35->regmap, CS35L35_AMP_INP_DRV_CTL,
 612                                         CS35L35_PDM_MODE_MASK,
 613                                         0 << CS35L35_PDM_MODE_SHIFT);
 614
 615         return 0;
 616 }
 617
 618 static const unsigned int cs35l35_pdm_rates[] = {
 619         44100, 48000, 88200, 96000
 620 };
 621
 622 static const struct snd_pcm_hw_constraint_list cs35l35_pdm_constraints = {
 623         .count  = ARRAY_SIZE(cs35l35_pdm_rates),
 624         .list   = cs35l35_pdm_rates,
 625 };
 626
 627 static int cs35l35_pdm_startup(struct snd_pcm_substream *substream,
 628                                struct snd_soc_dai *dai)
 629 {
 630         struct snd_soc_codec *codec = dai->codec;
 631         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 632
 633         if (!substream->runtime)
 634                 return 0;
 635
 636         snd_pcm_hw_constraint_list(substream->runtime, 0,
 637                                 SNDRV_PCM_HW_PARAM_RATE,
 638                                 &cs35l35_pdm_constraints);
 639
 640         regmap_update_bits(cs35l35->regmap, CS35L35_AMP_INP_DRV_CTL,
 641                                         CS35L35_PDM_MODE_MASK,
 642                                         1 << CS35L35_PDM_MODE_SHIFT);
 643
 644         return 0;
 645 }
 646
 647 static int cs35l35_dai_set_sysclk(struct snd_soc_dai *dai,
 648                                 int clk_id, unsigned int freq, int dir)
 649 {
 650         struct snd_soc_codec *codec = dai->codec;
 651         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 652
 653         /* Need the SCLK Frequency regardless of sysclk source for I2S */
 654         cs35l35->sclk = freq;
 655
 656         return 0;
 657 }
 658
 659 static const struct snd_soc_dai_ops cs35l35_ops = {
 660         .startup = cs35l35_pcm_startup,
 661         .set_fmt = cs35l35_set_dai_fmt,
 662         .hw_params = cs35l35_hw_params,
 663         .set_sysclk = cs35l35_dai_set_sysclk,
 664 };
 665
 666 static const struct snd_soc_dai_ops cs35l35_pdm_ops = {
 667         .startup = cs35l35_pdm_startup,
 668         .set_fmt = cs35l35_set_dai_fmt,
 669         .hw_params = cs35l35_hw_params,
 670 };
 671
 672 static struct snd_soc_dai_driver cs35l35_dai[] = {
 673         {
 674                 .name = "cs35l35-pcm",
 675                 .id = 0,
 676                 .playback = {
 677                         .stream_name = "AMP Playback",
 678                         .channels_min = 1,
 679                         .channels_max = 8,
 680                         .rates = SNDRV_PCM_RATE_KNOT,
 681                         .formats = CS35L35_FORMATS,
 682                 },
 683                 .capture = {
 684                         .stream_name = "AMP Capture",
 685                         .channels_min = 1,
 686                         .channels_max = 8,
 687                         .rates = SNDRV_PCM_RATE_KNOT,
 688                         .formats = CS35L35_FORMATS,
 689                 },
 690                 .ops = &cs35l35_ops,
 691                 .symmetric_rates = 1,
 692         },
 693         {
 694                 .name = "cs35l35-pdm",
 695                 .id = 1,
 696                 .playback = {
 697                         .stream_name = "PDM Playback",
 698                         .channels_min = 1,
 699                         .channels_max = 2,
 700                         .rates = SNDRV_PCM_RATE_KNOT,
 701                         .formats = CS35L35_FORMATS,
 702                 },
 703                 .ops = &cs35l35_pdm_ops,
 704         },
 705 };
 706
 707 static int cs35l35_codec_set_sysclk(struct snd_soc_codec *codec,
 708                                 int clk_id, int source, unsigned int freq,
 709                                 int dir)
 710 {
 711         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 712         int clksrc;
 713         int ret = 0;
 714
 715         switch (clk_id) {
 716         case 0:
 717                 clksrc = CS35L35_CLK_SOURCE_MCLK;
 718                 break;
 719         case 1:
 720                 clksrc = CS35L35_CLK_SOURCE_SCLK;
 721                 break;
 722         case 2:
 723                 clksrc = CS35L35_CLK_SOURCE_PDM;
 724                 break;
 725         default:
 726                 dev_err(codec->dev, "Invalid CLK Source\n");
 727                 return -EINVAL;
 728         }
 729
 730         switch (freq) {
 731         case 5644800:
 732         case 6144000:
 733         case 11289600:
 734         case 12000000:
 735         case 12288000:
 736         case 13000000:
 737         case 22579200:
 738         case 24000000:
 739         case 24576000:
 740         case 26000000:
 741                 cs35l35->sysclk = freq;
 742                 break;
 743         default:
 744                 dev_err(codec->dev, "Invalid CLK Frequency Input : %d\n", freq);
 745                 return -EINVAL;
 746         }
 747
 748         ret = regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 749                                 CS35L35_CLK_SOURCE_MASK,
 750                                 clksrc << CS35L35_CLK_SOURCE_SHIFT);
 751         if (ret != 0) {
 752                 dev_err(codec->dev, "Failed to set sysclk %d\n", ret);
 753                 return ret;
 754         }
 755
 756         return ret;
 757 }
 758
 759 static int cs35l35_boost_inductor(struct cs35l35_private *cs35l35,
 760                                   int inductor)
 761 {
 762         struct regmap *regmap = cs35l35->regmap;
 763         unsigned int bst_ipk = 0;
 764
 765         /*
 766          * Digital Boost Converter Configuration for feedback,
 767          * ramping, switching frequency, and estimation block seeding.
 768          */
 769
 770         regmap_update_bits(regmap, CS35L35_BST_CONV_SW_FREQ,
 771                            CS35L35_BST_CONV_SWFREQ_MASK, 0x00);
 772
 773         regmap_read(regmap, CS35L35_BST_PEAK_I, &bst_ipk);
 774         bst_ipk &= CS35L35_BST_IPK_MASK;
 775
 776         switch (inductor) {
 777         case 1000: /* 1 uH */
 778                 regmap_write(regmap, CS35L35_BST_CONV_COEF_1, 0x24);
 779                 regmap_write(regmap, CS35L35_BST_CONV_COEF_2, 0x24);
 780                 regmap_update_bits(regmap, CS35L35_BST_CONV_SW_FREQ,
 781                                    CS35L35_BST_CONV_LBST_MASK, 0x00);
 782
 783                 if (bst_ipk < 0x04)
 784                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x1B);
 785                 else
 786                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x4E);
 787                 break;
 788         case 1200: /* 1.2 uH */
 789                 regmap_write(regmap, CS35L35_BST_CONV_COEF_1, 0x20);
 790                 regmap_write(regmap, CS35L35_BST_CONV_COEF_2, 0x20);
 791                 regmap_update_bits(regmap, CS35L35_BST_CONV_SW_FREQ,
 792                                    CS35L35_BST_CONV_LBST_MASK, 0x01);
 793
 794                 if (bst_ipk < 0x04)
 795                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x1B);
 796                 else
 797                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x47);
 798                 break;
 799         case 1500: /* 1.5uH */
 800                 regmap_write(regmap, CS35L35_BST_CONV_COEF_1, 0x20);
 801                 regmap_write(regmap, CS35L35_BST_CONV_COEF_2, 0x20);
 802                 regmap_update_bits(regmap, CS35L35_BST_CONV_SW_FREQ,
 803                                    CS35L35_BST_CONV_LBST_MASK, 0x02);
 804
 805                 if (bst_ipk < 0x04)
 806                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x1B);
 807                 else
 808                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x3C);
 809                 break;
 810         case 2200: /* 2.2uH */
 811                 regmap_write(regmap, CS35L35_BST_CONV_COEF_1, 0x19);
 812                 regmap_write(regmap, CS35L35_BST_CONV_COEF_2, 0x25);
 813                 regmap_update_bits(regmap, CS35L35_BST_CONV_SW_FREQ,
 814                                    CS35L35_BST_CONV_LBST_MASK, 0x03);
 815
 816                 if (bst_ipk < 0x04)
 817                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x1B);
 818                 else
 819                         regmap_write(regmap, CS35L35_BST_CONV_SLOPE_COMP, 0x23);
 820                 break;
 821         default:
 822                 dev_err(cs35l35->dev, "Invalid Inductor Value %d uH\n",
 823                         inductor);
 824                 return -EINVAL;
 825         }
 826         return 0;
 827 }
 828
 829 static int cs35l35_codec_probe(struct snd_soc_codec *codec)
 830 {
 831         struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
 832         struct classh_cfg *classh = &cs35l35->pdata.classh_algo;
 833         struct monitor_cfg *monitor_config = &cs35l35->pdata.mon_cfg;
 834         int ret;
 835
 836         /* Set Platform Data */
 837         if (cs35l35->pdata.bst_vctl)
 838                 regmap_update_bits(cs35l35->regmap, CS35L35_BST_CVTR_V_CTL,
 839                                 CS35L35_BST_CTL_MASK,
 840                                 cs35l35->pdata.bst_vctl);
 841
 842         if (cs35l35->pdata.bst_ipk)
 843                 regmap_update_bits(cs35l35->regmap, CS35L35_BST_PEAK_I,
 844                                 CS35L35_BST_IPK_MASK,
 845                                 cs35l35->pdata.bst_ipk <<
 846                                 CS35L35_BST_IPK_SHIFT);
 847
 848         ret = cs35l35_boost_inductor(cs35l35, cs35l35->pdata.boost_ind);
 849         if (ret)
 850                 return ret;
 851
 852         if (cs35l35->pdata.gain_zc)
 853                 regmap_update_bits(cs35l35->regmap, CS35L35_PROTECT_CTL,
 854                                 CS35L35_AMP_GAIN_ZC_MASK,
 855                                 cs35l35->pdata.gain_zc <<
 856                                 CS35L35_AMP_GAIN_ZC_SHIFT);
 857
 858         if (cs35l35->pdata.aud_channel)
 859                 regmap_update_bits(cs35l35->regmap,
 860                                 CS35L35_AUDIN_RXLOC_CTL,
 861                                 CS35L35_AUD_IN_LR_MASK,
 862                                 cs35l35->pdata.aud_channel <<
 863                                 CS35L35_AUD_IN_LR_SHIFT);
 864
 865         if (cs35l35->pdata.stereo) {
 866                 regmap_update_bits(cs35l35->regmap,
 867                                 CS35L35_ADVIN_RXLOC_CTL,
 868                                 CS35L35_ADV_IN_LR_MASK,
 869                                 cs35l35->pdata.adv_channel <<
 870                                 CS35L35_ADV_IN_LR_SHIFT);
 871                 if (cs35l35->pdata.shared_bst)
 872                         regmap_update_bits(cs35l35->regmap, CS35L35_CLASS_H_CTL,
 873                                         CS35L35_CH_STEREO_MASK,
 874                                         1 << CS35L35_CH_STEREO_SHIFT);
 875                 ret = snd_soc_add_codec_controls(codec, cs35l35_adv_controls,
 876                                         ARRAY_SIZE(cs35l35_adv_controls));
 877                 if (ret)
 878                         return ret;
 879         }
 880
 881         if (cs35l35->pdata.sp_drv_str)
 882                 regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL1,
 883                                 CS35L35_SP_DRV_MASK,
 884                                 cs35l35->pdata.sp_drv_str <<
 885                                 CS35L35_SP_DRV_SHIFT);
 886         if (cs35l35->pdata.sp_drv_unused)
 887                 regmap_update_bits(cs35l35->regmap, CS35L35_SP_FMT_CTL3,
 888                                    CS35L35_SP_I2S_DRV_MASK,
 889                                    cs35l35->pdata.sp_drv_unused <<
 890                                    CS35L35_SP_I2S_DRV_SHIFT);
 891
 892         if (classh->classh_algo_enable) {
 893                 if (classh->classh_bst_override)
 894                         regmap_update_bits(cs35l35->regmap,
 895                                         CS35L35_CLASS_H_CTL,
 896                                         CS35L35_CH_BST_OVR_MASK,
 897                                         classh->classh_bst_override <<
 898                                         CS35L35_CH_BST_OVR_SHIFT);
 899                 if (classh->classh_bst_max_limit)
 900                         regmap_update_bits(cs35l35->regmap,
 901                                         CS35L35_CLASS_H_CTL,
 902                                         CS35L35_CH_BST_LIM_MASK,
 903                                         classh->classh_bst_max_limit <<
 904                                         CS35L35_CH_BST_LIM_SHIFT);
 905                 if (classh->classh_mem_depth)
 906                         regmap_update_bits(cs35l35->regmap,
 907                                         CS35L35_CLASS_H_CTL,
 908                                         CS35L35_CH_MEM_DEPTH_MASK,
 909                                         classh->classh_mem_depth <<
 910                                         CS35L35_CH_MEM_DEPTH_SHIFT);
 911                 if (classh->classh_headroom)
 912                         regmap_update_bits(cs35l35->regmap,
 913                                         CS35L35_CLASS_H_HEADRM_CTL,
 914                                         CS35L35_CH_HDRM_CTL_MASK,
 915                                         classh->classh_headroom <<
 916                                         CS35L35_CH_HDRM_CTL_SHIFT);
 917                 if (classh->classh_release_rate)
 918                         regmap_update_bits(cs35l35->regmap,
 919                                         CS35L35_CLASS_H_RELEASE_RATE,
 920                                         CS35L35_CH_REL_RATE_MASK,
 921                                         classh->classh_release_rate <<
 922                                         CS35L35_CH_REL_RATE_SHIFT);
 923                 if (classh->classh_wk_fet_disable)
 924                         regmap_update_bits(cs35l35->regmap,
 925                                         CS35L35_CLASS_H_FET_DRIVE_CTL,
 926                                         CS35L35_CH_WKFET_DIS_MASK,
 927                                         classh->classh_wk_fet_disable <<
 928                                         CS35L35_CH_WKFET_DIS_SHIFT);
 929                 if (classh->classh_wk_fet_delay)
 930                         regmap_update_bits(cs35l35->regmap,
 931                                         CS35L35_CLASS_H_FET_DRIVE_CTL,
 932                                         CS35L35_CH_WKFET_DEL_MASK,
 933                                         classh->classh_wk_fet_delay <<
 934                                         CS35L35_CH_WKFET_DEL_SHIFT);
 935                 if (classh->classh_wk_fet_thld)
 936                         regmap_update_bits(cs35l35->regmap,
 937                                         CS35L35_CLASS_H_FET_DRIVE_CTL,
 938                                         CS35L35_CH_WKFET_THLD_MASK,
 939                                         classh->classh_wk_fet_thld <<
 940                                         CS35L35_CH_WKFET_THLD_SHIFT);
 941                 if (classh->classh_vpch_auto)
 942                         regmap_update_bits(cs35l35->regmap,
 943                                         CS35L35_CLASS_H_VP_CTL,
 944                                         CS35L35_CH_VP_AUTO_MASK,
 945                                         classh->classh_vpch_auto <<
 946                                         CS35L35_CH_VP_AUTO_SHIFT);
 947                 if (classh->classh_vpch_rate)
 948                         regmap_update_bits(cs35l35->regmap,
 949                                         CS35L35_CLASS_H_VP_CTL,
 950                                         CS35L35_CH_VP_RATE_MASK,
 951                                         classh->classh_vpch_rate <<
 952                                         CS35L35_CH_VP_RATE_SHIFT);
 953                 if (classh->classh_vpch_man)
 954                         regmap_update_bits(cs35l35->regmap,
 955                                         CS35L35_CLASS_H_VP_CTL,
 956                                         CS35L35_CH_VP_MAN_MASK,
 957                                         classh->classh_vpch_man <<
 958                                         CS35L35_CH_VP_MAN_SHIFT);
 959         }
 960
 961         if (monitor_config->is_present) {
 962                 if (monitor_config->vmon_specs) {
 963                         regmap_update_bits(cs35l35->regmap,
 964                                         CS35L35_SPKMON_DEPTH_CTL,
 965                                         CS35L35_VMON_DEPTH_MASK,
 966                                         monitor_config->vmon_dpth <<
 967                                         CS35L35_VMON_DEPTH_SHIFT);
 968                         regmap_update_bits(cs35l35->regmap,
 969                                         CS35L35_VMON_TXLOC_CTL,
 970                                         CS35L35_MON_TXLOC_MASK,
 971                                         monitor_config->vmon_loc <<
 972                                         CS35L35_MON_TXLOC_SHIFT);
 973                         regmap_update_bits(cs35l35->regmap,
 974                                         CS35L35_VMON_TXLOC_CTL,
 975                                         CS35L35_MON_FRM_MASK,
 976                                         monitor_config->vmon_frm <<
 977                                         CS35L35_MON_FRM_SHIFT);
 978                 }
 979                 if (monitor_config->imon_specs) {
 980                         regmap_update_bits(cs35l35->regmap,
 981                                         CS35L35_SPKMON_DEPTH_CTL,
 982                                         CS35L35_IMON_DEPTH_MASK,
 983                                         monitor_config->imon_dpth <<
 984                                         CS35L35_IMON_DEPTH_SHIFT);
 985                         regmap_update_bits(cs35l35->regmap,
 986                                         CS35L35_IMON_TXLOC_CTL,
 987                                         CS35L35_MON_TXLOC_MASK,
 988                                         monitor_config->imon_loc <<
 989                                         CS35L35_MON_TXLOC_SHIFT);
 990                         regmap_update_bits(cs35l35->regmap,
 991                                         CS35L35_IMON_TXLOC_CTL,
 992                                         CS35L35_MON_FRM_MASK,
 993                                         monitor_config->imon_frm <<
 994                                         CS35L35_MON_FRM_SHIFT);
 995                         regmap_update_bits(cs35l35->regmap,
 996                                         CS35L35_IMON_SCALE_CTL,
 997                                         CS35L35_IMON_SCALE_MASK,
 998                                         monitor_config->imon_scale <<
 999                                         CS35L35_IMON_SCALE_SHIFT);
1000                 }
1001                 if (monitor_config->vpmon_specs) {
1002                         regmap_update_bits(cs35l35->regmap,
1003                                         CS35L35_SUPMON_DEPTH_CTL,
1004                                         CS35L35_VPMON_DEPTH_MASK,
1005                                         monitor_config->vpmon_dpth <<
1006                                         CS35L35_VPMON_DEPTH_SHIFT);
1007                         regmap_update_bits(cs35l35->regmap,
1008                                         CS35L35_VPMON_TXLOC_CTL,
1009                                         CS35L35_MON_TXLOC_MASK,
1010                                         monitor_config->vpmon_loc <<
1011                                         CS35L35_MON_TXLOC_SHIFT);
1012                         regmap_update_bits(cs35l35->regmap,
1013                                         CS35L35_VPMON_TXLOC_CTL,
1014                                         CS35L35_MON_FRM_MASK,
1015                                         monitor_config->vpmon_frm <<
1016                                         CS35L35_MON_FRM_SHIFT);
1017                 }
1018                 if (monitor_config->vbstmon_specs) {
1019                         regmap_update_bits(cs35l35->regmap,
1020                                         CS35L35_SUPMON_DEPTH_CTL,
1021                                         CS35L35_VBSTMON_DEPTH_MASK,
1022                                         monitor_config->vpmon_dpth <<
1023                                         CS35L35_VBSTMON_DEPTH_SHIFT);
1024                         regmap_update_bits(cs35l35->regmap,
1025                                         CS35L35_VBSTMON_TXLOC_CTL,
1026                                         CS35L35_MON_TXLOC_MASK,
1027                                         monitor_config->vbstmon_loc <<
1028                                         CS35L35_MON_TXLOC_SHIFT);
1029                         regmap_update_bits(cs35l35->regmap,
1030                                         CS35L35_VBSTMON_TXLOC_CTL,
1031                                         CS35L35_MON_FRM_MASK,
1032                                         monitor_config->vbstmon_frm <<
1033                                         CS35L35_MON_FRM_SHIFT);
1034                 }
1035                 if (monitor_config->vpbrstat_specs) {
1036                         regmap_update_bits(cs35l35->regmap,
1037                                         CS35L35_SUPMON_DEPTH_CTL,
1038                                         CS35L35_VPBRSTAT_DEPTH_MASK,
1039                                         monitor_config->vpbrstat_dpth <<
1040                                         CS35L35_VPBRSTAT_DEPTH_SHIFT);
1041                         regmap_update_bits(cs35l35->regmap,
1042                                         CS35L35_VPBR_STATUS_TXLOC_CTL,
1043                                         CS35L35_MON_TXLOC_MASK,
1044                                         monitor_config->vpbrstat_loc <<
1045                                         CS35L35_MON_TXLOC_SHIFT);
1046                         regmap_update_bits(cs35l35->regmap,
1047                                         CS35L35_VPBR_STATUS_TXLOC_CTL,
1048                                         CS35L35_MON_FRM_MASK,
1049                                         monitor_config->vpbrstat_frm <<
1050                                         CS35L35_MON_FRM_SHIFT);
1051                 }
1052                 if (monitor_config->zerofill_specs) {
1053                         regmap_update_bits(cs35l35->regmap,
1054                                         CS35L35_SUPMON_DEPTH_CTL,
1055                                         CS35L35_ZEROFILL_DEPTH_MASK,
1056                                         monitor_config->zerofill_dpth <<
1057                                         CS35L35_ZEROFILL_DEPTH_SHIFT);
1058                         regmap_update_bits(cs35l35->regmap,
1059                                         CS35L35_ZERO_FILL_LOC_CTL,
1060                                         CS35L35_MON_TXLOC_MASK,
1061                                         monitor_config->zerofill_loc <<
1062                                         CS35L35_MON_TXLOC_SHIFT);
1063                         regmap_update_bits(cs35l35->regmap,
1064                                         CS35L35_ZERO_FILL_LOC_CTL,
1065                                         CS35L35_MON_FRM_MASK,
1066                                         monitor_config->zerofill_frm <<
1067                                         CS35L35_MON_FRM_SHIFT);
1068                 }
1069         }
1070
1071         return 0;
1072 }
1073
1074 static struct snd_soc_codec_driver soc_codec_dev_cs35l35 = {
1075         .probe = cs35l35_codec_probe,
1076         .set_sysclk = cs35l35_codec_set_sysclk,
1077         .component_driver = {
1078                 .dapm_widgets = cs35l35_dapm_widgets,
1079                 .num_dapm_widgets = ARRAY_SIZE(cs35l35_dapm_widgets),
1080
1081                 .dapm_routes = cs35l35_audio_map,
1082                 .num_dapm_routes = ARRAY_SIZE(cs35l35_audio_map),
1083
1084                 .controls = cs35l35_aud_controls,
1085                 .num_controls = ARRAY_SIZE(cs35l35_aud_controls),
1086         },
1087
1088 };
1089
1090 static struct regmap_config cs35l35_regmap = {
1091         .reg_bits = 8,
1092         .val_bits = 8,
1093
1094         .max_register = CS35L35_MAX_REGISTER,
1095         .reg_defaults = cs35l35_reg,
1096         .num_reg_defaults = ARRAY_SIZE(cs35l35_reg),
1097         .volatile_reg = cs35l35_volatile_register,
1098         .readable_reg = cs35l35_readable_register,
1099         .precious_reg = cs35l35_precious_register,
1100         .cache_type = REGCACHE_RBTREE,
1101 };
1102
1103 static irqreturn_t cs35l35_irq(int irq, void *data)
1104 {
1105         struct cs35l35_private *cs35l35 = data;
1106         unsigned int sticky1, sticky2, sticky3, sticky4;
1107         unsigned int mask1, mask2, mask3, mask4, current1;
1108
1109         /* ack the irq by reading all status registers */
1110         regmap_read(cs35l35->regmap, CS35L35_INT_STATUS_4, &sticky4);
1111         regmap_read(cs35l35->regmap, CS35L35_INT_STATUS_3, &sticky3);
1112         regmap_read(cs35l35->regmap, CS35L35_INT_STATUS_2, &sticky2);
1113         regmap_read(cs35l35->regmap, CS35L35_INT_STATUS_1, &sticky1);
1114
1115         regmap_read(cs35l35->regmap, CS35L35_INT_MASK_4, &mask4);
1116         regmap_read(cs35l35->regmap, CS35L35_INT_MASK_3, &mask3);
1117         regmap_read(cs35l35->regmap, CS35L35_INT_MASK_2, &mask2);
1118         regmap_read(cs35l35->regmap, CS35L35_INT_MASK_1, &mask1);
1119
1120         /* Check to see if unmasked bits are active */
1121         if (!(sticky1 & ~mask1) && !(sticky2 & ~mask2) && !(sticky3 & ~mask3)
1122                         && !(sticky4 & ~mask4))
1123                 return IRQ_NONE;
1124
1125         if (sticky2 & CS35L35_PDN_DONE)
1126                 complete(&cs35l35->pdn_done);
1127
1128         /* read the current values */
1129         regmap_read(cs35l35->regmap, CS35L35_INT_STATUS_1, &current1);
1130
1131         /* handle the interrupts */
1132         if (sticky1 & CS35L35_CAL_ERR) {
1133                 dev_crit(cs35l35->dev, "Calibration Error\n");
1134
1135                 /* error is no longer asserted; safe to reset */
1136                 if (!(current1 & CS35L35_CAL_ERR)) {
1137                         pr_debug("%s : Cal error release\n", __func__);
1138                         regmap_update_bits(cs35l35->regmap,
1139                                         CS35L35_PROT_RELEASE_CTL,
1140                                         CS35L35_CAL_ERR_RLS, 0);
1141                         regmap_update_bits(cs35l35->regmap,
1142                                         CS35L35_PROT_RELEASE_CTL,
1143                                         CS35L35_CAL_ERR_RLS,
1144                                         CS35L35_CAL_ERR_RLS);
1145                         regmap_update_bits(cs35l35->regmap,
1146                                         CS35L35_PROT_RELEASE_CTL,
1147                                         CS35L35_CAL_ERR_RLS, 0);
1148                 }
1149         }
1150
1151         if (sticky1 & CS35L35_AMP_SHORT) {
1152                 dev_crit(cs35l35->dev, "AMP Short Error\n");
1153                 /* error is no longer asserted; safe to reset */
1154                 if (!(current1 & CS35L35_AMP_SHORT)) {
1155                         dev_dbg(cs35l35->dev, "Amp short error release\n");
1156                         regmap_update_bits(cs35l35->regmap,
1157                                         CS35L35_PROT_RELEASE_CTL,
1158                                         CS35L35_SHORT_RLS, 0);
1159                         regmap_update_bits(cs35l35->regmap,
1160                                         CS35L35_PROT_RELEASE_CTL,
1161                                         CS35L35_SHORT_RLS,
1162                                         CS35L35_SHORT_RLS);
1163                         regmap_update_bits(cs35l35->regmap,
1164                                         CS35L35_PROT_RELEASE_CTL,
1165                                         CS35L35_SHORT_RLS, 0);
1166                 }
1167         }
1168
1169         if (sticky1 & CS35L35_OTW) {
1170                 dev_warn(cs35l35->dev, "Over temperature warning\n");
1171
1172                 /* error is no longer asserted; safe to reset */
1173                 if (!(current1 & CS35L35_OTW)) {
1174                         dev_dbg(cs35l35->dev, "Over temperature warn release\n");
1175                         regmap_update_bits(cs35l35->regmap,
1176                                         CS35L35_PROT_RELEASE_CTL,
1177                                         CS35L35_OTW_RLS, 0);
1178                         regmap_update_bits(cs35l35->regmap,
1179                                         CS35L35_PROT_RELEASE_CTL,
1180                                         CS35L35_OTW_RLS,
1181                                         CS35L35_OTW_RLS);
1182                         regmap_update_bits(cs35l35->regmap,
1183                                         CS35L35_PROT_RELEASE_CTL,
1184                                         CS35L35_OTW_RLS, 0);
1185                 }
1186         }
1187
1188         if (sticky1 & CS35L35_OTE) {
1189                 dev_crit(cs35l35->dev, "Over temperature error\n");
1190                 /* error is no longer asserted; safe to reset */
1191                 if (!(current1 & CS35L35_OTE)) {
1192                         dev_dbg(cs35l35->dev, "Over temperature error release\n");
1193                         regmap_update_bits(cs35l35->regmap,
1194                                         CS35L35_PROT_RELEASE_CTL,
1195                                         CS35L35_OTE_RLS, 0);
1196                         regmap_update_bits(cs35l35->regmap,
1197                                         CS35L35_PROT_RELEASE_CTL,
1198                                         CS35L35_OTE_RLS,
1199                                         CS35L35_OTE_RLS);
1200                         regmap_update_bits(cs35l35->regmap,
1201                                         CS35L35_PROT_RELEASE_CTL,
1202                                         CS35L35_OTE_RLS, 0);
1203                 }
1204         }
1205
1206         if (sticky3 & CS35L35_BST_HIGH) {
1207                 dev_crit(cs35l35->dev, "VBST error: powering off!\n");
1208                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
1209                         CS35L35_PDN_AMP, CS35L35_PDN_AMP);
1210                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
1211                         CS35L35_PDN_ALL, CS35L35_PDN_ALL);
1212         }
1213
1214         if (sticky3 & CS35L35_LBST_SHORT) {
1215                 dev_crit(cs35l35->dev, "LBST error: powering off!\n");
1216                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
1217                         CS35L35_PDN_AMP, CS35L35_PDN_AMP);
1218                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL1,
1219                         CS35L35_PDN_ALL, CS35L35_PDN_ALL);
1220         }
1221
1222         if (sticky2 & CS35L35_VPBR_ERR)
1223                 dev_dbg(cs35l35->dev, "Error: Reactive Brownout\n");
1224
1225         if (sticky4 & CS35L35_VMON_OVFL)
1226                 dev_dbg(cs35l35->dev, "Error: VMON overflow\n");
1227
1228         if (sticky4 & CS35L35_IMON_OVFL)
1229                 dev_dbg(cs35l35->dev, "Error: IMON overflow\n");
1230
1231         return IRQ_HANDLED;
1232 }
1233
1234
1235 static int cs35l35_handle_of_data(struct i2c_client *i2c_client,
1236                                 struct cs35l35_platform_data *pdata)
1237 {
1238         struct device_node *np = i2c_client->dev.of_node;
1239         struct device_node *classh, *signal_format;
1240         struct classh_cfg *classh_config = &pdata->classh_algo;
1241         struct monitor_cfg *monitor_config = &pdata->mon_cfg;
1242         unsigned int val32 = 0;
1243         u8 monitor_array[4];
1244         const int imon_array_size = ARRAY_SIZE(monitor_array);
1245         const int mon_array_size = imon_array_size - 1;
1246         int ret = 0;
1247
1248         if (!np)
1249                 return 0;
1250
1251         pdata->bst_pdn_fet_on = of_property_read_bool(np,
1252                                         "cirrus,boost-pdn-fet-on");
1253
1254         ret = of_property_read_u32(np, "cirrus,boost-ctl-millivolt", &val32);
1255         if (ret >= 0) {
1256                 if (val32 < 2600 || val32 > 9000) {
1257                         dev_err(&i2c_client->dev,
1258                                 "Invalid Boost Voltage %d mV\n", val32);
1259                         return -EINVAL;
1260                 }
1261                 pdata->bst_vctl = ((val32 - 2600) / 100) + 1;
1262         }
1263
1264         ret = of_property_read_u32(np, "cirrus,boost-peak-milliamp", &val32);
1265         if (ret >= 0) {
1266                 if (val32 < 1680 || val32 > 4480) {
1267                         dev_err(&i2c_client->dev,
1268                                 "Invalid Boost Peak Current %u mA\n", val32);
1269                         return -EINVAL;
1270                 }
1271
1272                 pdata->bst_ipk = ((val32 - 1680) / 110) | CS35L35_VALID_PDATA;
1273         }
1274
1275         ret = of_property_read_u32(np, "cirrus,boost-ind-nanohenry", &val32);
1276         if (ret >= 0) {
1277                 pdata->boost_ind = val32;
1278         } else {
1279                 dev_err(&i2c_client->dev, "Inductor not specified.\n");
1280                 return -EINVAL;
1281         }
1282
1283         if (of_property_read_u32(np, "cirrus,sp-drv-strength", &val32) >= 0)
1284                 pdata->sp_drv_str = val32;
1285         if (of_property_read_u32(np, "cirrus,sp-drv-unused", &val32) >= 0)
1286                 pdata->sp_drv_unused = val32 | CS35L35_VALID_PDATA;
1287
1288         pdata->stereo = of_property_read_bool(np, "cirrus,stereo-config");
1289
1290         if (pdata->stereo) {
1291                 ret = of_property_read_u32(np, "cirrus,audio-channel", &val32);
1292                 if (ret >= 0)
1293                         pdata->aud_channel = val32;
1294
1295                 ret = of_property_read_u32(np, "cirrus,advisory-channel",
1296                                            &val32);
1297                 if (ret >= 0)
1298                         pdata->adv_channel = val32;
1299
1300                 pdata->shared_bst = of_property_read_bool(np,
1301                                                 "cirrus,shared-boost");
1302         }
1303
1304         pdata->ext_bst = of_property_read_bool(np, "cirrus,external-boost");
1305
1306         pdata->gain_zc = of_property_read_bool(np, "cirrus,amp-gain-zc");
1307
1308         classh = of_get_child_by_name(np, "cirrus,classh-internal-algo");
1309         classh_config->classh_algo_enable = classh ? true : false;
1310
1311         if (classh_config->classh_algo_enable) {
1312                 classh_config->classh_bst_override =
1313                         of_property_read_bool(np, "cirrus,classh-bst-overide");
1314
1315                 ret = of_property_read_u32(classh,
1316                                            "cirrus,classh-bst-max-limit",
1317                                            &val32);
1318                 if (ret >= 0) {
1319                         val32 |= CS35L35_VALID_PDATA;
1320                         classh_config->classh_bst_max_limit = val32;
1321                 }
1322
1323                 ret = of_property_read_u32(classh,
1324                                            "cirrus,classh-bst-max-limit",
1325                                            &val32);
1326                 if (ret >= 0) {
1327                         val32 |= CS35L35_VALID_PDATA;
1328                         classh_config->classh_bst_max_limit = val32;
1329                 }
1330
1331                 ret = of_property_read_u32(classh, "cirrus,classh-mem-depth",
1332                                            &val32);
1333                 if (ret >= 0) {
1334                         val32 |= CS35L35_VALID_PDATA;
1335                         classh_config->classh_mem_depth = val32;
1336                 }
1337
1338                 ret = of_property_read_u32(classh, "cirrus,classh-release-rate",
1339                                            &val32);
1340                 if (ret >= 0)
1341                         classh_config->classh_release_rate = val32;
1342
1343                 ret = of_property_read_u32(classh, "cirrus,classh-headroom",
1344                                            &val32);
1345                 if (ret >= 0) {
1346                         val32 |= CS35L35_VALID_PDATA;
1347                         classh_config->classh_headroom = val32;
1348                 }
1349
1350                 ret = of_property_read_u32(classh,
1351                                            "cirrus,classh-wk-fet-disable",
1352                                            &val32);
1353                 if (ret >= 0)
1354                         classh_config->classh_wk_fet_disable = val32;
1355
1356                 ret = of_property_read_u32(classh, "cirrus,classh-wk-fet-delay",
1357                                            &val32);
1358                 if (ret >= 0) {
1359                         val32 |= CS35L35_VALID_PDATA;
1360                         classh_config->classh_wk_fet_delay = val32;
1361                 }
1362
1363                 ret = of_property_read_u32(classh, "cirrus,classh-wk-fet-thld",
1364                                            &val32);
1365                 if (ret >= 0)
1366                         classh_config->classh_wk_fet_thld = val32;
1367
1368                 ret = of_property_read_u32(classh, "cirrus,classh-vpch-auto",
1369                                            &val32);
1370                 if (ret >= 0) {
1371                         val32 |= CS35L35_VALID_PDATA;
1372                         classh_config->classh_vpch_auto = val32;
1373                 }
1374
1375                 ret = of_property_read_u32(classh, "cirrus,classh-vpch-rate",
1376                                            &val32);
1377                 if (ret >= 0) {
1378                         val32 |= CS35L35_VALID_PDATA;
1379                         classh_config->classh_vpch_rate = val32;
1380                 }
1381
1382                 ret = of_property_read_u32(classh, "cirrus,classh-vpch-man",
1383                                            &val32);
1384                 if (ret >= 0)
1385                         classh_config->classh_vpch_man = val32;
1386         }
1387         of_node_put(classh);
1388
1389         /* frame depth location */
1390         signal_format = of_get_child_by_name(np, "cirrus,monitor-signal-format");
1391         monitor_config->is_present = signal_format ? true : false;
1392         if (monitor_config->is_present) {
1393                 ret = of_property_read_u8_array(signal_format, "cirrus,imon",
1394                                                 monitor_array, imon_array_size);
1395                 if (!ret) {
1396                         monitor_config->imon_specs = true;
1397                         monitor_config->imon_dpth = monitor_array[0];
1398                         monitor_config->imon_loc = monitor_array[1];
1399                         monitor_config->imon_frm = monitor_array[2];
1400                         monitor_config->imon_scale = monitor_array[3];
1401                 }
1402                 ret = of_property_read_u8_array(signal_format, "cirrus,vmon",
1403                                                 monitor_array, mon_array_size);
1404                 if (!ret) {
1405                         monitor_config->vmon_specs = true;
1406                         monitor_config->vmon_dpth = monitor_array[0];
1407                         monitor_config->vmon_loc = monitor_array[1];
1408                         monitor_config->vmon_frm = monitor_array[2];
1409                 }
1410                 ret = of_property_read_u8_array(signal_format, "cirrus,vpmon",
1411                                                 monitor_array, mon_array_size);
1412                 if (!ret) {
1413                         monitor_config->vpmon_specs = true;
1414                         monitor_config->vpmon_dpth = monitor_array[0];
1415                         monitor_config->vpmon_loc = monitor_array[1];
1416                         monitor_config->vpmon_frm = monitor_array[2];
1417                 }
1418                 ret = of_property_read_u8_array(signal_format, "cirrus,vbstmon",
1419                                                 monitor_array, mon_array_size);
1420                 if (!ret) {
1421                         monitor_config->vbstmon_specs = true;
1422                         monitor_config->vbstmon_dpth = monitor_array[0];
1423                         monitor_config->vbstmon_loc = monitor_array[1];
1424                         monitor_config->vbstmon_frm = monitor_array[2];
1425                 }
1426                 ret = of_property_read_u8_array(signal_format, "cirrus,vpbrstat",
1427                                                 monitor_array, mon_array_size);
1428                 if (!ret) {
1429                         monitor_config->vpbrstat_specs = true;
1430                         monitor_config->vpbrstat_dpth = monitor_array[0];
1431                         monitor_config->vpbrstat_loc = monitor_array[1];
1432                         monitor_config->vpbrstat_frm = monitor_array[2];
1433                 }
1434                 ret = of_property_read_u8_array(signal_format, "cirrus,zerofill",
1435                                                 monitor_array, mon_array_size);
1436                 if (!ret) {
1437                         monitor_config->zerofill_specs = true;
1438                         monitor_config->zerofill_dpth = monitor_array[0];
1439                         monitor_config->zerofill_loc = monitor_array[1];
1440                         monitor_config->zerofill_frm = monitor_array[2];
1441                 }
1442         }
1443         of_node_put(signal_format);
1444
1445         return 0;
1446 }
1447
1448 /* Errata Rev A0 */
1449 static const struct reg_sequence cs35l35_errata_patch[] = {
1450
1451         { 0x7F, 0x99 },
1452         { 0x00, 0x99 },
1453         { 0x52, 0x22 },
1454         { 0x04, 0x14 },
1455         { 0x6D, 0x44 },
1456         { 0x24, 0x10 },
1457         { 0x58, 0xC4 },
1458         { 0x00, 0x98 },
1459         { 0x18, 0x08 },
1460         { 0x00, 0x00 },
1461         { 0x7F, 0x00 },
1462 };
1463
1464 static int cs35l35_i2c_probe(struct i2c_client *i2c_client,
1465                               const struct i2c_device_id *id)
1466 {
1467         struct cs35l35_private *cs35l35;
1468         struct device *dev = &i2c_client->dev;
1469         struct cs35l35_platform_data *pdata = dev_get_platdata(dev);
1470         int i;
1471         int ret;
1472         unsigned int devid = 0;
1473         unsigned int reg;
1474
1475         cs35l35 = devm_kzalloc(dev, sizeof(struct cs35l35_private), GFP_KERNEL);
1476         if (!cs35l35)
1477                 return -ENOMEM;
1478
1479         cs35l35->dev = dev;
1480
1481         i2c_set_clientdata(i2c_client, cs35l35);
1482         cs35l35->regmap = devm_regmap_init_i2c(i2c_client, &cs35l35_regmap);
1483         if (IS_ERR(cs35l35->regmap)) {
1484                 ret = PTR_ERR(cs35l35->regmap);
1485                 dev_err(dev, "regmap_init() failed: %d\n", ret);
1486                 goto err;
1487         }
1488
1489         for (i = 0; i < ARRAY_SIZE(cs35l35_supplies); i++)
1490                 cs35l35->supplies[i].supply = cs35l35_supplies[i];
1491
1492         cs35l35->num_supplies = ARRAY_SIZE(cs35l35_supplies);
1493
1494         ret = devm_regulator_bulk_get(dev, cs35l35->num_supplies,
1495                                       cs35l35->supplies);
1496         if (ret != 0) {
1497                 dev_err(dev, "Failed to request core supplies: %d\n", ret);
1498                 return ret;
1499         }
1500
1501         if (pdata) {
1502                 cs35l35->pdata = *pdata;
1503         } else {
1504                 pdata = devm_kzalloc(dev, sizeof(struct cs35l35_platform_data),
1505                                      GFP_KERNEL);
1506                 if (!pdata)
1507                         return -ENOMEM;
1508                 if (i2c_client->dev.of_node) {
1509                         ret = cs35l35_handle_of_data(i2c_client, pdata);
1510                         if (ret != 0)
1511                                 return ret;
1512
1513                 }
1514                 cs35l35->pdata = *pdata;
1515         }
1516
1517         ret = regulator_bulk_enable(cs35l35->num_supplies,
1518                                         cs35l35->supplies);
1519         if (ret != 0) {
1520                 dev_err(dev, "Failed to enable core supplies: %d\n", ret);
1521                 return ret;
1522         }
1523
1524         /* returning NULL can be valid if in stereo mode */
1525         cs35l35->reset_gpio = devm_gpiod_get_optional(dev, "reset",
1526                                                       GPIOD_OUT_LOW);
1527         if (IS_ERR(cs35l35->reset_gpio)) {
1528                 ret = PTR_ERR(cs35l35->reset_gpio);
1529                 cs35l35->reset_gpio = NULL;
1530                 if (ret == -EBUSY) {
1531                         dev_info(dev,
1532                                  "Reset line busy, assuming shared reset\n");
1533                 } else {
1534                         dev_err(dev, "Failed to get reset GPIO: %d\n", ret);
1535                         goto err;
1536                 }
1537         }
1538
1539         gpiod_set_value_cansleep(cs35l35->reset_gpio, 1);
1540
1541         init_completion(&cs35l35->pdn_done);
1542
1543         ret = devm_request_threaded_irq(dev, i2c_client->irq, NULL, cs35l35_irq,
1544                                         IRQF_ONESHOT | IRQF_TRIGGER_LOW |
1545                                         IRQF_SHARED, "cs35l35", cs35l35);
1546         if (ret != 0) {
1547                 dev_err(dev, "Failed to request IRQ: %d\n", ret);
1548                 goto err;
1549         }
1550         /* initialize codec */
1551         ret = regmap_read(cs35l35->regmap, CS35L35_DEVID_AB, &reg);
1552
1553         devid = (reg & 0xFF) << 12;
1554         ret = regmap_read(cs35l35->regmap, CS35L35_DEVID_CD, &reg);
1555         devid |= (reg & 0xFF) << 4;
1556         ret = regmap_read(cs35l35->regmap, CS35L35_DEVID_E, &reg);
1557         devid |= (reg & 0xF0) >> 4;
1558
1559         if (devid != CS35L35_CHIP_ID) {
1560                 dev_err(dev, "CS35L35 Device ID (%X). Expected ID %X\n",
1561                         devid, CS35L35_CHIP_ID);
1562                 ret = -ENODEV;
1563                 goto err;
1564         }
1565
1566         ret = regmap_read(cs35l35->regmap, CS35L35_REV_ID, &reg);
1567         if (ret < 0) {
1568                 dev_err(dev, "Get Revision ID failed: %d\n", ret);
1569                 goto err;
1570         }
1571
1572         ret = regmap_register_patch(cs35l35->regmap, cs35l35_errata_patch,
1573                                     ARRAY_SIZE(cs35l35_errata_patch));
1574         if (ret < 0) {
1575                 dev_err(dev, "Failed to apply errata patch: %d\n", ret);
1576                 goto err;
1577         }
1578
1579         dev_info(dev, "Cirrus Logic CS35L35 (%x), Revision: %02X\n",
1580                  devid, reg & 0xFF);
1581
1582         /* Set the INT Masks for critical errors */
1583         regmap_write(cs35l35->regmap, CS35L35_INT_MASK_1,
1584                                 CS35L35_INT1_CRIT_MASK);
1585         regmap_write(cs35l35->regmap, CS35L35_INT_MASK_2,
1586                                 CS35L35_INT2_CRIT_MASK);
1587         regmap_write(cs35l35->regmap, CS35L35_INT_MASK_3,
1588                                 CS35L35_INT3_CRIT_MASK);
1589         regmap_write(cs35l35->regmap, CS35L35_INT_MASK_4,
1590                                 CS35L35_INT4_CRIT_MASK);
1591
1592         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
1593                         CS35L35_PWR2_PDN_MASK,
1594                         CS35L35_PWR2_PDN_MASK);
1595
1596         if (cs35l35->pdata.bst_pdn_fet_on)
1597                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
1598                                         CS35L35_PDN_BST_MASK,
1599                                         1 << CS35L35_PDN_BST_FETON_SHIFT);
1600         else
1601                 regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL2,
1602                                         CS35L35_PDN_BST_MASK,
1603                                         1 << CS35L35_PDN_BST_FETOFF_SHIFT);
1604
1605         regmap_update_bits(cs35l35->regmap, CS35L35_PWRCTL3,
1606                         CS35L35_PWR3_PDN_MASK,
1607                         CS35L35_PWR3_PDN_MASK);
1608
1609         regmap_update_bits(cs35l35->regmap, CS35L35_PROTECT_CTL,
1610                 CS35L35_AMP_MUTE_MASK, 1 << CS35L35_AMP_MUTE_SHIFT);
1611
1612         ret =  snd_soc_register_codec(dev, &soc_codec_dev_cs35l35, cs35l35_dai,
1613                                       ARRAY_SIZE(cs35l35_dai));
1614         if (ret < 0) {
1615                 dev_err(dev, "Failed to register codec: %d\n", ret);
1616                 goto err;
1617         }
1618
1619         return 0;
1620
1621 err:
1622         regulator_bulk_disable(cs35l35->num_supplies,
1623                                cs35l35->supplies);
1624         gpiod_set_value_cansleep(cs35l35->reset_gpio, 0);
1625
1626         return ret;
1627 }
1628
1629 static int cs35l35_i2c_remove(struct i2c_client *client)
1630 {
1631         snd_soc_unregister_codec(&client->dev);
1632         return 0;
1633 }
1634
1635 static const struct of_device_id cs35l35_of_match[] = {
1636         {.compatible = "cirrus,cs35l35"},
1637         {},
1638 };
1639 MODULE_DEVICE_TABLE(of, cs35l35_of_match);
1640
1641 static const struct i2c_device_id cs35l35_id[] = {
1642         {"cs35l35", 0},
1643         {}
1644 };
1645
1646 MODULE_DEVICE_TABLE(i2c, cs35l35_id);
1647
1648 static struct i2c_driver cs35l35_i2c_driver = {
1649         .driver = {
1650                 .name = "cs35l35",
1651                 .of_match_table = cs35l35_of_match,
1652         },
1653         .id_table = cs35l35_id,
1654         .probe = cs35l35_i2c_probe,
1655         .remove = cs35l35_i2c_remove,
1656 };
1657
1658 module_i2c_driver(cs35l35_i2c_driver);
1659
1660 MODULE_DESCRIPTION("ASoC CS35L35 driver");
1661 MODULE_AUTHOR("Brian Austin, Cirrus Logic Inc, <brian.austin@cirrus.com>");
1662 MODULE_LICENSE("GPL");