sound/soc/codecs/cs43130.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * cs43130.c  --  CS43130 ALSA Soc Audio driver
   4  *
   5  * Copyright 2017 Cirrus Logic, Inc.
   6  *
   7  * Authors: Li Xu <li.xu@cirrus.com>
   8  */
   9 #include <linux/module.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/delay.h>
  14 #include <linux/gpio.h>
  15 #include <linux/gpio/consumer.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm.h>
  18 #include <linux/i2c.h>
  19 #include <linux/of_device.h>
  20 #include <linux/regmap.h>
  21 #include <linux/slab.h>
  22 #include <sound/core.h>
  23 #include <sound/pcm.h>
  24 #include <sound/pcm_params.h>
  25 #include <sound/soc.h>
  26 #include <sound/soc-dapm.h>
  27 #include <sound/initval.h>
  28 #include <sound/tlv.h>
  29 #include <linux/of_gpio.h>
  30 #include <linux/regulator/consumer.h>
  31 #include <linux/pm_runtime.h>
  32 #include <linux/of_irq.h>
  33 #include <linux/completion.h>
  34 #include <linux/mutex.h>
  35 #include <linux/workqueue.h>
  36 #include <sound/jack.h>
  37
  38 #include "cs43130.h"
  39
  40 static const struct reg_default cs43130_reg_defaults[] = {
  41         {CS43130_SYS_CLK_CTL_1, 0x06},
  42         {CS43130_SP_SRATE, 0x01},
  43         {CS43130_SP_BITSIZE, 0x05},
  44         {CS43130_PAD_INT_CFG, 0x03},
  45         {CS43130_PWDN_CTL, 0xFE},
  46         {CS43130_CRYSTAL_SET, 0x04},
  47         {CS43130_PLL_SET_1, 0x00},
  48         {CS43130_PLL_SET_2, 0x00},
  49         {CS43130_PLL_SET_3, 0x00},
  50         {CS43130_PLL_SET_4, 0x00},
  51         {CS43130_PLL_SET_5, 0x40},
  52         {CS43130_PLL_SET_6, 0x10},
  53         {CS43130_PLL_SET_7, 0x80},
  54         {CS43130_PLL_SET_8, 0x03},
  55         {CS43130_PLL_SET_9, 0x02},
  56         {CS43130_PLL_SET_10, 0x02},
  57         {CS43130_CLKOUT_CTL, 0x00},
  58         {CS43130_ASP_NUM_1, 0x01},
  59         {CS43130_ASP_NUM_2, 0x00},
  60         {CS43130_ASP_DEN_1, 0x08},
  61         {CS43130_ASP_DEN_2, 0x00},
  62         {CS43130_ASP_LRCK_HI_TIME_1, 0x1F},
  63         {CS43130_ASP_LRCK_HI_TIME_2, 0x00},
  64         {CS43130_ASP_LRCK_PERIOD_1, 0x3F},
  65         {CS43130_ASP_LRCK_PERIOD_2, 0x00},
  66         {CS43130_ASP_CLOCK_CONF, 0x0C},
  67         {CS43130_ASP_FRAME_CONF, 0x0A},
  68         {CS43130_XSP_NUM_1, 0x01},
  69         {CS43130_XSP_NUM_2, 0x00},
  70         {CS43130_XSP_DEN_1, 0x02},
  71         {CS43130_XSP_DEN_2, 0x00},
  72         {CS43130_XSP_LRCK_HI_TIME_1, 0x1F},
  73         {CS43130_XSP_LRCK_HI_TIME_2, 0x00},
  74         {CS43130_XSP_LRCK_PERIOD_1, 0x3F},
  75         {CS43130_XSP_LRCK_PERIOD_2, 0x00},
  76         {CS43130_XSP_CLOCK_CONF, 0x0C},
  77         {CS43130_XSP_FRAME_CONF, 0x0A},
  78         {CS43130_ASP_CH_1_LOC, 0x00},
  79         {CS43130_ASP_CH_2_LOC, 0x00},
  80         {CS43130_ASP_CH_1_SZ_EN, 0x06},
  81         {CS43130_ASP_CH_2_SZ_EN, 0x0E},
  82         {CS43130_XSP_CH_1_LOC, 0x00},
  83         {CS43130_XSP_CH_2_LOC, 0x00},
  84         {CS43130_XSP_CH_1_SZ_EN, 0x06},
  85         {CS43130_XSP_CH_2_SZ_EN, 0x0E},
  86         {CS43130_DSD_VOL_B, 0x78},
  87         {CS43130_DSD_VOL_A, 0x78},
  88         {CS43130_DSD_PATH_CTL_1, 0xA8},
  89         {CS43130_DSD_INT_CFG, 0x00},
  90         {CS43130_DSD_PATH_CTL_2, 0x02},
  91         {CS43130_DSD_PCM_MIX_CTL, 0x00},
  92         {CS43130_DSD_PATH_CTL_3, 0x40},
  93         {CS43130_HP_OUT_CTL_1, 0x30},
  94         {CS43130_PCM_FILT_OPT, 0x02},
  95         {CS43130_PCM_VOL_B, 0x78},
  96         {CS43130_PCM_VOL_A, 0x78},
  97         {CS43130_PCM_PATH_CTL_1, 0xA8},
  98         {CS43130_PCM_PATH_CTL_2, 0x00},
  99         {CS43130_CLASS_H_CTL, 0x1E},
 100         {CS43130_HP_DETECT, 0x04},
 101         {CS43130_HP_LOAD_1, 0x00},
 102         {CS43130_HP_MEAS_LOAD_1, 0x00},
 103         {CS43130_HP_MEAS_LOAD_2, 0x00},
 104         {CS43130_INT_MASK_1, 0xFF},
 105         {CS43130_INT_MASK_2, 0xFF},
 106         {CS43130_INT_MASK_3, 0xFF},
 107         {CS43130_INT_MASK_4, 0xFF},
 108         {CS43130_INT_MASK_5, 0xFF},
 109 };
 110
 111 static bool cs43130_volatile_register(struct device *dev, unsigned int reg)
 112 {
 113         switch (reg) {
 114         case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
 115         case CS43130_HP_DC_STAT_1 ... CS43130_HP_DC_STAT_2:
 116         case CS43130_HP_AC_STAT_1 ... CS43130_HP_AC_STAT_2:
 117                 return true;
 118         default:
 119                 return false;
 120         }
 121 }
 122
 123 static bool cs43130_readable_register(struct device *dev, unsigned int reg)
 124 {
 125         switch (reg) {
 126         case CS43130_DEVID_AB ... CS43130_SYS_CLK_CTL_1:
 127         case CS43130_SP_SRATE ... CS43130_PAD_INT_CFG:
 128         case CS43130_PWDN_CTL:
 129         case CS43130_CRYSTAL_SET:
 130         case CS43130_PLL_SET_1 ... CS43130_PLL_SET_5:
 131         case CS43130_PLL_SET_6:
 132         case CS43130_PLL_SET_7:
 133         case CS43130_PLL_SET_8:
 134         case CS43130_PLL_SET_9:
 135         case CS43130_PLL_SET_10:
 136         case CS43130_CLKOUT_CTL:
 137         case CS43130_ASP_NUM_1 ... CS43130_ASP_FRAME_CONF:
 138         case CS43130_XSP_NUM_1 ... CS43130_XSP_FRAME_CONF:
 139         case CS43130_ASP_CH_1_LOC:
 140         case CS43130_ASP_CH_2_LOC:
 141         case CS43130_ASP_CH_1_SZ_EN:
 142         case CS43130_ASP_CH_2_SZ_EN:
 143         case CS43130_XSP_CH_1_LOC:
 144         case CS43130_XSP_CH_2_LOC:
 145         case CS43130_XSP_CH_1_SZ_EN:
 146         case CS43130_XSP_CH_2_SZ_EN:
 147         case CS43130_DSD_VOL_B ... CS43130_DSD_PATH_CTL_3:
 148         case CS43130_HP_OUT_CTL_1:
 149         case CS43130_PCM_FILT_OPT ... CS43130_PCM_PATH_CTL_2:
 150         case CS43130_CLASS_H_CTL:
 151         case CS43130_HP_DETECT:
 152         case CS43130_HP_STATUS:
 153         case CS43130_HP_LOAD_1:
 154         case CS43130_HP_MEAS_LOAD_1:
 155         case CS43130_HP_MEAS_LOAD_2:
 156         case CS43130_HP_DC_STAT_1:
 157         case CS43130_HP_DC_STAT_2:
 158         case CS43130_HP_AC_STAT_1:
 159         case CS43130_HP_AC_STAT_2:
 160         case CS43130_HP_LOAD_STAT:
 161         case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
 162         case CS43130_INT_MASK_1 ... CS43130_INT_MASK_5:
 163                 return true;
 164         default:
 165                 return false;
 166         }
 167 }
 168
 169 static bool cs43130_precious_register(struct device *dev, unsigned int reg)
 170 {
 171         switch (reg) {
 172         case CS43130_INT_STATUS_1 ... CS43130_INT_STATUS_5:
 173                 return true;
 174         default:
 175                 return false;
 176         }
 177 }
 178
 179 struct cs43130_pll_params {
 180         unsigned int pll_in;
 181         u8 sclk_prediv;
 182         u8 pll_div_int;
 183         u32 pll_div_frac;
 184         u8 pll_mode;
 185         u8 pll_divout;
 186         unsigned int pll_out;
 187         u8 pll_cal_ratio;
 188 };
 189
 190 static const struct cs43130_pll_params pll_ratio_table[] = {
 191         {9600000, 0x02, 0x49, 0x800000, 0x00, 0x08, 22579200, 151},
 192         {9600000, 0x02, 0x50, 0x000000, 0x00, 0x08, 24576000, 164},
 193
 194         {11289600, 0x02, 0X40, 0, 0x01, 0x08, 22579200, 128},
 195         {11289600, 0x02, 0x44, 0x06F700, 0x0, 0x08, 24576000, 139},
 196
 197         {12000000, 0x02, 0x49, 0x800000, 0x00, 0x0A, 22579200, 120},
 198         {12000000, 0x02, 0x40, 0x000000, 0x00, 0x08, 24576000, 131},
 199
 200         {12288000, 0x02, 0x49, 0x800000, 0x01, 0x0A, 22579200, 118},
 201         {12288000, 0x02, 0x40, 0x000000, 0x01, 0x08, 24576000, 128},
 202
 203         {13000000, 0x02, 0x45, 0x797680, 0x01, 0x0A, 22579200, 111},
 204         {13000000, 0x02, 0x3C, 0x7EA940, 0x01, 0x08, 24576000, 121},
 205
 206         {19200000, 0x03, 0x49, 0x800000, 0x00, 0x08, 22579200, 151},
 207         {19200000, 0x03, 0x50, 0x000000, 0x00, 0x08, 24576000, 164},
 208
 209         {22579200, 0, 0, 0, 0, 0, 22579200, 0},
 210         {22579200, 0x03, 0x44, 0x06F700, 0x00, 0x08, 24576000, 139},
 211
 212         {24000000, 0x03, 0x49, 0x800000, 0x00, 0x0A, 22579200, 120},
 213         {24000000, 0x03, 0x40, 0x000000, 0x00, 0x08, 24576000, 131},
 214
 215         {24576000, 0x03, 0x49, 0x800000, 0x01, 0x0A, 22579200, 118},
 216         {24576000, 0, 0, 0, 0, 0, 24576000, 0},
 217
 218         {26000000, 0x03, 0x45, 0x797680, 0x01, 0x0A, 22579200, 111},
 219         {26000000, 0x03, 0x3C, 0x7EA940, 0x01, 0x08, 24576000, 121},
 220 };
 221
 222 static const struct cs43130_pll_params *cs43130_get_pll_table(
 223                 unsigned int freq_in, unsigned int freq_out)
 224 {
 225         int i;
 226
 227         for (i = 0; i < ARRAY_SIZE(pll_ratio_table); i++) {
 228                 if (pll_ratio_table[i].pll_in == freq_in &&
 229                     pll_ratio_table[i].pll_out == freq_out)
 230                         return &pll_ratio_table[i];
 231         }
 232
 233         return NULL;
 234 }
 235
 236 static int cs43130_pll_config(struct snd_soc_component *component)
 237 {
 238         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 239         const struct cs43130_pll_params *pll_entry;
 240
 241         dev_dbg(component->dev, "cs43130->mclk = %u, cs43130->mclk_int = %u\n",
 242                 cs43130->mclk, cs43130->mclk_int);
 243
 244         pll_entry = cs43130_get_pll_table(cs43130->mclk, cs43130->mclk_int);
 245         if (!pll_entry)
 246                 return -EINVAL;
 247
 248         if (pll_entry->pll_cal_ratio == 0) {
 249                 regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_1,
 250                                    CS43130_PLL_START_MASK, 0);
 251
 252                 cs43130->pll_bypass = true;
 253                 return 0;
 254         }
 255
 256         cs43130->pll_bypass = false;
 257
 258         regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_2,
 259                            CS43130_PLL_DIV_DATA_MASK,
 260                            pll_entry->pll_div_frac >>
 261                            CS43130_PLL_DIV_FRAC_0_DATA_SHIFT);
 262         regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_3,
 263                            CS43130_PLL_DIV_DATA_MASK,
 264                            pll_entry->pll_div_frac >>
 265                            CS43130_PLL_DIV_FRAC_1_DATA_SHIFT);
 266         regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_4,
 267                            CS43130_PLL_DIV_DATA_MASK,
 268                            pll_entry->pll_div_frac >>
 269                            CS43130_PLL_DIV_FRAC_2_DATA_SHIFT);
 270         regmap_write(cs43130->regmap, CS43130_PLL_SET_5,
 271                      pll_entry->pll_div_int);
 272         regmap_write(cs43130->regmap, CS43130_PLL_SET_6, pll_entry->pll_divout);
 273         regmap_write(cs43130->regmap, CS43130_PLL_SET_7,
 274                      pll_entry->pll_cal_ratio);
 275         regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_8,
 276                            CS43130_PLL_MODE_MASK,
 277                            pll_entry->pll_mode << CS43130_PLL_MODE_SHIFT);
 278         regmap_write(cs43130->regmap, CS43130_PLL_SET_9,
 279                      pll_entry->sclk_prediv);
 280         regmap_update_bits(cs43130->regmap, CS43130_PLL_SET_1,
 281                            CS43130_PLL_START_MASK, 1);
 282
 283         return 0;
 284 }
 285
 286 static int cs43130_set_pll(struct snd_soc_component *component, int pll_id, int source,
 287                            unsigned int freq_in, unsigned int freq_out)
 288 {
 289         int ret = 0;
 290         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 291
 292         switch (freq_in) {
 293         case 9600000:
 294         case 11289600:
 295         case 12000000:
 296         case 12288000:
 297         case 13000000:
 298         case 19200000:
 299         case 22579200:
 300         case 24000000:
 301         case 24576000:
 302         case 26000000:
 303                 cs43130->mclk = freq_in;
 304                 break;
 305         default:
 306                 dev_err(component->dev,
 307                         "unsupported pll input reference clock:%d\n", freq_in);
 308                 return -EINVAL;
 309         }
 310
 311         switch (freq_out) {
 312         case 22579200:
 313                 cs43130->mclk_int = freq_out;
 314                 break;
 315         case 24576000:
 316                 cs43130->mclk_int = freq_out;
 317                 break;
 318         default:
 319                 dev_err(component->dev,
 320                         "unsupported pll output ref clock: %u\n", freq_out);
 321                 return -EINVAL;
 322         }
 323
 324         ret = cs43130_pll_config(component);
 325         dev_dbg(component->dev, "cs43130->pll_bypass = %d", cs43130->pll_bypass);
 326         return ret;
 327 }
 328
 329 static int cs43130_change_clksrc(struct snd_soc_component *component,
 330                                  enum cs43130_mclk_src_sel src)
 331 {
 332         int ret;
 333         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 334         int mclk_int_decoded;
 335
 336         if (src == cs43130->mclk_int_src) {
 337                 /* clk source has not changed */
 338                 return 0;
 339         }
 340
 341         switch (cs43130->mclk_int) {
 342         case CS43130_MCLK_22M:
 343                 mclk_int_decoded = CS43130_MCLK_22P5;
 344                 break;
 345         case CS43130_MCLK_24M:
 346                 mclk_int_decoded = CS43130_MCLK_24P5;
 347                 break;
 348         default:
 349                 dev_err(component->dev, "Invalid MCLK INT freq: %u\n", cs43130->mclk_int);
 350                 return -EINVAL;
 351         }
 352
 353         switch (src) {
 354         case CS43130_MCLK_SRC_EXT:
 355                 cs43130->pll_bypass = true;
 356                 cs43130->mclk_int_src = CS43130_MCLK_SRC_EXT;
 357                 if (cs43130->xtal_ibias == CS43130_XTAL_UNUSED) {
 358                         regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 359                                            CS43130_PDN_XTAL_MASK,
 360                                            1 << CS43130_PDN_XTAL_SHIFT);
 361                 } else {
 362                         reinit_completion(&cs43130->xtal_rdy);
 363                         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 364                                            CS43130_XTAL_RDY_INT_MASK, 0);
 365                         regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 366                                            CS43130_PDN_XTAL_MASK, 0);
 367                         ret = wait_for_completion_timeout(&cs43130->xtal_rdy,
 368                                                           msecs_to_jiffies(100));
 369                         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 370                                            CS43130_XTAL_RDY_INT_MASK,
 371                                            1 << CS43130_XTAL_RDY_INT_SHIFT);
 372                         if (ret == 0) {
 373                                 dev_err(component->dev, "Timeout waiting for XTAL_READY interrupt\n");
 374                                 return -ETIMEDOUT;
 375                         }
 376                 }
 377
 378                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 379                                    CS43130_MCLK_SRC_SEL_MASK,
 380                                    src << CS43130_MCLK_SRC_SEL_SHIFT);
 381                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 382                                    CS43130_MCLK_INT_MASK,
 383                                    mclk_int_decoded << CS43130_MCLK_INT_SHIFT);
 384                 usleep_range(150, 200);
 385
 386                 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 387                                    CS43130_PDN_PLL_MASK,
 388                                    1 << CS43130_PDN_PLL_SHIFT);
 389                 break;
 390         case CS43130_MCLK_SRC_PLL:
 391                 cs43130->pll_bypass = false;
 392                 cs43130->mclk_int_src = CS43130_MCLK_SRC_PLL;
 393                 if (cs43130->xtal_ibias == CS43130_XTAL_UNUSED) {
 394                         regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 395                                            CS43130_PDN_XTAL_MASK,
 396                                            1 << CS43130_PDN_XTAL_SHIFT);
 397                 } else {
 398                         reinit_completion(&cs43130->xtal_rdy);
 399                         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 400                                            CS43130_XTAL_RDY_INT_MASK, 0);
 401                         regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 402                                            CS43130_PDN_XTAL_MASK, 0);
 403                         ret = wait_for_completion_timeout(&cs43130->xtal_rdy,
 404                                                           msecs_to_jiffies(100));
 405                         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 406                                            CS43130_XTAL_RDY_INT_MASK,
 407                                            1 << CS43130_XTAL_RDY_INT_SHIFT);
 408                         if (ret == 0) {
 409                                 dev_err(component->dev, "Timeout waiting for XTAL_READY interrupt\n");
 410                                 return -ETIMEDOUT;
 411                         }
 412                 }
 413
 414                 reinit_completion(&cs43130->pll_rdy);
 415                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 416                                    CS43130_PLL_RDY_INT_MASK, 0);
 417                 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 418                                    CS43130_PDN_PLL_MASK, 0);
 419                 ret = wait_for_completion_timeout(&cs43130->pll_rdy,
 420                                                   msecs_to_jiffies(100));
 421                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
 422                                    CS43130_PLL_RDY_INT_MASK,
 423                                    1 << CS43130_PLL_RDY_INT_SHIFT);
 424                 if (ret == 0) {
 425                         dev_err(component->dev, "Timeout waiting for PLL_READY interrupt\n");
 426                         return -ETIMEDOUT;
 427                 }
 428
 429                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 430                                    CS43130_MCLK_SRC_SEL_MASK,
 431                                    src << CS43130_MCLK_SRC_SEL_SHIFT);
 432                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 433                                    CS43130_MCLK_INT_MASK,
 434                                    mclk_int_decoded << CS43130_MCLK_INT_SHIFT);
 435                 usleep_range(150, 200);
 436                 break;
 437         case CS43130_MCLK_SRC_RCO:
 438                 cs43130->mclk_int_src = CS43130_MCLK_SRC_RCO;
 439
 440                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 441                                    CS43130_MCLK_SRC_SEL_MASK,
 442                                    src << CS43130_MCLK_SRC_SEL_SHIFT);
 443                 regmap_update_bits(cs43130->regmap, CS43130_SYS_CLK_CTL_1,
 444                                    CS43130_MCLK_INT_MASK,
 445                                    CS43130_MCLK_22P5 << CS43130_MCLK_INT_SHIFT);
 446                 usleep_range(150, 200);
 447
 448                 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 449                                    CS43130_PDN_XTAL_MASK,
 450                                    1 << CS43130_PDN_XTAL_SHIFT);
 451                 regmap_update_bits(cs43130->regmap, CS43130_PWDN_CTL,
 452                                    CS43130_PDN_PLL_MASK,
 453                                    1 << CS43130_PDN_PLL_SHIFT);
 454                 break;
 455         default:
 456                 dev_err(component->dev, "Invalid MCLK source value\n");
 457                 return -EINVAL;
 458         }
 459
 460         return 0;
 461 }
 462
 463 static const struct cs43130_bitwidth_map cs43130_bitwidth_table[] = {
 464         {8,     CS43130_SP_BIT_SIZE_8,  CS43130_CH_BIT_SIZE_8},
 465         {16,    CS43130_SP_BIT_SIZE_16, CS43130_CH_BIT_SIZE_16},
 466         {24,    CS43130_SP_BIT_SIZE_24, CS43130_CH_BIT_SIZE_24},
 467         {32,    CS43130_SP_BIT_SIZE_32, CS43130_CH_BIT_SIZE_32},
 468 };
 469
 470 static const struct cs43130_bitwidth_map *cs43130_get_bitwidth_table(
 471                                 unsigned int bitwidth)
 472 {
 473         int i;
 474
 475         for (i = 0; i < ARRAY_SIZE(cs43130_bitwidth_table); i++) {
 476                 if (cs43130_bitwidth_table[i].bitwidth == bitwidth)
 477                         return &cs43130_bitwidth_table[i];
 478         }
 479
 480         return NULL;
 481 }
 482
 483 static int cs43130_set_bitwidth(int dai_id, unsigned int bitwidth_dai,
 484                           struct regmap *regmap)
 485 {
 486         const struct cs43130_bitwidth_map *bw_map;
 487
 488         bw_map = cs43130_get_bitwidth_table(bitwidth_dai);
 489         if (!bw_map)
 490                 return -EINVAL;
 491
 492         switch (dai_id) {
 493         case CS43130_ASP_PCM_DAI:
 494         case CS43130_ASP_DOP_DAI:
 495                 regmap_update_bits(regmap, CS43130_ASP_CH_1_SZ_EN,
 496                                    CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
 497                 regmap_update_bits(regmap, CS43130_ASP_CH_2_SZ_EN,
 498                                    CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
 499                 regmap_update_bits(regmap, CS43130_SP_BITSIZE,
 500                                    CS43130_ASP_BITSIZE_MASK, bw_map->sp_bit);
 501                 break;
 502         case CS43130_XSP_DOP_DAI:
 503                 regmap_update_bits(regmap, CS43130_XSP_CH_1_SZ_EN,
 504                                    CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
 505                 regmap_update_bits(regmap, CS43130_XSP_CH_2_SZ_EN,
 506                                    CS43130_CH_BITSIZE_MASK, bw_map->ch_bit);
 507                 regmap_update_bits(regmap, CS43130_SP_BITSIZE,
 508                                    CS43130_XSP_BITSIZE_MASK, bw_map->sp_bit <<
 509                                    CS43130_XSP_BITSIZE_SHIFT);
 510                 break;
 511         default:
 512                 return -EINVAL;
 513         }
 514
 515         return 0;
 516 }
 517
 518 static const struct cs43130_rate_map cs43130_rate_table[] = {
 519         {32000,         CS43130_ASP_SPRATE_32K},
 520         {44100,         CS43130_ASP_SPRATE_44_1K},
 521         {48000,         CS43130_ASP_SPRATE_48K},
 522         {88200,         CS43130_ASP_SPRATE_88_2K},
 523         {96000,         CS43130_ASP_SPRATE_96K},
 524         {176400,        CS43130_ASP_SPRATE_176_4K},
 525         {192000,        CS43130_ASP_SPRATE_192K},
 526         {352800,        CS43130_ASP_SPRATE_352_8K},
 527         {384000,        CS43130_ASP_SPRATE_384K},
 528 };
 529
 530 static const struct cs43130_rate_map *cs43130_get_rate_table(int fs)
 531 {
 532         int i;
 533
 534         for (i = 0; i < ARRAY_SIZE(cs43130_rate_table); i++) {
 535                 if (cs43130_rate_table[i].fs == fs)
 536                         return &cs43130_rate_table[i];
 537         }
 538
 539         return NULL;
 540 }
 541
 542 static const struct cs43130_clk_gen *cs43130_get_clk_gen(int mclk_int, int fs,
 543                 const struct cs43130_clk_gen *clk_gen_table, int len_clk_gen_table)
 544 {
 545         int i;
 546
 547         for (i = 0; i < len_clk_gen_table; i++) {
 548                 if (clk_gen_table[i].mclk_int == mclk_int &&
 549                     clk_gen_table[i].fs == fs)
 550                         return &clk_gen_table[i];
 551         }
 552
 553         return NULL;
 554 }
 555
 556 static int cs43130_set_sp_fmt(int dai_id, unsigned int bitwidth_sclk,
 557                               struct snd_pcm_hw_params *params,
 558                               struct cs43130_private *cs43130)
 559 {
 560         u16 frm_size;
 561         u16 hi_size;
 562         u8 frm_delay;
 563         u8 frm_phase;
 564         u8 frm_data;
 565         u8 sclk_edge;
 566         u8 lrck_edge;
 567         u8 clk_data;
 568         u8 loc_ch1;
 569         u8 loc_ch2;
 570         u8 dai_mode_val;
 571         const struct cs43130_clk_gen *clk_gen;
 572
 573         switch (cs43130->dais[dai_id].dai_format) {
 574         case SND_SOC_DAIFMT_I2S:
 575                 hi_size = bitwidth_sclk;
 576                 frm_delay = 2;
 577                 frm_phase = 0;
 578                 break;
 579         case SND_SOC_DAIFMT_LEFT_J:
 580                 hi_size = bitwidth_sclk;
 581                 frm_delay = 2;
 582                 frm_phase = 1;
 583                 break;
 584         case SND_SOC_DAIFMT_DSP_A:
 585                 hi_size = 1;
 586                 frm_delay = 2;
 587                 frm_phase = 1;
 588                 break;
 589         case SND_SOC_DAIFMT_DSP_B:
 590                 hi_size = 1;
 591                 frm_delay = 0;
 592                 frm_phase = 1;
 593                 break;
 594         default:
 595                 return -EINVAL;
 596         }
 597
 598         switch (cs43130->dais[dai_id].dai_mode) {
 599         case SND_SOC_DAIFMT_CBS_CFS:
 600                 dai_mode_val = 0;
 601                 break;
 602         case SND_SOC_DAIFMT_CBM_CFM:
 603                 dai_mode_val = 1;
 604                 break;
 605         default:
 606                 return -EINVAL;
 607         }
 608
 609         frm_size = bitwidth_sclk * params_channels(params);
 610         sclk_edge = 1;
 611         lrck_edge = 0;
 612         loc_ch1 = 0;
 613         loc_ch2 = bitwidth_sclk * (params_channels(params) - 1);
 614
 615         frm_data = frm_delay & CS43130_SP_FSD_MASK;
 616         frm_data |= (frm_phase << CS43130_SP_STP_SHIFT) & CS43130_SP_STP_MASK;
 617
 618         clk_data = lrck_edge & CS43130_SP_LCPOL_IN_MASK;
 619         clk_data |= (lrck_edge << CS43130_SP_LCPOL_OUT_SHIFT) &
 620                     CS43130_SP_LCPOL_OUT_MASK;
 621         clk_data |= (sclk_edge << CS43130_SP_SCPOL_IN_SHIFT) &
 622                     CS43130_SP_SCPOL_IN_MASK;
 623         clk_data |= (sclk_edge << CS43130_SP_SCPOL_OUT_SHIFT) &
 624                     CS43130_SP_SCPOL_OUT_MASK;
 625         clk_data |= (dai_mode_val << CS43130_SP_MODE_SHIFT) &
 626                     CS43130_SP_MODE_MASK;
 627
 628         switch (dai_id) {
 629         case CS43130_ASP_PCM_DAI:
 630         case CS43130_ASP_DOP_DAI:
 631                 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_PERIOD_1,
 632                         CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
 633                         CS43130_SP_LCPR_LSB_DATA_SHIFT);
 634                 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_PERIOD_2,
 635                         CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
 636                         CS43130_SP_LCPR_MSB_DATA_SHIFT);
 637                 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_HI_TIME_1,
 638                         CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
 639                         CS43130_SP_LCHI_LSB_DATA_SHIFT);
 640                 regmap_update_bits(cs43130->regmap, CS43130_ASP_LRCK_HI_TIME_2,
 641                         CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
 642                         CS43130_SP_LCHI_MSB_DATA_SHIFT);
 643                 regmap_write(cs43130->regmap, CS43130_ASP_FRAME_CONF, frm_data);
 644                 regmap_write(cs43130->regmap, CS43130_ASP_CH_1_LOC, loc_ch1);
 645                 regmap_write(cs43130->regmap, CS43130_ASP_CH_2_LOC, loc_ch2);
 646                 regmap_update_bits(cs43130->regmap, CS43130_ASP_CH_1_SZ_EN,
 647                         CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
 648                 regmap_update_bits(cs43130->regmap, CS43130_ASP_CH_2_SZ_EN,
 649                         CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
 650                 regmap_write(cs43130->regmap, CS43130_ASP_CLOCK_CONF, clk_data);
 651                 break;
 652         case CS43130_XSP_DOP_DAI:
 653                 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_PERIOD_1,
 654                         CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
 655                         CS43130_SP_LCPR_LSB_DATA_SHIFT);
 656                 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_PERIOD_2,
 657                         CS43130_SP_LCPR_DATA_MASK, (frm_size - 1) >>
 658                         CS43130_SP_LCPR_MSB_DATA_SHIFT);
 659                 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_HI_TIME_1,
 660                         CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
 661                         CS43130_SP_LCHI_LSB_DATA_SHIFT);
 662                 regmap_update_bits(cs43130->regmap, CS43130_XSP_LRCK_HI_TIME_2,
 663                         CS43130_SP_LCHI_DATA_MASK, (hi_size - 1) >>
 664                         CS43130_SP_LCHI_MSB_DATA_SHIFT);
 665                 regmap_write(cs43130->regmap, CS43130_XSP_FRAME_CONF, frm_data);
 666                 regmap_write(cs43130->regmap, CS43130_XSP_CH_1_LOC, loc_ch1);
 667                 regmap_write(cs43130->regmap, CS43130_XSP_CH_2_LOC, loc_ch2);
 668                 regmap_update_bits(cs43130->regmap, CS43130_XSP_CH_1_SZ_EN,
 669                         CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
 670                 regmap_update_bits(cs43130->regmap, CS43130_XSP_CH_2_SZ_EN,
 671                         CS43130_CH_EN_MASK, 1 << CS43130_CH_EN_SHIFT);
 672                 regmap_write(cs43130->regmap, CS43130_XSP_CLOCK_CONF, clk_data);
 673                 break;
 674         default:
 675                 return -EINVAL;
 676         }
 677
 678         switch (frm_size) {
 679         case 16:
 680                 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
 681                                               params_rate(params),
 682                                               cs43130_16_clk_gen,
 683                                               ARRAY_SIZE(cs43130_16_clk_gen));
 684                 break;
 685         case 32:
 686                 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
 687                                               params_rate(params),
 688                                               cs43130_32_clk_gen,
 689                                               ARRAY_SIZE(cs43130_32_clk_gen));
 690                 break;
 691         case 48:
 692                 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
 693                                               params_rate(params),
 694                                               cs43130_48_clk_gen,
 695                                               ARRAY_SIZE(cs43130_48_clk_gen));
 696                 break;
 697         case 64:
 698                 clk_gen = cs43130_get_clk_gen(cs43130->mclk_int,
 699                                               params_rate(params),
 700                                               cs43130_64_clk_gen,
 701                                               ARRAY_SIZE(cs43130_64_clk_gen));
 702                 break;
 703         default:
 704                 return -EINVAL;
 705         }
 706
 707         if (!clk_gen)
 708                 return -EINVAL;
 709
 710         switch (dai_id) {
 711         case CS43130_ASP_PCM_DAI:
 712         case CS43130_ASP_DOP_DAI:
 713                 regmap_write(cs43130->regmap, CS43130_ASP_DEN_1,
 714                              (clk_gen->den & CS43130_SP_M_LSB_DATA_MASK) >>
 715                              CS43130_SP_M_LSB_DATA_SHIFT);
 716                 regmap_write(cs43130->regmap, CS43130_ASP_DEN_2,
 717                              (clk_gen->den & CS43130_SP_M_MSB_DATA_MASK) >>
 718                              CS43130_SP_M_MSB_DATA_SHIFT);
 719                 regmap_write(cs43130->regmap, CS43130_ASP_NUM_1,
 720                              (clk_gen->num & CS43130_SP_N_LSB_DATA_MASK) >>
 721                              CS43130_SP_N_LSB_DATA_SHIFT);
 722                 regmap_write(cs43130->regmap, CS43130_ASP_NUM_2,
 723                              (clk_gen->num & CS43130_SP_N_MSB_DATA_MASK) >>
 724                              CS43130_SP_N_MSB_DATA_SHIFT);
 725                 break;
 726         case CS43130_XSP_DOP_DAI:
 727                 regmap_write(cs43130->regmap, CS43130_XSP_DEN_1,
 728                              (clk_gen->den & CS43130_SP_M_LSB_DATA_MASK) >>
 729                              CS43130_SP_M_LSB_DATA_SHIFT);
 730                 regmap_write(cs43130->regmap, CS43130_XSP_DEN_2,
 731                              (clk_gen->den & CS43130_SP_M_MSB_DATA_MASK) >>
 732                              CS43130_SP_M_MSB_DATA_SHIFT);
 733                 regmap_write(cs43130->regmap, CS43130_XSP_NUM_1,
 734                              (clk_gen->num & CS43130_SP_N_LSB_DATA_MASK) >>
 735                              CS43130_SP_N_LSB_DATA_SHIFT);
 736                 regmap_write(cs43130->regmap, CS43130_XSP_NUM_2,
 737                              (clk_gen->num & CS43130_SP_N_MSB_DATA_MASK) >>
 738                              CS43130_SP_N_MSB_DATA_SHIFT);
 739                 break;
 740         default:
 741                 return -EINVAL;
 742         }
 743
 744         return 0;
 745 }
 746
 747 static int cs43130_pcm_dsd_mix(bool en, struct regmap *regmap)
 748 {
 749         if (en) {
 750                 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
 751                                    CS43130_MIX_PCM_PREP_MASK,
 752                                    1 << CS43130_MIX_PCM_PREP_SHIFT);
 753                 usleep_range(6000, 6050);
 754                 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
 755                                    CS43130_MIX_PCM_DSD_MASK,
 756                                    1 << CS43130_MIX_PCM_DSD_SHIFT);
 757         } else {
 758                 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
 759                                    CS43130_MIX_PCM_DSD_MASK,
 760                                    0 << CS43130_MIX_PCM_DSD_SHIFT);
 761                 usleep_range(1600, 1650);
 762                 regmap_update_bits(regmap, CS43130_DSD_PCM_MIX_CTL,
 763                                    CS43130_MIX_PCM_PREP_MASK,
 764                                    0 << CS43130_MIX_PCM_PREP_SHIFT);
 765         }
 766
 767         return 0;
 768 }
 769
 770 static int cs43130_dsd_hw_params(struct snd_pcm_substream *substream,
 771                                  struct snd_pcm_hw_params *params,
 772                                  struct snd_soc_dai *dai)
 773 {
 774         struct snd_soc_component *component = dai->component;
 775         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 776         unsigned int required_clk;
 777         u8 dsd_speed;
 778
 779         mutex_lock(&cs43130->clk_mutex);
 780         if (!cs43130->clk_req) {
 781                 /* no DAI is currently using clk */
 782                 if (!(CS43130_MCLK_22M % params_rate(params)))
 783                         required_clk = CS43130_MCLK_22M;
 784                 else
 785                         required_clk = CS43130_MCLK_24M;
 786
 787                 cs43130_set_pll(component, 0, 0, cs43130->mclk, required_clk);
 788                 if (cs43130->pll_bypass)
 789                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
 790                 else
 791                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
 792         }
 793
 794         cs43130->clk_req++;
 795         if (cs43130->clk_req == 2)
 796                 cs43130_pcm_dsd_mix(true, cs43130->regmap);
 797         mutex_unlock(&cs43130->clk_mutex);
 798
 799         switch (params_rate(params)) {
 800         case 176400:
 801                 dsd_speed = 0;
 802                 break;
 803         case 352800:
 804                 dsd_speed = 1;
 805                 break;
 806         default:
 807                 dev_err(component->dev, "Rate(%u) not supported\n",
 808                         params_rate(params));
 809                 return -EINVAL;
 810         }
 811
 812         if (cs43130->dais[dai->id].dai_mode == SND_SOC_DAIFMT_CBM_CFM)
 813                 regmap_update_bits(cs43130->regmap, CS43130_DSD_INT_CFG,
 814                                    CS43130_DSD_MASTER, CS43130_DSD_MASTER);
 815         else
 816                 regmap_update_bits(cs43130->regmap, CS43130_DSD_INT_CFG,
 817                                    CS43130_DSD_MASTER, 0);
 818
 819         regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
 820                            CS43130_DSD_SPEED_MASK,
 821                            dsd_speed << CS43130_DSD_SPEED_SHIFT);
 822         regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
 823                            CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_DSD <<
 824                            CS43130_DSD_SRC_SHIFT);
 825
 826         return 0;
 827 }
 828
 829 static int cs43130_hw_params(struct snd_pcm_substream *substream,
 830                                  struct snd_pcm_hw_params *params,
 831                                  struct snd_soc_dai *dai)
 832 {
 833         struct snd_soc_component *component = dai->component;
 834         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 835         const struct cs43130_rate_map *rate_map;
 836         unsigned int sclk = cs43130->dais[dai->id].sclk;
 837         unsigned int bitwidth_sclk;
 838         unsigned int bitwidth_dai = (unsigned int)(params_width(params));
 839         unsigned int required_clk;
 840         u8 dsd_speed;
 841
 842         mutex_lock(&cs43130->clk_mutex);
 843         if (!cs43130->clk_req) {
 844                 /* no DAI is currently using clk */
 845                 if (!(CS43130_MCLK_22M % params_rate(params)))
 846                         required_clk = CS43130_MCLK_22M;
 847                 else
 848                         required_clk = CS43130_MCLK_24M;
 849
 850                 cs43130_set_pll(component, 0, 0, cs43130->mclk, required_clk);
 851                 if (cs43130->pll_bypass)
 852                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
 853                 else
 854                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
 855         }
 856
 857         cs43130->clk_req++;
 858         if (cs43130->clk_req == 2)
 859                 cs43130_pcm_dsd_mix(true, cs43130->regmap);
 860         mutex_unlock(&cs43130->clk_mutex);
 861
 862         switch (dai->id) {
 863         case CS43130_ASP_DOP_DAI:
 864         case CS43130_XSP_DOP_DAI:
 865                 /* DoP bitwidth is always 24-bit */
 866                 bitwidth_dai = 24;
 867                 sclk = params_rate(params) * bitwidth_dai *
 868                        params_channels(params);
 869
 870                 switch (params_rate(params)) {
 871                 case 176400:
 872                         dsd_speed = 0;
 873                         break;
 874                 case 352800:
 875                         dsd_speed = 1;
 876                         break;
 877                 default:
 878                         dev_err(component->dev, "Rate(%u) not supported\n",
 879                                 params_rate(params));
 880                         return -EINVAL;
 881                 }
 882
 883                 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
 884                                    CS43130_DSD_SPEED_MASK,
 885                                    dsd_speed << CS43130_DSD_SPEED_SHIFT);
 886                 break;
 887         case CS43130_ASP_PCM_DAI:
 888                 rate_map = cs43130_get_rate_table(params_rate(params));
 889                 if (!rate_map)
 890                         return -EINVAL;
 891
 892                 regmap_write(cs43130->regmap, CS43130_SP_SRATE, rate_map->val);
 893                 break;
 894         default:
 895                 dev_err(component->dev, "Invalid DAI (%d)\n", dai->id);
 896                 return -EINVAL;
 897         }
 898
 899         switch (dai->id) {
 900         case CS43130_ASP_DOP_DAI:
 901                 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
 902                                    CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_ASP <<
 903                                    CS43130_DSD_SRC_SHIFT);
 904                 break;
 905         case CS43130_XSP_DOP_DAI:
 906                 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_2,
 907                                    CS43130_DSD_SRC_MASK, CS43130_DSD_SRC_XSP <<
 908                                    CS43130_DSD_SRC_SHIFT);
 909                 break;
 910         }
 911
 912         if (!sclk && cs43130->dais[dai->id].dai_mode == SND_SOC_DAIFMT_CBM_CFM)
 913                 /* Calculate SCLK in master mode if unassigned */
 914                 sclk = params_rate(params) * bitwidth_dai *
 915                        params_channels(params);
 916
 917         if (!sclk) {
 918                 /* at this point, SCLK must be set */
 919                 dev_err(component->dev, "SCLK freq is not set\n");
 920                 return -EINVAL;
 921         }
 922
 923         bitwidth_sclk = (sclk / params_rate(params)) / params_channels(params);
 924         if (bitwidth_sclk < bitwidth_dai) {
 925                 dev_err(component->dev, "Format not supported: SCLK freq is too low\n");
 926                 return -EINVAL;
 927         }
 928
 929         dev_dbg(component->dev,
 930                 "sclk = %u, fs = %d, bitwidth_dai = %u\n",
 931                 sclk, params_rate(params), bitwidth_dai);
 932
 933         dev_dbg(component->dev,
 934                 "bitwidth_sclk = %u, num_ch = %u\n",
 935                 bitwidth_sclk, params_channels(params));
 936
 937         cs43130_set_bitwidth(dai->id, bitwidth_dai, cs43130->regmap);
 938         cs43130_set_sp_fmt(dai->id, bitwidth_sclk, params, cs43130);
 939
 940         return 0;
 941 }
 942
 943 static int cs43130_hw_free(struct snd_pcm_substream *substream,
 944                            struct snd_soc_dai *dai)
 945 {
 946         struct snd_soc_component *component = dai->component;
 947         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
 948
 949         mutex_lock(&cs43130->clk_mutex);
 950         cs43130->clk_req--;
 951         if (!cs43130->clk_req) {
 952                 /* no DAI is currently using clk */
 953                 cs43130_change_clksrc(component, CS43130_MCLK_SRC_RCO);
 954                 cs43130_pcm_dsd_mix(false, cs43130->regmap);
 955         }
 956         mutex_unlock(&cs43130->clk_mutex);
 957
 958         return 0;
 959 }
 960
 961 static const DECLARE_TLV_DB_SCALE(pcm_vol_tlv, -12750, 50, 1);
 962
 963 static const char * const pcm_ch_text[] = {
 964         "Left-Right Ch",
 965         "Left-Left Ch",
 966         "Right-Left Ch",
 967         "Right-Right Ch",
 968 };
 969
 970 static const struct reg_sequence pcm_ch_en_seq[] = {
 971         {CS43130_DXD1, 0x99},
 972         {0x180005, 0x8C},
 973         {0x180007, 0xAB},
 974         {0x180015, 0x31},
 975         {0x180017, 0xB2},
 976         {0x180025, 0x30},
 977         {0x180027, 0x84},
 978         {0x180035, 0x9C},
 979         {0x180037, 0xAE},
 980         {0x18000D, 0x24},
 981         {0x18000F, 0xA3},
 982         {0x18001D, 0x05},
 983         {0x18001F, 0xD4},
 984         {0x18002D, 0x0B},
 985         {0x18002F, 0xC7},
 986         {0x18003D, 0x71},
 987         {0x18003F, 0xE7},
 988         {CS43130_DXD1, 0},
 989 };
 990
 991 static const struct reg_sequence pcm_ch_dis_seq[] = {
 992         {CS43130_DXD1, 0x99},
 993         {0x180005, 0x24},
 994         {0x180007, 0xA3},
 995         {0x180015, 0x05},
 996         {0x180017, 0xD4},
 997         {0x180025, 0x0B},
 998         {0x180027, 0xC7},
 999         {0x180035, 0x71},
1000         {0x180037, 0xE7},
1001         {0x18000D, 0x8C},
1002         {0x18000F, 0xAB},
1003         {0x18001D, 0x31},
1004         {0x18001F, 0xB2},
1005         {0x18002D, 0x30},
1006         {0x18002F, 0x84},
1007         {0x18003D, 0x9C},
1008         {0x18003F, 0xAE},
1009         {CS43130_DXD1, 0},
1010 };
1011
1012 static int cs43130_pcm_ch_get(struct snd_kcontrol *kcontrol,
1013                               struct snd_ctl_elem_value *ucontrol)
1014 {
1015         return snd_soc_get_enum_double(kcontrol, ucontrol);
1016 }
1017
1018 static int cs43130_pcm_ch_put(struct snd_kcontrol *kcontrol,
1019                               struct snd_ctl_elem_value *ucontrol)
1020 {
1021         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1022         unsigned int *item = ucontrol->value.enumerated.item;
1023         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1024         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1025         unsigned int val;
1026
1027         if (item[0] >= e->items)
1028                 return -EINVAL;
1029         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
1030
1031         switch (cs43130->dev_id) {
1032         case CS43131_CHIP_ID:
1033         case CS43198_CHIP_ID:
1034                 if (val >= 2)
1035                         regmap_multi_reg_write(cs43130->regmap, pcm_ch_en_seq,
1036                                                ARRAY_SIZE(pcm_ch_en_seq));
1037                 else
1038                         regmap_multi_reg_write(cs43130->regmap, pcm_ch_dis_seq,
1039                                                ARRAY_SIZE(pcm_ch_dis_seq));
1040                 break;
1041         }
1042
1043         return snd_soc_put_enum_double(kcontrol, ucontrol);
1044 }
1045
1046 static SOC_ENUM_SINGLE_DECL(pcm_ch_enum, CS43130_PCM_PATH_CTL_2, 0,
1047                             pcm_ch_text);
1048
1049 static const char * const pcm_spd_texts[] = {
1050         "Fast",
1051         "Slow",
1052 };
1053
1054 static SOC_ENUM_SINGLE_DECL(pcm_spd_enum, CS43130_PCM_FILT_OPT, 7,
1055                             pcm_spd_texts);
1056
1057 static const char * const dsd_texts[] = {
1058         "Off",
1059         "BCKA Mode",
1060         "BCKD Mode",
1061 };
1062
1063 static const unsigned int dsd_values[] = {
1064         CS43130_DSD_SRC_DSD,
1065         CS43130_DSD_SRC_ASP,
1066         CS43130_DSD_SRC_XSP,
1067 };
1068
1069 static SOC_VALUE_ENUM_SINGLE_DECL(dsd_enum, CS43130_DSD_INT_CFG, 0, 0x03,
1070                                   dsd_texts, dsd_values);
1071
1072 static const struct snd_kcontrol_new cs43130_snd_controls[] = {
1073         SOC_DOUBLE_R_TLV("Master Playback Volume",
1074                          CS43130_PCM_VOL_A, CS43130_PCM_VOL_B, 0, 0xFF, 1,
1075                          pcm_vol_tlv),
1076         SOC_DOUBLE_R_TLV("Master DSD Playback Volume",
1077                          CS43130_DSD_VOL_A, CS43130_DSD_VOL_B, 0, 0xFF, 1,
1078                          pcm_vol_tlv),
1079         SOC_ENUM_EXT("PCM Ch Select", pcm_ch_enum, cs43130_pcm_ch_get,
1080                      cs43130_pcm_ch_put),
1081         SOC_ENUM("PCM Filter Speed", pcm_spd_enum),
1082         SOC_SINGLE("PCM Phase Compensation", CS43130_PCM_FILT_OPT, 6, 1, 0),
1083         SOC_SINGLE("PCM Nonoversample Emulate", CS43130_PCM_FILT_OPT, 5, 1, 0),
1084         SOC_SINGLE("PCM High-pass Filter", CS43130_PCM_FILT_OPT, 1, 1, 0),
1085         SOC_SINGLE("PCM De-emphasis Filter", CS43130_PCM_FILT_OPT, 0, 1, 0),
1086         SOC_ENUM("DSD Phase Modulation", dsd_enum),
1087 };
1088
1089 static const struct reg_sequence pcm_seq[] = {
1090         {CS43130_DXD1, 0x99},
1091         {CS43130_DXD7, 0x01},
1092         {CS43130_DXD8, 0},
1093         {CS43130_DXD9, 0x01},
1094         {CS43130_DXD3, 0x12},
1095         {CS43130_DXD4, 0},
1096         {CS43130_DXD10, 0x28},
1097         {CS43130_DXD11, 0x28},
1098         {CS43130_DXD1, 0},
1099 };
1100
1101 static const struct reg_sequence dsd_seq[] = {
1102         {CS43130_DXD1, 0x99},
1103         {CS43130_DXD7, 0x01},
1104         {CS43130_DXD8, 0},
1105         {CS43130_DXD9, 0x01},
1106         {CS43130_DXD3, 0x12},
1107         {CS43130_DXD4, 0},
1108         {CS43130_DXD10, 0x1E},
1109         {CS43130_DXD11, 0x20},
1110         {CS43130_DXD1, 0},
1111 };
1112
1113 static const struct reg_sequence pop_free_seq[] = {
1114         {CS43130_DXD1, 0x99},
1115         {CS43130_DXD12, 0x0A},
1116         {CS43130_DXD1, 0},
1117 };
1118
1119 static const struct reg_sequence pop_free_seq2[] = {
1120         {CS43130_DXD1, 0x99},
1121         {CS43130_DXD13, 0x20},
1122         {CS43130_DXD1, 0},
1123 };
1124
1125 static const struct reg_sequence mute_seq[] = {
1126         {CS43130_DXD1, 0x99},
1127         {CS43130_DXD3, 0x12},
1128         {CS43130_DXD5, 0x02},
1129         {CS43130_DXD4, 0x12},
1130         {CS43130_DXD1, 0},
1131 };
1132
1133 static const struct reg_sequence unmute_seq[] = {
1134         {CS43130_DXD1, 0x99},
1135         {CS43130_DXD3, 0x10},
1136         {CS43130_DXD5, 0},
1137         {CS43130_DXD4, 0x16},
1138         {CS43130_DXD1, 0},
1139 };
1140
1141 static int cs43130_dsd_event(struct snd_soc_dapm_widget *w,
1142                               struct snd_kcontrol *kcontrol, int event)
1143 {
1144         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1145         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1146
1147         switch (event) {
1148         case SND_SOC_DAPM_PRE_PMU:
1149                 switch (cs43130->dev_id) {
1150                 case CS43130_CHIP_ID:
1151                 case CS4399_CHIP_ID:
1152                         regmap_multi_reg_write(cs43130->regmap, dsd_seq,
1153                                                ARRAY_SIZE(dsd_seq));
1154                         break;
1155                 }
1156                 break;
1157         case SND_SOC_DAPM_POST_PMU:
1158                 regmap_update_bits(cs43130->regmap, CS43130_DSD_PATH_CTL_1,
1159                                    CS43130_MUTE_MASK, 0);
1160                 switch (cs43130->dev_id) {
1161                 case CS43130_CHIP_ID:
1162                 case CS4399_CHIP_ID:
1163                         regmap_multi_reg_write(cs43130->regmap, unmute_seq,
1164                                                ARRAY_SIZE(unmute_seq));
1165                         break;
1166                 }
1167                 break;
1168         case SND_SOC_DAPM_PRE_PMD:
1169                 switch (cs43130->dev_id) {
1170                 case CS43130_CHIP_ID:
1171                 case CS4399_CHIP_ID:
1172                         regmap_multi_reg_write(cs43130->regmap, mute_seq,
1173                                                ARRAY_SIZE(mute_seq));
1174                         regmap_update_bits(cs43130->regmap,
1175                                            CS43130_DSD_PATH_CTL_1,
1176                                            CS43130_MUTE_MASK, CS43130_MUTE_EN);
1177                         /*
1178                          * DSD Power Down Sequence
1179                          * According to Design, 130ms is preferred.
1180                          */
1181                         msleep(130);
1182                         break;
1183                 case CS43131_CHIP_ID:
1184                 case CS43198_CHIP_ID:
1185                         regmap_update_bits(cs43130->regmap,
1186                                            CS43130_DSD_PATH_CTL_1,
1187                                            CS43130_MUTE_MASK, CS43130_MUTE_EN);
1188                         break;
1189                 }
1190                 break;
1191         default:
1192                 dev_err(component->dev, "Invalid event = 0x%x\n", event);
1193                 return -EINVAL;
1194         }
1195         return 0;
1196 }
1197
1198 static int cs43130_pcm_event(struct snd_soc_dapm_widget *w,
1199                               struct snd_kcontrol *kcontrol, int event)
1200 {
1201         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1202         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1203
1204         switch (event) {
1205         case SND_SOC_DAPM_PRE_PMU:
1206                 switch (cs43130->dev_id) {
1207                 case CS43130_CHIP_ID:
1208                 case CS4399_CHIP_ID:
1209                         regmap_multi_reg_write(cs43130->regmap, pcm_seq,
1210                                                ARRAY_SIZE(pcm_seq));
1211                         break;
1212                 }
1213                 break;
1214         case SND_SOC_DAPM_POST_PMU:
1215                 regmap_update_bits(cs43130->regmap, CS43130_PCM_PATH_CTL_1,
1216                                    CS43130_MUTE_MASK, 0);
1217                 switch (cs43130->dev_id) {
1218                 case CS43130_CHIP_ID:
1219                 case CS4399_CHIP_ID:
1220                         regmap_multi_reg_write(cs43130->regmap, unmute_seq,
1221                                                ARRAY_SIZE(unmute_seq));
1222                         break;
1223                 }
1224                 break;
1225         case SND_SOC_DAPM_PRE_PMD:
1226                 switch (cs43130->dev_id) {
1227                 case CS43130_CHIP_ID:
1228                 case CS4399_CHIP_ID:
1229                         regmap_multi_reg_write(cs43130->regmap, mute_seq,
1230                                                ARRAY_SIZE(mute_seq));
1231                         regmap_update_bits(cs43130->regmap,
1232                                            CS43130_PCM_PATH_CTL_1,
1233                                            CS43130_MUTE_MASK, CS43130_MUTE_EN);
1234                         /*
1235                          * PCM Power Down Sequence
1236                          * According to Design, 130ms is preferred.
1237                          */
1238                         msleep(130);
1239                         break;
1240                 case CS43131_CHIP_ID:
1241                 case CS43198_CHIP_ID:
1242                         regmap_update_bits(cs43130->regmap,
1243                                            CS43130_PCM_PATH_CTL_1,
1244                                            CS43130_MUTE_MASK, CS43130_MUTE_EN);
1245                         break;
1246                 }
1247                 break;
1248         default:
1249                 dev_err(component->dev, "Invalid event = 0x%x\n", event);
1250                 return -EINVAL;
1251         }
1252         return 0;
1253 }
1254
1255 static const struct reg_sequence dac_postpmu_seq[] = {
1256         {CS43130_DXD9, 0x0C},
1257         {CS43130_DXD3, 0x10},
1258         {CS43130_DXD4, 0x20},
1259 };
1260
1261 static const struct reg_sequence dac_postpmd_seq[] = {
1262         {CS43130_DXD1, 0x99},
1263         {CS43130_DXD6, 0x01},
1264         {CS43130_DXD1, 0},
1265 };
1266
1267 static int cs43130_dac_event(struct snd_soc_dapm_widget *w,
1268                              struct snd_kcontrol *kcontrol, int event)
1269 {
1270         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1271         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1272
1273         switch (event) {
1274         case SND_SOC_DAPM_PRE_PMU:
1275                 switch (cs43130->dev_id) {
1276                 case CS43130_CHIP_ID:
1277                 case CS4399_CHIP_ID:
1278                         regmap_multi_reg_write(cs43130->regmap, pop_free_seq,
1279                                                ARRAY_SIZE(pop_free_seq));
1280                         break;
1281                 case CS43131_CHIP_ID:
1282                 case CS43198_CHIP_ID:
1283                         regmap_multi_reg_write(cs43130->regmap, pop_free_seq2,
1284                                                ARRAY_SIZE(pop_free_seq2));
1285                         break;
1286                 }
1287                 break;
1288         case SND_SOC_DAPM_POST_PMU:
1289                 usleep_range(10000, 10050);
1290
1291                 regmap_write(cs43130->regmap, CS43130_DXD1, 0x99);
1292
1293                 switch (cs43130->dev_id) {
1294                 case CS43130_CHIP_ID:
1295                 case CS4399_CHIP_ID:
1296                         regmap_multi_reg_write(cs43130->regmap, dac_postpmu_seq,
1297                                                ARRAY_SIZE(dac_postpmu_seq));
1298                         /*
1299                          * Per datasheet, Sec. PCM Power-Up Sequence.
1300                          * According to Design, CS43130_DXD12 must be 0 to meet
1301                          * THDN and Dynamic Range spec.
1302                          */
1303                         msleep(1000);
1304                         regmap_write(cs43130->regmap, CS43130_DXD12, 0);
1305                         break;
1306                 case CS43131_CHIP_ID:
1307                 case CS43198_CHIP_ID:
1308                         usleep_range(12000, 12010);
1309                         regmap_write(cs43130->regmap, CS43130_DXD13, 0);
1310                         break;
1311                 }
1312
1313                 regmap_write(cs43130->regmap, CS43130_DXD1, 0);
1314                 break;
1315         case SND_SOC_DAPM_POST_PMD:
1316                 switch (cs43130->dev_id) {
1317                 case CS43130_CHIP_ID:
1318                 case CS4399_CHIP_ID:
1319                         regmap_multi_reg_write(cs43130->regmap, dac_postpmd_seq,
1320                                                ARRAY_SIZE(dac_postpmd_seq));
1321                         break;
1322                 }
1323                 break;
1324         default:
1325                 dev_err(component->dev, "Invalid DAC event = 0x%x\n", event);
1326                 return -EINVAL;
1327         }
1328         return 0;
1329 }
1330
1331 static const struct reg_sequence hpin_prepmd_seq[] = {
1332         {CS43130_DXD1, 0x99},
1333         {CS43130_DXD15, 0x64},
1334         {CS43130_DXD14, 0},
1335         {CS43130_DXD2, 0},
1336         {CS43130_DXD1, 0},
1337 };
1338
1339 static const struct reg_sequence hpin_postpmu_seq[] = {
1340         {CS43130_DXD1, 0x99},
1341         {CS43130_DXD2, 1},
1342         {CS43130_DXD14, 0xDC},
1343         {CS43130_DXD15, 0xE4},
1344         {CS43130_DXD1, 0},
1345 };
1346
1347 static int cs43130_hpin_event(struct snd_soc_dapm_widget *w,
1348                               struct snd_kcontrol *kcontrol, int event)
1349 {
1350         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1351         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1352
1353         switch (event) {
1354         case SND_SOC_DAPM_POST_PMD:
1355                 regmap_multi_reg_write(cs43130->regmap, hpin_prepmd_seq,
1356                                        ARRAY_SIZE(hpin_prepmd_seq));
1357                 break;
1358         case SND_SOC_DAPM_PRE_PMU:
1359                 regmap_multi_reg_write(cs43130->regmap, hpin_postpmu_seq,
1360                                        ARRAY_SIZE(hpin_postpmu_seq));
1361                 break;
1362         default:
1363                 dev_err(component->dev, "Invalid HPIN event = 0x%x\n", event);
1364                 return -EINVAL;
1365         }
1366         return 0;
1367 }
1368
1369 static const struct snd_soc_dapm_widget digital_hp_widgets[] = {
1370         SND_SOC_DAPM_OUTPUT("HPOUTA"),
1371         SND_SOC_DAPM_OUTPUT("HPOUTB"),
1372
1373         SND_SOC_DAPM_AIF_IN_E("ASPIN PCM", NULL, 0, CS43130_PWDN_CTL,
1374                               CS43130_PDN_ASP_SHIFT, 1, cs43130_pcm_event,
1375                               (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1376                                SND_SOC_DAPM_PRE_PMD)),
1377
1378         SND_SOC_DAPM_AIF_IN_E("ASPIN DoP", NULL, 0, CS43130_PWDN_CTL,
1379                               CS43130_PDN_ASP_SHIFT, 1, cs43130_dsd_event,
1380                               (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1381                                SND_SOC_DAPM_PRE_PMD)),
1382
1383         SND_SOC_DAPM_AIF_IN_E("XSPIN DoP", NULL, 0, CS43130_PWDN_CTL,
1384                               CS43130_PDN_XSP_SHIFT, 1, cs43130_dsd_event,
1385                               (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1386                                SND_SOC_DAPM_PRE_PMD)),
1387
1388         SND_SOC_DAPM_AIF_IN_E("XSPIN DSD", NULL, 0, CS43130_PWDN_CTL,
1389                               CS43130_PDN_DSDIF_SHIFT, 1, cs43130_dsd_event,
1390                               (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1391                                SND_SOC_DAPM_PRE_PMD)),
1392
1393         SND_SOC_DAPM_DAC("DSD", NULL, CS43130_DSD_PATH_CTL_2,
1394                          CS43130_DSD_EN_SHIFT, 0),
1395
1396         SND_SOC_DAPM_DAC_E("HiFi DAC", NULL, CS43130_PWDN_CTL,
1397                            CS43130_PDN_HP_SHIFT, 1, cs43130_dac_event,
1398                            (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1399                             SND_SOC_DAPM_POST_PMD)),
1400 };
1401
1402 static const struct snd_soc_dapm_widget analog_hp_widgets[] = {
1403         SND_SOC_DAPM_DAC_E("Analog Playback", NULL, CS43130_HP_OUT_CTL_1,
1404                            CS43130_HP_IN_EN_SHIFT, 0, cs43130_hpin_event,
1405                            (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD)),
1406 };
1407
1408 static struct snd_soc_dapm_widget all_hp_widgets[
1409                         ARRAY_SIZE(digital_hp_widgets) +
1410                         ARRAY_SIZE(analog_hp_widgets)];
1411
1412 static const struct snd_soc_dapm_route digital_hp_routes[] = {
1413         {"ASPIN PCM", NULL, "ASP PCM Playback"},
1414         {"ASPIN DoP", NULL, "ASP DoP Playback"},
1415         {"XSPIN DoP", NULL, "XSP DoP Playback"},
1416         {"XSPIN DSD", NULL, "XSP DSD Playback"},
1417         {"DSD", NULL, "ASPIN DoP"},
1418         {"DSD", NULL, "XSPIN DoP"},
1419         {"DSD", NULL, "XSPIN DSD"},
1420         {"HiFi DAC", NULL, "ASPIN PCM"},
1421         {"HiFi DAC", NULL, "DSD"},
1422         {"HPOUTA", NULL, "HiFi DAC"},
1423         {"HPOUTB", NULL, "HiFi DAC"},
1424 };
1425
1426 static const struct snd_soc_dapm_route analog_hp_routes[] = {
1427         {"HPOUTA", NULL, "Analog Playback"},
1428         {"HPOUTB", NULL, "Analog Playback"},
1429 };
1430
1431 static struct snd_soc_dapm_route all_hp_routes[
1432                         ARRAY_SIZE(digital_hp_routes) +
1433                         ARRAY_SIZE(analog_hp_routes)];
1434
1435 static const unsigned int cs43130_asp_src_rates[] = {
1436         32000, 44100, 48000, 88200, 96000, 176400, 192000, 352800, 384000
1437 };
1438
1439 static const struct snd_pcm_hw_constraint_list cs43130_asp_constraints = {
1440         .count  = ARRAY_SIZE(cs43130_asp_src_rates),
1441         .list   = cs43130_asp_src_rates,
1442 };
1443
1444 static int cs43130_pcm_startup(struct snd_pcm_substream *substream,
1445                                struct snd_soc_dai *dai)
1446 {
1447         return snd_pcm_hw_constraint_list(substream->runtime, 0,
1448                                           SNDRV_PCM_HW_PARAM_RATE,
1449                                           &cs43130_asp_constraints);
1450 }
1451
1452 static const unsigned int cs43130_dop_src_rates[] = {
1453         176400, 352800,
1454 };
1455
1456 static const struct snd_pcm_hw_constraint_list cs43130_dop_constraints = {
1457         .count  = ARRAY_SIZE(cs43130_dop_src_rates),
1458         .list   = cs43130_dop_src_rates,
1459 };
1460
1461 static int cs43130_dop_startup(struct snd_pcm_substream *substream,
1462                                struct snd_soc_dai *dai)
1463 {
1464         return snd_pcm_hw_constraint_list(substream->runtime, 0,
1465                                           SNDRV_PCM_HW_PARAM_RATE,
1466                                           &cs43130_dop_constraints);
1467 }
1468
1469 static int cs43130_pcm_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1470 {
1471         struct snd_soc_component *component = codec_dai->component;
1472         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1473
1474         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1475         case SND_SOC_DAIFMT_CBS_CFS:
1476                 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBS_CFS;
1477                 break;
1478         case SND_SOC_DAIFMT_CBM_CFM:
1479                 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBM_CFM;
1480                 break;
1481         default:
1482                 dev_err(component->dev, "unsupported mode\n");
1483                 return -EINVAL;
1484         }
1485
1486         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1487         case SND_SOC_DAIFMT_I2S:
1488                 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_I2S;
1489                 break;
1490         case SND_SOC_DAIFMT_LEFT_J:
1491                 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_LEFT_J;
1492                 break;
1493         case SND_SOC_DAIFMT_DSP_A:
1494                 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_DSP_A;
1495                 break;
1496         case SND_SOC_DAIFMT_DSP_B:
1497                 cs43130->dais[codec_dai->id].dai_format = SND_SOC_DAIFMT_DSP_B;
1498                 break;
1499         default:
1500                 dev_err(component->dev,
1501                         "unsupported audio format\n");
1502                 return -EINVAL;
1503         }
1504
1505         dev_dbg(component->dev, "dai_id = %d,  dai_mode = %u, dai_format = %u\n",
1506                 codec_dai->id,
1507                 cs43130->dais[codec_dai->id].dai_mode,
1508                 cs43130->dais[codec_dai->id].dai_format);
1509
1510         return 0;
1511 }
1512
1513 static int cs43130_dsd_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1514 {
1515         struct snd_soc_component *component = codec_dai->component;
1516         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1517
1518         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1519         case SND_SOC_DAIFMT_CBS_CFS:
1520                 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBS_CFS;
1521                 break;
1522         case SND_SOC_DAIFMT_CBM_CFM:
1523                 cs43130->dais[codec_dai->id].dai_mode = SND_SOC_DAIFMT_CBM_CFM;
1524                 break;
1525         default:
1526                 dev_err(component->dev, "Unsupported DAI format.\n");
1527                 return -EINVAL;
1528         }
1529
1530         dev_dbg(component->dev, "dai_mode = 0x%x\n",
1531                 cs43130->dais[codec_dai->id].dai_mode);
1532
1533         return 0;
1534 }
1535
1536 static int cs43130_set_sysclk(struct snd_soc_dai *codec_dai,
1537                                   int clk_id, unsigned int freq, int dir)
1538 {
1539         struct snd_soc_component *component = codec_dai->component;
1540         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1541
1542         cs43130->dais[codec_dai->id].sclk = freq;
1543         dev_dbg(component->dev, "dai_id = %d,  sclk = %u\n", codec_dai->id,
1544                 cs43130->dais[codec_dai->id].sclk);
1545
1546         return 0;
1547 }
1548
1549 static const struct snd_soc_dai_ops cs43130_pcm_ops = {
1550         .startup        = cs43130_pcm_startup,
1551         .hw_params      = cs43130_hw_params,
1552         .hw_free        = cs43130_hw_free,
1553         .set_sysclk     = cs43130_set_sysclk,
1554         .set_fmt        = cs43130_pcm_set_fmt,
1555 };
1556
1557 static const struct snd_soc_dai_ops cs43130_dop_ops = {
1558         .startup        = cs43130_dop_startup,
1559         .hw_params      = cs43130_hw_params,
1560         .hw_free        = cs43130_hw_free,
1561         .set_sysclk     = cs43130_set_sysclk,
1562         .set_fmt        = cs43130_pcm_set_fmt,
1563 };
1564
1565 static const struct snd_soc_dai_ops cs43130_dsd_ops = {
1566         .startup        = cs43130_dop_startup,
1567         .hw_params      = cs43130_dsd_hw_params,
1568         .hw_free        = cs43130_hw_free,
1569         .set_fmt        = cs43130_dsd_set_fmt,
1570 };
1571
1572 static struct snd_soc_dai_driver cs43130_dai[] = {
1573         {
1574                 .name = "cs43130-asp-pcm",
1575                 .id = CS43130_ASP_PCM_DAI,
1576                 .playback = {
1577                         .stream_name = "ASP PCM Playback",
1578                         .channels_min = 1,
1579                         .channels_max = 2,
1580                         .rates = SNDRV_PCM_RATE_KNOT,
1581                         .formats = CS43130_PCM_FORMATS,
1582                 },
1583                 .ops = &cs43130_pcm_ops,
1584                 .symmetric_rate = 1,
1585         },
1586         {
1587                 .name = "cs43130-asp-dop",
1588                 .id = CS43130_ASP_DOP_DAI,
1589                 .playback = {
1590                         .stream_name = "ASP DoP Playback",
1591                         .channels_min = 1,
1592                         .channels_max = 2,
1593                         .rates = SNDRV_PCM_RATE_KNOT,
1594                         .formats = CS43130_DOP_FORMATS,
1595                 },
1596                 .ops = &cs43130_dop_ops,
1597                 .symmetric_rate = 1,
1598         },
1599         {
1600                 .name = "cs43130-xsp-dop",
1601                 .id = CS43130_XSP_DOP_DAI,
1602                 .playback = {
1603                         .stream_name = "XSP DoP Playback",
1604                         .channels_min = 1,
1605                         .channels_max = 2,
1606                         .rates = SNDRV_PCM_RATE_KNOT,
1607                         .formats = CS43130_DOP_FORMATS,
1608                 },
1609                 .ops = &cs43130_dop_ops,
1610                 .symmetric_rate = 1,
1611         },
1612         {
1613                 .name = "cs43130-xsp-dsd",
1614                 .id = CS43130_XSP_DSD_DAI,
1615                 .playback = {
1616                         .stream_name = "XSP DSD Playback",
1617                         .channels_min = 1,
1618                         .channels_max = 2,
1619                         .rates = SNDRV_PCM_RATE_KNOT,
1620                         .formats = CS43130_DOP_FORMATS,
1621                 },
1622                 .ops = &cs43130_dsd_ops,
1623         },
1624
1625 };
1626
1627 static int cs43130_component_set_sysclk(struct snd_soc_component *component,
1628                                     int clk_id, int source, unsigned int freq,
1629                                     int dir)
1630 {
1631         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
1632
1633         dev_dbg(component->dev, "clk_id = %d, source = %d, freq = %d, dir = %d\n",
1634                 clk_id, source, freq, dir);
1635
1636         switch (freq) {
1637         case CS43130_MCLK_22M:
1638         case CS43130_MCLK_24M:
1639                 cs43130->mclk = freq;
1640                 break;
1641         default:
1642                 dev_err(component->dev, "Invalid MCLK INT freq: %u\n", freq);
1643                 return -EINVAL;
1644         }
1645
1646         if (source == CS43130_MCLK_SRC_EXT) {
1647                 cs43130->pll_bypass = true;
1648         } else {
1649                 dev_err(component->dev, "Invalid MCLK source\n");
1650                 return -EINVAL;
1651         }
1652
1653         return 0;
1654 }
1655
1656 static inline u16 cs43130_get_ac_reg_val(u16 ac_freq)
1657 {
1658         /* AC freq is counted in 5.94Hz step. */
1659         return ac_freq / 6;
1660 }
1661
1662 static int cs43130_show_dc(struct device *dev, char *buf, u8 ch)
1663 {
1664         struct i2c_client *client = to_i2c_client(dev);
1665         struct cs43130_private *cs43130 = i2c_get_clientdata(client);
1666
1667         if (!cs43130->hpload_done)
1668                 return scnprintf(buf, PAGE_SIZE, "NO_HPLOAD\n");
1669         else
1670                 return scnprintf(buf, PAGE_SIZE, "%u\n",
1671                                  cs43130->hpload_dc[ch]);
1672 }
1673
1674 static ssize_t cs43130_show_dc_l(struct device *dev,
1675                                  struct device_attribute *attr, char *buf)
1676 {
1677         return cs43130_show_dc(dev, buf, HP_LEFT);
1678 }
1679
1680 static ssize_t cs43130_show_dc_r(struct device *dev,
1681                                  struct device_attribute *attr, char *buf)
1682 {
1683         return cs43130_show_dc(dev, buf, HP_RIGHT);
1684 }
1685
1686 static u16 const cs43130_ac_freq[CS43130_AC_FREQ] = {
1687         24,
1688         43,
1689         93,
1690         200,
1691         431,
1692         928,
1693         2000,
1694         4309,
1695         9283,
1696         20000,
1697 };
1698
1699 static int cs43130_show_ac(struct device *dev, char *buf, u8 ch)
1700 {
1701         int i, j = 0, tmp;
1702         struct i2c_client *client = to_i2c_client(dev);
1703         struct cs43130_private *cs43130 = i2c_get_clientdata(client);
1704
1705         if (cs43130->hpload_done && cs43130->ac_meas) {
1706                 for (i = 0; i < ARRAY_SIZE(cs43130_ac_freq); i++) {
1707                         tmp = scnprintf(buf + j, PAGE_SIZE - j, "%u\n",
1708                                         cs43130->hpload_ac[i][ch]);
1709                         if (!tmp)
1710                                 break;
1711
1712                         j += tmp;
1713                 }
1714
1715                 return j;
1716         } else {
1717                 return scnprintf(buf, PAGE_SIZE, "NO_HPLOAD\n");
1718         }
1719 }
1720
1721 static ssize_t cs43130_show_ac_l(struct device *dev,
1722                                  struct device_attribute *attr, char *buf)
1723 {
1724         return cs43130_show_ac(dev, buf, HP_LEFT);
1725 }
1726
1727 static ssize_t cs43130_show_ac_r(struct device *dev,
1728                                  struct device_attribute *attr, char *buf)
1729 {
1730         return cs43130_show_ac(dev, buf, HP_RIGHT);
1731 }
1732
1733 static DEVICE_ATTR(hpload_dc_l, 0444, cs43130_show_dc_l, NULL);
1734 static DEVICE_ATTR(hpload_dc_r, 0444, cs43130_show_dc_r, NULL);
1735 static DEVICE_ATTR(hpload_ac_l, 0444, cs43130_show_ac_l, NULL);
1736 static DEVICE_ATTR(hpload_ac_r, 0444, cs43130_show_ac_r, NULL);
1737
1738 static struct reg_sequence hp_en_cal_seq[] = {
1739         {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1740         {CS43130_HP_MEAS_LOAD_1, 0},
1741         {CS43130_HP_MEAS_LOAD_2, 0},
1742         {CS43130_INT_MASK_4, 0},
1743         {CS43130_DXD1, 0x99},
1744         {CS43130_DXD16, 0xBB},
1745         {CS43130_DXD12, 0x01},
1746         {CS43130_DXD19, 0xCB},
1747         {CS43130_DXD17, 0x95},
1748         {CS43130_DXD18, 0x0B},
1749         {CS43130_DXD1, 0},
1750         {CS43130_HP_LOAD_1, 0x80},
1751 };
1752
1753 static struct reg_sequence hp_en_cal_seq2[] = {
1754         {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1755         {CS43130_HP_MEAS_LOAD_1, 0},
1756         {CS43130_HP_MEAS_LOAD_2, 0},
1757         {CS43130_INT_MASK_4, 0},
1758         {CS43130_HP_LOAD_1, 0x80},
1759 };
1760
1761 static struct reg_sequence hp_dis_cal_seq[] = {
1762         {CS43130_HP_LOAD_1, 0x80},
1763         {CS43130_DXD1, 0x99},
1764         {CS43130_DXD12, 0},
1765         {CS43130_DXD1, 0},
1766         {CS43130_HP_LOAD_1, 0},
1767 };
1768
1769 static struct reg_sequence hp_dis_cal_seq2[] = {
1770         {CS43130_HP_LOAD_1, 0x80},
1771         {CS43130_HP_LOAD_1, 0},
1772 };
1773
1774 static struct reg_sequence hp_dc_ch_l_seq[] = {
1775         {CS43130_DXD1, 0x99},
1776         {CS43130_DXD19, 0x0A},
1777         {CS43130_DXD17, 0x93},
1778         {CS43130_DXD18, 0x0A},
1779         {CS43130_DXD1, 0},
1780         {CS43130_HP_LOAD_1, 0x80},
1781         {CS43130_HP_LOAD_1, 0x81},
1782 };
1783
1784 static struct reg_sequence hp_dc_ch_l_seq2[] = {
1785         {CS43130_HP_LOAD_1, 0x80},
1786         {CS43130_HP_LOAD_1, 0x81},
1787 };
1788
1789 static struct reg_sequence hp_dc_ch_r_seq[] = {
1790         {CS43130_DXD1, 0x99},
1791         {CS43130_DXD19, 0x8A},
1792         {CS43130_DXD17, 0x15},
1793         {CS43130_DXD18, 0x06},
1794         {CS43130_DXD1, 0},
1795         {CS43130_HP_LOAD_1, 0x90},
1796         {CS43130_HP_LOAD_1, 0x91},
1797 };
1798
1799 static struct reg_sequence hp_dc_ch_r_seq2[] = {
1800         {CS43130_HP_LOAD_1, 0x90},
1801         {CS43130_HP_LOAD_1, 0x91},
1802 };
1803
1804 static struct reg_sequence hp_ac_ch_l_seq[] = {
1805         {CS43130_DXD1, 0x99},
1806         {CS43130_DXD19, 0x0A},
1807         {CS43130_DXD17, 0x93},
1808         {CS43130_DXD18, 0x0A},
1809         {CS43130_DXD1, 0},
1810         {CS43130_HP_LOAD_1, 0x80},
1811         {CS43130_HP_LOAD_1, 0x82},
1812 };
1813
1814 static struct reg_sequence hp_ac_ch_l_seq2[] = {
1815         {CS43130_HP_LOAD_1, 0x80},
1816         {CS43130_HP_LOAD_1, 0x82},
1817 };
1818
1819 static struct reg_sequence hp_ac_ch_r_seq[] = {
1820         {CS43130_DXD1, 0x99},
1821         {CS43130_DXD19, 0x8A},
1822         {CS43130_DXD17, 0x15},
1823         {CS43130_DXD18, 0x06},
1824         {CS43130_DXD1, 0},
1825         {CS43130_HP_LOAD_1, 0x90},
1826         {CS43130_HP_LOAD_1, 0x92},
1827 };
1828
1829 static struct reg_sequence hp_ac_ch_r_seq2[] = {
1830         {CS43130_HP_LOAD_1, 0x90},
1831         {CS43130_HP_LOAD_1, 0x92},
1832 };
1833
1834 static struct reg_sequence hp_cln_seq[] = {
1835         {CS43130_INT_MASK_4, CS43130_INT_MASK_ALL},
1836         {CS43130_HP_MEAS_LOAD_1, 0},
1837         {CS43130_HP_MEAS_LOAD_2, 0},
1838 };
1839
1840 struct reg_sequences {
1841         struct reg_sequence     *seq;
1842         int                     size;
1843         unsigned int            msk;
1844 };
1845
1846 static struct reg_sequences hpload_seq1[] = {
1847         {
1848                 .seq    = hp_en_cal_seq,
1849                 .size   = ARRAY_SIZE(hp_en_cal_seq),
1850                 .msk    = CS43130_HPLOAD_ON_INT,
1851         },
1852         {
1853                 .seq    = hp_dc_ch_l_seq,
1854                 .size   = ARRAY_SIZE(hp_dc_ch_l_seq),
1855                 .msk    = CS43130_HPLOAD_DC_INT,
1856         },
1857         {
1858                 .seq    = hp_ac_ch_l_seq,
1859                 .size   = ARRAY_SIZE(hp_ac_ch_l_seq),
1860                 .msk    = CS43130_HPLOAD_AC_INT,
1861         },
1862         {
1863                 .seq    = hp_dis_cal_seq,
1864                 .size   = ARRAY_SIZE(hp_dis_cal_seq),
1865                 .msk    = CS43130_HPLOAD_OFF_INT,
1866         },
1867         {
1868                 .seq    = hp_en_cal_seq,
1869                 .size   = ARRAY_SIZE(hp_en_cal_seq),
1870                 .msk    = CS43130_HPLOAD_ON_INT,
1871         },
1872         {
1873                 .seq    = hp_dc_ch_r_seq,
1874                 .size   = ARRAY_SIZE(hp_dc_ch_r_seq),
1875                 .msk    = CS43130_HPLOAD_DC_INT,
1876         },
1877         {
1878                 .seq    = hp_ac_ch_r_seq,
1879                 .size   = ARRAY_SIZE(hp_ac_ch_r_seq),
1880                 .msk    = CS43130_HPLOAD_AC_INT,
1881         },
1882 };
1883
1884 static struct reg_sequences hpload_seq2[] = {
1885         {
1886                 .seq    = hp_en_cal_seq2,
1887                 .size   = ARRAY_SIZE(hp_en_cal_seq2),
1888                 .msk    = CS43130_HPLOAD_ON_INT,
1889         },
1890         {
1891                 .seq    = hp_dc_ch_l_seq2,
1892                 .size   = ARRAY_SIZE(hp_dc_ch_l_seq2),
1893                 .msk    = CS43130_HPLOAD_DC_INT,
1894         },
1895         {
1896                 .seq    = hp_ac_ch_l_seq2,
1897                 .size   = ARRAY_SIZE(hp_ac_ch_l_seq2),
1898                 .msk    = CS43130_HPLOAD_AC_INT,
1899         },
1900         {
1901                 .seq    = hp_dis_cal_seq2,
1902                 .size   = ARRAY_SIZE(hp_dis_cal_seq2),
1903                 .msk    = CS43130_HPLOAD_OFF_INT,
1904         },
1905         {
1906                 .seq    = hp_en_cal_seq2,
1907                 .size   = ARRAY_SIZE(hp_en_cal_seq2),
1908                 .msk    = CS43130_HPLOAD_ON_INT,
1909         },
1910         {
1911                 .seq    = hp_dc_ch_r_seq2,
1912                 .size   = ARRAY_SIZE(hp_dc_ch_r_seq2),
1913                 .msk    = CS43130_HPLOAD_DC_INT,
1914         },
1915         {
1916                 .seq    = hp_ac_ch_r_seq2,
1917                 .size   = ARRAY_SIZE(hp_ac_ch_r_seq2),
1918                 .msk    = CS43130_HPLOAD_AC_INT,
1919         },
1920 };
1921
1922 static int cs43130_update_hpload(unsigned int msk, int ac_idx,
1923                                  struct cs43130_private *cs43130)
1924 {
1925         bool left_ch = true;
1926         unsigned int reg;
1927         u32 addr;
1928         u16 impedance;
1929         struct snd_soc_component *component = cs43130->component;
1930
1931         switch (msk) {
1932         case CS43130_HPLOAD_DC_INT:
1933         case CS43130_HPLOAD_AC_INT:
1934                 break;
1935         default:
1936                 return 0;
1937         }
1938
1939         regmap_read(cs43130->regmap, CS43130_HP_LOAD_1, &reg);
1940         if (reg & CS43130_HPLOAD_CHN_SEL)
1941                 left_ch = false;
1942
1943         if (msk == CS43130_HPLOAD_DC_INT)
1944                 addr = CS43130_HP_DC_STAT_1;
1945         else
1946                 addr = CS43130_HP_AC_STAT_1;
1947
1948         regmap_read(cs43130->regmap, addr, &reg);
1949         impedance = reg >> 3;
1950         regmap_read(cs43130->regmap, addr + 1, &reg);
1951         impedance |= reg << 5;
1952
1953         if (msk == CS43130_HPLOAD_DC_INT) {
1954                 if (left_ch)
1955                         cs43130->hpload_dc[HP_LEFT] = impedance;
1956                 else
1957                         cs43130->hpload_dc[HP_RIGHT] = impedance;
1958
1959                 dev_dbg(component->dev, "HP DC impedance (Ch %u): %u\n", !left_ch,
1960                         impedance);
1961         } else {
1962                 if (left_ch)
1963                         cs43130->hpload_ac[ac_idx][HP_LEFT] = impedance;
1964                 else
1965                         cs43130->hpload_ac[ac_idx][HP_RIGHT] = impedance;
1966
1967                 dev_dbg(component->dev, "HP AC (%u Hz) impedance (Ch %u): %u\n",
1968                         cs43130->ac_freq[ac_idx], !left_ch, impedance);
1969         }
1970
1971         return 0;
1972 }
1973
1974 static int cs43130_hpload_proc(struct cs43130_private *cs43130,
1975                                struct reg_sequence *seq, int seq_size,
1976                                unsigned int rslt_msk, int ac_idx)
1977 {
1978         int ret;
1979         unsigned int msk;
1980         u16 ac_reg_val;
1981         struct snd_soc_component *component = cs43130->component;
1982
1983         reinit_completion(&cs43130->hpload_evt);
1984
1985         if (rslt_msk == CS43130_HPLOAD_AC_INT) {
1986                 ac_reg_val = cs43130_get_ac_reg_val(cs43130->ac_freq[ac_idx]);
1987                 regmap_update_bits(cs43130->regmap, CS43130_HP_LOAD_1,
1988                                    CS43130_HPLOAD_AC_START, 0);
1989                 regmap_update_bits(cs43130->regmap, CS43130_HP_MEAS_LOAD_1,
1990                                    CS43130_HP_MEAS_LOAD_MASK,
1991                                    ac_reg_val >> CS43130_HP_MEAS_LOAD_1_SHIFT);
1992                 regmap_update_bits(cs43130->regmap, CS43130_HP_MEAS_LOAD_2,
1993                                    CS43130_HP_MEAS_LOAD_MASK,
1994                                    ac_reg_val >> CS43130_HP_MEAS_LOAD_2_SHIFT);
1995         }
1996
1997         regmap_multi_reg_write(cs43130->regmap, seq,
1998                                seq_size);
1999
2000         ret = wait_for_completion_timeout(&cs43130->hpload_evt,
2001                                           msecs_to_jiffies(1000));
2002         regmap_read(cs43130->regmap, CS43130_INT_MASK_4, &msk);
2003         if (!ret) {
2004                 dev_err(component->dev, "Timeout waiting for HPLOAD interrupt\n");
2005                 return -1;
2006         }
2007
2008         dev_dbg(component->dev, "HP load stat: %x, INT_MASK_4: %x\n",
2009                 cs43130->hpload_stat, msk);
2010         if ((cs43130->hpload_stat & (CS43130_HPLOAD_NO_DC_INT |
2011                                      CS43130_HPLOAD_UNPLUG_INT |
2012                                      CS43130_HPLOAD_OOR_INT)) ||
2013             !(cs43130->hpload_stat & rslt_msk)) {
2014                 dev_dbg(component->dev, "HP load measure failed\n");
2015                 return -1;
2016         }
2017
2018         return 0;
2019 }
2020
2021 static const struct reg_sequence hv_seq[][2] = {
2022         {
2023                 {CS43130_CLASS_H_CTL, 0x1C},
2024                 {CS43130_HP_OUT_CTL_1, 0x10},
2025         },
2026         {
2027                 {CS43130_CLASS_H_CTL, 0x1E},
2028                 {CS43130_HP_OUT_CTL_1, 0x20},
2029         },
2030         {
2031                 {CS43130_CLASS_H_CTL, 0x1E},
2032                 {CS43130_HP_OUT_CTL_1, 0x30},
2033         },
2034 };
2035
2036 static int cs43130_set_hv(struct regmap *regmap, u16 hpload_dc,
2037                           const u16 *dc_threshold)
2038 {
2039         int i;
2040
2041         for (i = 0; i < CS43130_DC_THRESHOLD; i++) {
2042                 if (hpload_dc <= dc_threshold[i])
2043                         break;
2044         }
2045
2046         regmap_multi_reg_write(regmap, hv_seq[i], ARRAY_SIZE(hv_seq[i]));
2047
2048         return 0;
2049 }
2050
2051 static void cs43130_imp_meas(struct work_struct *wk)
2052 {
2053         unsigned int reg, seq_size;
2054         int i, ret, ac_idx;
2055         struct cs43130_private *cs43130;
2056         struct snd_soc_component *component;
2057         struct reg_sequences *hpload_seq;
2058
2059         cs43130 = container_of(wk, struct cs43130_private, work);
2060         component = cs43130->component;
2061
2062         if (!cs43130->mclk)
2063                 return;
2064
2065         cs43130->hpload_done = false;
2066
2067         mutex_lock(&cs43130->clk_mutex);
2068         if (!cs43130->clk_req) {
2069                 /* clk not in use */
2070                 cs43130_set_pll(component, 0, 0, cs43130->mclk, CS43130_MCLK_22M);
2071                 if (cs43130->pll_bypass)
2072                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_EXT);
2073                 else
2074                         cs43130_change_clksrc(component, CS43130_MCLK_SRC_PLL);
2075         }
2076
2077         cs43130->clk_req++;
2078         mutex_unlock(&cs43130->clk_mutex);
2079
2080         regmap_read(cs43130->regmap, CS43130_INT_STATUS_4, &reg);
2081
2082         switch (cs43130->dev_id) {
2083         case CS43130_CHIP_ID:
2084                 hpload_seq = hpload_seq1;
2085                 seq_size = ARRAY_SIZE(hpload_seq1);
2086                 break;
2087         case CS43131_CHIP_ID:
2088                 hpload_seq = hpload_seq2;
2089                 seq_size = ARRAY_SIZE(hpload_seq2);
2090                 break;
2091         default:
2092                 WARN(1, "Invalid dev_id for meas: %d", cs43130->dev_id);
2093                 return;
2094         }
2095
2096         i = 0;
2097         ac_idx = 0;
2098         while (i < seq_size) {
2099                 ret = cs43130_hpload_proc(cs43130, hpload_seq[i].seq,
2100                                           hpload_seq[i].size,
2101                                           hpload_seq[i].msk, ac_idx);
2102                 if (ret < 0)
2103                         goto exit;
2104
2105                 cs43130_update_hpload(hpload_seq[i].msk, ac_idx, cs43130);
2106
2107                 if (cs43130->ac_meas &&
2108                     hpload_seq[i].msk == CS43130_HPLOAD_AC_INT &&
2109                     ac_idx < CS43130_AC_FREQ - 1) {
2110                         ac_idx++;
2111                 } else {
2112                         ac_idx = 0;
2113                         i++;
2114                 }
2115         }
2116         cs43130->hpload_done = true;
2117
2118         if (cs43130->hpload_dc[HP_LEFT] >= CS43130_LINEOUT_LOAD)
2119                 snd_soc_jack_report(&cs43130->jack, CS43130_JACK_LINEOUT,
2120                                     CS43130_JACK_MASK);
2121         else
2122                 snd_soc_jack_report(&cs43130->jack, CS43130_JACK_HEADPHONE,
2123                                     CS43130_JACK_MASK);
2124
2125         dev_dbg(component->dev, "Set HP output control. DC threshold\n");
2126         for (i = 0; i < CS43130_DC_THRESHOLD; i++)
2127                 dev_dbg(component->dev, "DC threshold[%d]: %u.\n", i,
2128                         cs43130->dc_threshold[i]);
2129
2130         cs43130_set_hv(cs43130->regmap, cs43130->hpload_dc[HP_LEFT],
2131                        cs43130->dc_threshold);
2132
2133 exit:
2134         switch (cs43130->dev_id) {
2135         case CS43130_CHIP_ID:
2136                 cs43130_hpload_proc(cs43130, hp_dis_cal_seq,
2137                                     ARRAY_SIZE(hp_dis_cal_seq),
2138                                     CS43130_HPLOAD_OFF_INT, ac_idx);
2139                 break;
2140         case CS43131_CHIP_ID:
2141                 cs43130_hpload_proc(cs43130, hp_dis_cal_seq2,
2142                                     ARRAY_SIZE(hp_dis_cal_seq2),
2143                                     CS43130_HPLOAD_OFF_INT, ac_idx);
2144                 break;
2145         }
2146
2147         regmap_multi_reg_write(cs43130->regmap, hp_cln_seq,
2148                                ARRAY_SIZE(hp_cln_seq));
2149
2150         mutex_lock(&cs43130->clk_mutex);
2151         cs43130->clk_req--;
2152         /* clk not in use */
2153         if (!cs43130->clk_req)
2154                 cs43130_change_clksrc(component, CS43130_MCLK_SRC_RCO);
2155         mutex_unlock(&cs43130->clk_mutex);
2156 }
2157
2158 static irqreturn_t cs43130_irq_thread(int irq, void *data)
2159 {
2160         struct cs43130_private *cs43130 = (struct cs43130_private *)data;
2161         struct snd_soc_component *component = cs43130->component;
2162         unsigned int stickies[CS43130_NUM_INT];
2163         unsigned int irq_occurrence = 0;
2164         unsigned int masks[CS43130_NUM_INT];
2165         int i, j;
2166
2167         for (i = 0; i < ARRAY_SIZE(stickies); i++) {
2168                 regmap_read(cs43130->regmap, CS43130_INT_STATUS_1 + i,
2169                             &stickies[i]);
2170                 regmap_read(cs43130->regmap, CS43130_INT_MASK_1 + i,
2171                             &masks[i]);
2172         }
2173
2174         for (i = 0; i < ARRAY_SIZE(stickies); i++) {
2175                 stickies[i] = stickies[i] & (~masks[i]);
2176                 for (j = 0; j < 8; j++)
2177                         irq_occurrence += (stickies[i] >> j) & 1;
2178         }
2179         dev_dbg(component->dev, "number of interrupts occurred (%u)\n",
2180                 irq_occurrence);
2181
2182         if (!irq_occurrence)
2183                 return IRQ_NONE;
2184
2185         if (stickies[0] & CS43130_XTAL_RDY_INT) {
2186                 complete(&cs43130->xtal_rdy);
2187                 return IRQ_HANDLED;
2188         }
2189
2190         if (stickies[0] & CS43130_PLL_RDY_INT) {
2191                 complete(&cs43130->pll_rdy);
2192                 return IRQ_HANDLED;
2193         }
2194
2195         if (stickies[3] & CS43130_HPLOAD_NO_DC_INT) {
2196                 cs43130->hpload_stat = stickies[3];
2197                 dev_err(component->dev,
2198                         "DC load has not completed before AC load (%x)\n",
2199                         cs43130->hpload_stat);
2200                 complete(&cs43130->hpload_evt);
2201                 return IRQ_HANDLED;
2202         }
2203
2204         if (stickies[3] & CS43130_HPLOAD_UNPLUG_INT) {
2205                 cs43130->hpload_stat = stickies[3];
2206                 dev_err(component->dev, "HP unplugged during measurement (%x)\n",
2207                         cs43130->hpload_stat);
2208                 complete(&cs43130->hpload_evt);
2209                 return IRQ_HANDLED;
2210         }
2211
2212         if (stickies[3] & CS43130_HPLOAD_OOR_INT) {
2213                 cs43130->hpload_stat = stickies[3];
2214                 dev_err(component->dev, "HP load out of range (%x)\n",
2215                         cs43130->hpload_stat);
2216                 complete(&cs43130->hpload_evt);
2217                 return IRQ_HANDLED;
2218         }
2219
2220         if (stickies[3] & CS43130_HPLOAD_AC_INT) {
2221                 cs43130->hpload_stat = stickies[3];
2222                 dev_dbg(component->dev, "HP AC load measurement done (%x)\n",
2223                         cs43130->hpload_stat);
2224                 complete(&cs43130->hpload_evt);
2225                 return IRQ_HANDLED;
2226         }
2227
2228         if (stickies[3] & CS43130_HPLOAD_DC_INT) {
2229                 cs43130->hpload_stat = stickies[3];
2230                 dev_dbg(component->dev, "HP DC load measurement done (%x)\n",
2231                         cs43130->hpload_stat);
2232                 complete(&cs43130->hpload_evt);
2233                 return IRQ_HANDLED;
2234         }
2235
2236         if (stickies[3] & CS43130_HPLOAD_ON_INT) {
2237                 cs43130->hpload_stat = stickies[3];
2238                 dev_dbg(component->dev, "HP load state machine on done (%x)\n",
2239                         cs43130->hpload_stat);
2240                 complete(&cs43130->hpload_evt);
2241                 return IRQ_HANDLED;
2242         }
2243
2244         if (stickies[3] & CS43130_HPLOAD_OFF_INT) {
2245                 cs43130->hpload_stat = stickies[3];
2246                 dev_dbg(component->dev, "HP load state machine off done (%x)\n",
2247                         cs43130->hpload_stat);
2248                 complete(&cs43130->hpload_evt);
2249                 return IRQ_HANDLED;
2250         }
2251
2252         if (stickies[0] & CS43130_XTAL_ERR_INT) {
2253                 dev_err(component->dev, "Crystal err: clock is not running\n");
2254                 return IRQ_HANDLED;
2255         }
2256
2257         if (stickies[0] & CS43130_HP_UNPLUG_INT) {
2258                 dev_dbg(component->dev, "HP unplugged\n");
2259                 cs43130->hpload_done = false;
2260                 snd_soc_jack_report(&cs43130->jack, 0, CS43130_JACK_MASK);
2261                 return IRQ_HANDLED;
2262         }
2263
2264         if (stickies[0] & CS43130_HP_PLUG_INT) {
2265                 if (cs43130->dc_meas && !cs43130->hpload_done &&
2266                     !work_busy(&cs43130->work)) {
2267                         dev_dbg(component->dev, "HP load queue work\n");
2268                         queue_work(cs43130->wq, &cs43130->work);
2269                 }
2270
2271                 snd_soc_jack_report(&cs43130->jack, SND_JACK_MECHANICAL,
2272                                     CS43130_JACK_MASK);
2273                 return IRQ_HANDLED;
2274         }
2275
2276         return IRQ_NONE;
2277 }
2278
2279 static int cs43130_probe(struct snd_soc_component *component)
2280 {
2281         int ret;
2282         struct cs43130_private *cs43130 = snd_soc_component_get_drvdata(component);
2283         struct snd_soc_card *card = component->card;
2284         unsigned int reg;
2285
2286         cs43130->component = component;
2287
2288         if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED) {
2289                 regmap_update_bits(cs43130->regmap, CS43130_CRYSTAL_SET,
2290                                    CS43130_XTAL_IBIAS_MASK,
2291                                    cs43130->xtal_ibias);
2292                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2293                                    CS43130_XTAL_ERR_INT, 0);
2294         }
2295
2296         ret = snd_soc_card_jack_new(card, "Headphone", CS43130_JACK_MASK,
2297                                     &cs43130->jack, NULL, 0);
2298         if (ret < 0) {
2299                 dev_err(component->dev, "Cannot create jack\n");
2300                 return ret;
2301         }
2302
2303         cs43130->hpload_done = false;
2304         if (cs43130->dc_meas) {
2305                 ret = device_create_file(component->dev, &dev_attr_hpload_dc_l);
2306                 if (ret < 0)
2307                         return ret;
2308
2309                 ret = device_create_file(component->dev, &dev_attr_hpload_dc_r);
2310                 if (ret < 0)
2311                         return ret;
2312
2313                 ret = device_create_file(component->dev, &dev_attr_hpload_ac_l);
2314                 if (ret < 0)
2315                         return ret;
2316
2317                 ret = device_create_file(component->dev, &dev_attr_hpload_ac_r);
2318                 if (ret < 0)
2319                         return ret;
2320
2321                 cs43130->wq = create_singlethread_workqueue("cs43130_hp");
2322                 if (!cs43130->wq)
2323                         return -ENOMEM;
2324                 INIT_WORK(&cs43130->work, cs43130_imp_meas);
2325         }
2326
2327         regmap_read(cs43130->regmap, CS43130_INT_STATUS_1, &reg);
2328         regmap_read(cs43130->regmap, CS43130_HP_STATUS, &reg);
2329         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2330                            CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT, 0);
2331         regmap_update_bits(cs43130->regmap, CS43130_HP_DETECT,
2332                            CS43130_HP_DETECT_CTRL_MASK, 0);
2333         regmap_update_bits(cs43130->regmap, CS43130_HP_DETECT,
2334                            CS43130_HP_DETECT_CTRL_MASK,
2335                            CS43130_HP_DETECT_CTRL_MASK);
2336
2337         return 0;
2338 }
2339
2340 static struct snd_soc_component_driver soc_component_dev_cs43130 = {
2341         .probe                  = cs43130_probe,
2342         .controls               = cs43130_snd_controls,
2343         .num_controls           = ARRAY_SIZE(cs43130_snd_controls),
2344         .set_sysclk             = cs43130_component_set_sysclk,
2345         .set_pll                = cs43130_set_pll,
2346         .idle_bias_on           = 1,
2347         .use_pmdown_time        = 1,
2348         .endianness             = 1,
2349         .non_legacy_dai_naming  = 1,
2350 };
2351
2352 static const struct regmap_config cs43130_regmap = {
2353         .reg_bits               = 24,
2354         .pad_bits               = 8,
2355         .val_bits               = 8,
2356
2357         .max_register           = CS43130_LASTREG,
2358         .reg_defaults           = cs43130_reg_defaults,
2359         .num_reg_defaults       = ARRAY_SIZE(cs43130_reg_defaults),
2360         .readable_reg           = cs43130_readable_register,
2361         .precious_reg           = cs43130_precious_register,
2362         .volatile_reg           = cs43130_volatile_register,
2363         .cache_type             = REGCACHE_RBTREE,
2364         /* needed for regcache_sync */
2365         .use_single_read        = true,
2366         .use_single_write       = true,
2367 };
2368
2369 static u16 const cs43130_dc_threshold[CS43130_DC_THRESHOLD] = {
2370         50,
2371         120,
2372 };
2373
2374 static int cs43130_handle_device_data(struct i2c_client *i2c_client,
2375                                       struct cs43130_private *cs43130)
2376 {
2377         struct device_node *np = i2c_client->dev.of_node;
2378         unsigned int val;
2379         int i;
2380
2381         if (of_property_read_u32(np, "cirrus,xtal-ibias", &val) < 0) {
2382                 /* Crystal is unused. System clock is used for external MCLK */
2383                 cs43130->xtal_ibias = CS43130_XTAL_UNUSED;
2384                 return 0;
2385         }
2386
2387         switch (val) {
2388         case 1:
2389                 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_7_5UA;
2390                 break;
2391         case 2:
2392                 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_12_5UA;
2393                 break;
2394         case 3:
2395                 cs43130->xtal_ibias = CS43130_XTAL_IBIAS_15UA;
2396                 break;
2397         default:
2398                 dev_err(&i2c_client->dev,
2399                         "Invalid cirrus,xtal-ibias value: %d\n", val);
2400                 return -EINVAL;
2401         }
2402
2403         cs43130->dc_meas = of_property_read_bool(np, "cirrus,dc-measure");
2404         cs43130->ac_meas = of_property_read_bool(np, "cirrus,ac-measure");
2405
2406         if (of_property_read_u16_array(np, "cirrus,ac-freq", cs43130->ac_freq,
2407                                         CS43130_AC_FREQ) < 0) {
2408                 for (i = 0; i < CS43130_AC_FREQ; i++)
2409                         cs43130->ac_freq[i] = cs43130_ac_freq[i];
2410         }
2411
2412         if (of_property_read_u16_array(np, "cirrus,dc-threshold",
2413                                        cs43130->dc_threshold,
2414                                        CS43130_DC_THRESHOLD) < 0) {
2415                 for (i = 0; i < CS43130_DC_THRESHOLD; i++)
2416                         cs43130->dc_threshold[i] = cs43130_dc_threshold[i];
2417         }
2418
2419         return 0;
2420 }
2421
2422 static int cs43130_i2c_probe(struct i2c_client *client,
2423                              const struct i2c_device_id *id)
2424 {
2425         struct cs43130_private *cs43130;
2426         int ret;
2427         unsigned int devid = 0;
2428         unsigned int reg;
2429         int i;
2430
2431         cs43130 = devm_kzalloc(&client->dev, sizeof(*cs43130), GFP_KERNEL);
2432         if (!cs43130)
2433                 return -ENOMEM;
2434
2435         i2c_set_clientdata(client, cs43130);
2436
2437         cs43130->regmap = devm_regmap_init_i2c(client, &cs43130_regmap);
2438         if (IS_ERR(cs43130->regmap)) {
2439                 ret = PTR_ERR(cs43130->regmap);
2440                 return ret;
2441         }
2442
2443         if (client->dev.of_node) {
2444                 ret = cs43130_handle_device_data(client, cs43130);
2445                 if (ret != 0)
2446                         return ret;
2447         }
2448         for (i = 0; i < ARRAY_SIZE(cs43130->supplies); i++)
2449                 cs43130->supplies[i].supply = cs43130_supply_names[i];
2450
2451         ret = devm_regulator_bulk_get(&client->dev,
2452                                       ARRAY_SIZE(cs43130->supplies),
2453                                       cs43130->supplies);
2454         if (ret != 0) {
2455                 dev_err(&client->dev, "Failed to request supplies: %d\n", ret);
2456                 return ret;
2457         }
2458         ret = regulator_bulk_enable(ARRAY_SIZE(cs43130->supplies),
2459                                     cs43130->supplies);
2460         if (ret != 0) {
2461                 dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
2462                 return ret;
2463         }
2464
2465         cs43130->reset_gpio = devm_gpiod_get_optional(&client->dev,
2466                                                       "reset", GPIOD_OUT_LOW);
2467         if (IS_ERR(cs43130->reset_gpio))
2468                 return PTR_ERR(cs43130->reset_gpio);
2469
2470         gpiod_set_value_cansleep(cs43130->reset_gpio, 1);
2471
2472         usleep_range(2000, 2050);
2473
2474         ret = regmap_read(cs43130->regmap, CS43130_DEVID_AB, &reg);
2475
2476         devid = (reg & 0xFF) << 12;
2477         ret = regmap_read(cs43130->regmap, CS43130_DEVID_CD, &reg);
2478         devid |= (reg & 0xFF) << 4;
2479         ret = regmap_read(cs43130->regmap, CS43130_DEVID_E, &reg);
2480         devid |= (reg & 0xF0) >> 4;
2481
2482         switch (devid) {
2483         case CS43130_CHIP_ID:
2484         case CS4399_CHIP_ID:
2485         case CS43131_CHIP_ID:
2486         case CS43198_CHIP_ID:
2487                 break;
2488         default:
2489                 dev_err(&client->dev,
2490                         "CS43130 Device ID %X. Expected ID %X, %X, %X or %X\n",
2491                         devid, CS43130_CHIP_ID, CS4399_CHIP_ID,
2492                         CS43131_CHIP_ID, CS43198_CHIP_ID);
2493                 ret = -ENODEV;
2494                 goto err;
2495         }
2496
2497         cs43130->dev_id = devid;
2498         ret = regmap_read(cs43130->regmap, CS43130_REV_ID, &reg);
2499         if (ret < 0) {
2500                 dev_err(&client->dev, "Get Revision ID failed\n");
2501                 goto err;
2502         }
2503
2504         dev_info(&client->dev,
2505                  "Cirrus Logic CS43130 (%x), Revision: %02X\n", devid,
2506                  reg & 0xFF);
2507
2508         mutex_init(&cs43130->clk_mutex);
2509
2510         init_completion(&cs43130->xtal_rdy);
2511         init_completion(&cs43130->pll_rdy);
2512         init_completion(&cs43130->hpload_evt);
2513
2514         ret = devm_request_threaded_irq(&client->dev, client->irq,
2515                                         NULL, cs43130_irq_thread,
2516                                         IRQF_ONESHOT | IRQF_TRIGGER_LOW,
2517                                         "cs43130", cs43130);
2518         if (ret != 0) {
2519                 dev_err(&client->dev, "Failed to request IRQ: %d\n", ret);
2520                 return ret;
2521         }
2522
2523         cs43130->mclk_int_src = CS43130_MCLK_SRC_RCO;
2524
2525         pm_runtime_set_autosuspend_delay(&client->dev, 100);
2526         pm_runtime_use_autosuspend(&client->dev);
2527         pm_runtime_set_active(&client->dev);
2528         pm_runtime_enable(&client->dev);
2529
2530         switch (cs43130->dev_id) {
2531         case CS43130_CHIP_ID:
2532         case CS43131_CHIP_ID:
2533                 memcpy(all_hp_widgets, digital_hp_widgets,
2534                        sizeof(digital_hp_widgets));
2535                 memcpy(all_hp_widgets + ARRAY_SIZE(digital_hp_widgets),
2536                        analog_hp_widgets, sizeof(analog_hp_widgets));
2537                 memcpy(all_hp_routes, digital_hp_routes,
2538                        sizeof(digital_hp_routes));
2539                 memcpy(all_hp_routes + ARRAY_SIZE(digital_hp_routes),
2540                        analog_hp_routes, sizeof(analog_hp_routes));
2541
2542                 soc_component_dev_cs43130.dapm_widgets =
2543                         all_hp_widgets;
2544                 soc_component_dev_cs43130.num_dapm_widgets =
2545                         ARRAY_SIZE(all_hp_widgets);
2546                 soc_component_dev_cs43130.dapm_routes =
2547                         all_hp_routes;
2548                 soc_component_dev_cs43130.num_dapm_routes =
2549                         ARRAY_SIZE(all_hp_routes);
2550                 break;
2551         case CS43198_CHIP_ID:
2552         case CS4399_CHIP_ID:
2553                 soc_component_dev_cs43130.dapm_widgets =
2554                         digital_hp_widgets;
2555                 soc_component_dev_cs43130.num_dapm_widgets =
2556                         ARRAY_SIZE(digital_hp_widgets);
2557                 soc_component_dev_cs43130.dapm_routes =
2558                         digital_hp_routes;
2559                 soc_component_dev_cs43130.num_dapm_routes =
2560                         ARRAY_SIZE(digital_hp_routes);
2561                 break;
2562         }
2563
2564         ret = devm_snd_soc_register_component(&client->dev,
2565                                      &soc_component_dev_cs43130,
2566                                      cs43130_dai, ARRAY_SIZE(cs43130_dai));
2567         if (ret < 0) {
2568                 dev_err(&client->dev,
2569                         "snd_soc_register_component failed with ret = %d\n", ret);
2570                 goto err;
2571         }
2572
2573         regmap_update_bits(cs43130->regmap, CS43130_PAD_INT_CFG,
2574                            CS43130_ASP_3ST_MASK, 0);
2575         regmap_update_bits(cs43130->regmap, CS43130_PAD_INT_CFG,
2576                            CS43130_XSP_3ST_MASK, 0);
2577
2578         return 0;
2579 err:
2580         return ret;
2581 }
2582
2583 static int cs43130_i2c_remove(struct i2c_client *client)
2584 {
2585         struct cs43130_private *cs43130 = i2c_get_clientdata(client);
2586
2587         if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2588                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2589                                    CS43130_XTAL_ERR_INT,
2590                                    1 << CS43130_XTAL_ERR_INT_SHIFT);
2591
2592         regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2593                            CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT,
2594                            CS43130_HP_PLUG_INT | CS43130_HP_UNPLUG_INT);
2595
2596         if (cs43130->dc_meas) {
2597                 cancel_work_sync(&cs43130->work);
2598                 flush_workqueue(cs43130->wq);
2599
2600                 device_remove_file(&client->dev, &dev_attr_hpload_dc_l);
2601                 device_remove_file(&client->dev, &dev_attr_hpload_dc_r);
2602                 device_remove_file(&client->dev, &dev_attr_hpload_ac_l);
2603                 device_remove_file(&client->dev, &dev_attr_hpload_ac_r);
2604         }
2605
2606         gpiod_set_value_cansleep(cs43130->reset_gpio, 0);
2607
2608         pm_runtime_disable(&client->dev);
2609         regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2610
2611         return 0;
2612 }
2613
2614 static int __maybe_unused cs43130_runtime_suspend(struct device *dev)
2615 {
2616         struct cs43130_private *cs43130 = dev_get_drvdata(dev);
2617
2618         if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2619                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2620                                    CS43130_XTAL_ERR_INT,
2621                                    1 << CS43130_XTAL_ERR_INT_SHIFT);
2622
2623         regcache_cache_only(cs43130->regmap, true);
2624         regcache_mark_dirty(cs43130->regmap);
2625
2626         gpiod_set_value_cansleep(cs43130->reset_gpio, 0);
2627
2628         regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2629
2630         return 0;
2631 }
2632
2633 static int __maybe_unused cs43130_runtime_resume(struct device *dev)
2634 {
2635         struct cs43130_private *cs43130 = dev_get_drvdata(dev);
2636         int ret;
2637
2638         ret = regulator_bulk_enable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2639         if (ret != 0) {
2640                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
2641                 return ret;
2642         }
2643
2644         regcache_cache_only(cs43130->regmap, false);
2645
2646         gpiod_set_value_cansleep(cs43130->reset_gpio, 1);
2647
2648         usleep_range(2000, 2050);
2649
2650         ret = regcache_sync(cs43130->regmap);
2651         if (ret != 0) {
2652                 dev_err(dev, "Failed to restore register cache\n");
2653                 goto err;
2654         }
2655
2656         if (cs43130->xtal_ibias != CS43130_XTAL_UNUSED)
2657                 regmap_update_bits(cs43130->regmap, CS43130_INT_MASK_1,
2658                                    CS43130_XTAL_ERR_INT, 0);
2659
2660         return 0;
2661 err:
2662         regcache_cache_only(cs43130->regmap, true);
2663         regulator_bulk_disable(CS43130_NUM_SUPPLIES, cs43130->supplies);
2664
2665         return ret;
2666 }
2667
2668 static const struct dev_pm_ops cs43130_runtime_pm = {
2669         SET_RUNTIME_PM_OPS(cs43130_runtime_suspend, cs43130_runtime_resume,
2670                            NULL)
2671 };
2672
2673 static const struct of_device_id cs43130_of_match[] = {
2674         {.compatible = "cirrus,cs43130",},
2675         {.compatible = "cirrus,cs4399",},
2676         {.compatible = "cirrus,cs43131",},
2677         {.compatible = "cirrus,cs43198",},
2678         {},
2679 };
2680
2681 MODULE_DEVICE_TABLE(of, cs43130_of_match);
2682
2683 static const struct i2c_device_id cs43130_i2c_id[] = {
2684         {"cs43130", 0},
2685         {"cs4399", 0},
2686         {"cs43131", 0},
2687         {"cs43198", 0},
2688         {}
2689 };
2690
2691 MODULE_DEVICE_TABLE(i2c, cs43130_i2c_id);
2692
2693 static struct i2c_driver cs43130_i2c_driver = {
2694         .driver = {
2695                 .name           = "cs43130",
2696                 .of_match_table = cs43130_of_match,
2697                 .pm             = &cs43130_runtime_pm,
2698         },
2699         .id_table       = cs43130_i2c_id,
2700         .probe          = cs43130_i2c_probe,
2701         .remove         = cs43130_i2c_remove,
2702 };
2703
2704 module_i2c_driver(cs43130_i2c_driver);
2705
2706 MODULE_AUTHOR("Li Xu <li.xu@cirrus.com>");
2707 MODULE_DESCRIPTION("Cirrus Logic CS43130 ALSA SoC Codec Driver");
2708 MODULE_LICENSE("GPL");