sound/soc/codecs/ak4613.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // ak4613.c  --  Asahi Kasei ALSA Soc Audio driver
   4 //
   5 // Copyright (C) 2015 Renesas Electronics Corporation
   6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   7 //
   8 // Based on ak4642.c by Kuninori Morimoto
   9 // Based on wm8731.c by Richard Purdie
  10 // Based on ak4535.c by Richard Purdie
  11 // Based on wm8753.c by Liam Girdwood
  12
  13 /*
  14  *              +-------+
  15  *              |AK4613 |
  16  *      SDTO1 <-|       |
  17  *              |       |
  18  *      SDTI1 ->|       |
  19  *      SDTI2 ->|       |
  20  *      SDTI3 ->|       |
  21  *              +-------+
  22  *
  23  *        +---+
  24  * clk    |   |___________________________________________...
  25  *
  26  * [TDM512]
  27  * SDTO1  [L1][R1][L2][R2]
  28  * SDTI1  [L1][R1][L2][R2][L3][R3][L4][R4][L5][R5][L6][R6]
  29  *
  30  * [TDM256]
  31  * SDTO1  [L1][R1][L2][R2]
  32  * SDTI1  [L1][R1][L2][R2][L3][R3][L4][R4]
  33  * SDTI2  [L5][R5][L6][R6]
  34  *
  35  * [TDM128]
  36  * SDTO1  [L1][R1][L2][R2]
  37  * SDTI1  [L1][R1][L2][R2]
  38  * SDTI2  [L3][R3][L4][R4]
  39  * SDTI3  [L5][R5][L6][R6]
  40  *
  41  * [STEREO]
  42  *      Playback  2ch : SDTI1
  43  *      Capture   2ch : SDTO1
  44  *
  45  * [TDM512]
  46  *      Playback 12ch : SDTI1
  47  *      Capture   4ch : SDTO1
  48  *
  49  * [TDM256]
  50  *      Playback 12ch : SDTI1 + SDTI2
  51  *      Playback  8ch : SDTI1
  52  *      Capture   4ch : SDTO1
  53  *
  54  * [TDM128]
  55  *      Playback 12ch : SDTI1 + SDTI2 + SDTI3
  56  *      Playback  8ch : SDTI1 + SDTI2
  57  *      Playback  4ch : SDTI1
  58  *      Capture   4ch : SDTO1
  59  *
  60  *
  61  * !!! NOTE !!!
  62  *
  63  * Renesas is the only user of ak4613 on upstream so far,
  64  * but the chip connection is like below.
  65  * Thus, Renesas can't test all connection case.
  66  * Tested TDM is very limited.
  67  *
  68  * +-----+      +-----------+
  69  * | SoC |      |  AK4613   |
  70  * |     |<-----|SDTO1   IN1|<-- Mic
  71  * |     |      |        IN2|
  72  * |     |      |           |
  73  * |     |----->|SDTI1  OUT1|--> Headphone
  74  * +-----+      |SDTI2  OUT2|
  75  *              |SDTI3  OUT3|
  76  *              |       OUT4|
  77  *              |       OUT5|
  78  *              |       OUT6|
  79  *              +-----------+
  80  *
  81  * Renesas SoC can handle [2,  6,8]    channels.
  82  * Ak4613      can handle [2,4,  8,12] channels.
  83  *
  84  * Because of above HW connection and available channels number,
  85  * Renesas could test are ...
  86  *
  87  *      [STEREO] Playback  2ch : SDTI1
  88  *               Capture   2ch : SDTO1
  89  *      [TDM256] Playback  8ch : SDTI1 (*)
  90  *
  91  * (*) it used 8ch data between SoC <-> AK4613 on TDM256 mode,
  92  *     but could confirm is only first 2ch because only 1
  93  *     Headphone is connected.
  94  *
  95  * see
  96  *      AK4613_ENABLE_TDM_TEST
  97  */
  98 #include <linux/clk.h>
  99 #include <linux/delay.h>
 100 #include <linux/i2c.h>
 101 #include <linux/slab.h>
 102 #include <linux/of.h>
 103 #include <linux/of_graph.h>
 104 #include <linux/module.h>
 105 #include <linux/regmap.h>
 106 #include <sound/soc.h>
 107 #include <sound/pcm_params.h>
 108 #include <sound/tlv.h>
 109
 110 #define PW_MGMT1        0x00 /* Power Management 1 */
 111 #define PW_MGMT2        0x01 /* Power Management 2 */
 112 #define PW_MGMT3        0x02 /* Power Management 3 */
 113 #define CTRL1           0x03 /* Control 1 */
 114 #define CTRL2           0x04 /* Control 2 */
 115 #define DEMP1           0x05 /* De-emphasis1 */
 116 #define DEMP2           0x06 /* De-emphasis2 */
 117 #define OFD             0x07 /* Overflow Detect */
 118 #define ZRD             0x08 /* Zero Detect */
 119 #define ICTRL           0x09 /* Input Control */
 120 #define OCTRL           0x0a /* Output Control */
 121 #define LOUT1           0x0b /* LOUT1 Volume Control */
 122 #define ROUT1           0x0c /* ROUT1 Volume Control */
 123 #define LOUT2           0x0d /* LOUT2 Volume Control */
 124 #define ROUT2           0x0e /* ROUT2 Volume Control */
 125 #define LOUT3           0x0f /* LOUT3 Volume Control */
 126 #define ROUT3           0x10 /* ROUT3 Volume Control */
 127 #define LOUT4           0x11 /* LOUT4 Volume Control */
 128 #define ROUT4           0x12 /* ROUT4 Volume Control */
 129 #define LOUT5           0x13 /* LOUT5 Volume Control */
 130 #define ROUT5           0x14 /* ROUT5 Volume Control */
 131 #define LOUT6           0x15 /* LOUT6 Volume Control */
 132 #define ROUT6           0x16 /* ROUT6 Volume Control */
 133
 134 /* PW_MGMT1 */
 135 #define RSTN            BIT(0)
 136 #define PMDAC           BIT(1)
 137 #define PMADC           BIT(2)
 138 #define PMVR            BIT(3)
 139
 140 /* PW_MGMT2 */
 141 #define PMAD_ALL        0x7
 142
 143 /* PW_MGMT3 */
 144 #define PMDA_ALL        0x3f
 145
 146 /* CTRL1 */
 147 #define DIF0            BIT(3)
 148 #define DIF1            BIT(4)
 149 #define DIF2            BIT(5)
 150 #define TDM0            BIT(6)
 151 #define TDM1            BIT(7)
 152 #define NO_FMT          (0xff)
 153 #define FMT_MASK        (0xf8)
 154
 155 /* CTRL2 */
 156 #define DFS_MASK                (3 << 2)
 157 #define DFS_NORMAL_SPEED        (0 << 2)
 158 #define DFS_DOUBLE_SPEED        (1 << 2)
 159 #define DFS_QUAD_SPEED          (2 << 2)
 160
 161 /* ICTRL */
 162 #define ICTRL_MASK      (0x3)
 163
 164 /* OCTRL */
 165 #define OCTRL_MASK      (0x3F)
 166
 167 /*
 168  * configs
 169  *
 170  * 0x000000BA
 171  *
 172  * B : AK4613_CONFIG_SDTI_x
 173  * A : AK4613_CONFIG_MODE_x
 174  */
 175 #define AK4613_CONFIG_SET(priv, x)       priv->configs |= AK4613_CONFIG_##x
 176 #define AK4613_CONFIG_GET(priv, x)      (priv->configs &  AK4613_CONFIG_##x##_MASK)
 177
 178 /*
 179  * AK4613_CONFIG_SDTI_x
 180  *
 181  * It indicates how many SDTIx is connected.
 182  */
 183 #define AK4613_CONFIG_SDTI_MASK         (0xF << 4)
 184 #define AK4613_CONFIG_SDTI(x)           (((x) & 0xF) << 4)
 185 #define AK4613_CONFIG_SDTI_set(priv, x)   AK4613_CONFIG_SET(priv, SDTI(x))
 186 #define AK4613_CONFIG_SDTI_get(priv)    ((AK4613_CONFIG_GET(priv, SDTI) >> 4) & 0xF)
 187
 188 /*
 189  * AK4613_CONFIG_MODE_x
 190  *
 191  * Same as Ctrl1 :: TDM1/TDM0
 192  * No shift is requested
 193  * see
 194  *      AK4613_CTRL1_TO_MODE()
 195  *      Table 11/12/13/14
 196  */
 197 #define AK4613_CONFIG_MODE_MASK         (0xF)
 198 #define AK4613_CONFIG_MODE_STEREO       (0x0)
 199 #define AK4613_CONFIG_MODE_TDM512       (0x1)
 200 #define AK4613_CONFIG_MODE_TDM256       (0x2)
 201 #define AK4613_CONFIG_MODE_TDM128       (0x3)
 202
 203 /*
 204  * !!!! FIXME !!!!
 205  *
 206  * Because of testable HW limitation, TDM256 8ch TDM was only tested.
 207  * This driver uses AK4613_ENABLE_TDM_TEST instead of new DT property so far.
 208  * Don't hesitate to update driver, you don't need to care compatible
 209  * with Renesas.
 210  *
 211  * #define AK4613_ENABLE_TDM_TEST
 212  */
 213
 214 struct ak4613_interface {
 215         unsigned int width;
 216         unsigned int fmt;
 217         u8 dif;
 218 };
 219
 220 struct ak4613_priv {
 221         struct mutex lock;
 222         struct snd_pcm_hw_constraint_list constraint_rates;
 223         struct snd_pcm_hw_constraint_list constraint_channels;
 224         struct work_struct dummy_write_work;
 225         struct snd_soc_component *component;
 226         unsigned int rate;
 227         unsigned int sysclk;
 228
 229         unsigned int fmt;
 230         unsigned int configs;
 231         int cnt;
 232         u8 ctrl1;
 233         u8 oc;
 234         u8 ic;
 235 };
 236
 237 /*
 238  * Playback Volume
 239  *
 240  * max : 0x00 : 0 dB
 241  *       ( 0.5 dB step )
 242  * min : 0xFE : -127.0 dB
 243  * mute: 0xFF
 244  */
 245 static const DECLARE_TLV_DB_SCALE(out_tlv, -12750, 50, 1);
 246
 247 static const struct snd_kcontrol_new ak4613_snd_controls[] = {
 248         SOC_DOUBLE_R_TLV("Digital Playback Volume1", LOUT1, ROUT1,
 249                          0, 0xFF, 1, out_tlv),
 250         SOC_DOUBLE_R_TLV("Digital Playback Volume2", LOUT2, ROUT2,
 251                          0, 0xFF, 1, out_tlv),
 252         SOC_DOUBLE_R_TLV("Digital Playback Volume3", LOUT3, ROUT3,
 253                          0, 0xFF, 1, out_tlv),
 254         SOC_DOUBLE_R_TLV("Digital Playback Volume4", LOUT4, ROUT4,
 255                          0, 0xFF, 1, out_tlv),
 256         SOC_DOUBLE_R_TLV("Digital Playback Volume5", LOUT5, ROUT5,
 257                          0, 0xFF, 1, out_tlv),
 258         SOC_DOUBLE_R_TLV("Digital Playback Volume6", LOUT6, ROUT6,
 259                          0, 0xFF, 1, out_tlv),
 260 };
 261
 262 static const struct reg_default ak4613_reg[] = {
 263         { 0x0,  0x0f }, { 0x1,  0x07 }, { 0x2,  0x3f }, { 0x3,  0x20 },
 264         { 0x4,  0x20 }, { 0x5,  0x55 }, { 0x6,  0x05 }, { 0x7,  0x07 },
 265         { 0x8,  0x0f }, { 0x9,  0x07 }, { 0xa,  0x3f }, { 0xb,  0x00 },
 266         { 0xc,  0x00 }, { 0xd,  0x00 }, { 0xe,  0x00 }, { 0xf,  0x00 },
 267         { 0x10, 0x00 }, { 0x11, 0x00 }, { 0x12, 0x00 }, { 0x13, 0x00 },
 268         { 0x14, 0x00 }, { 0x15, 0x00 }, { 0x16, 0x00 },
 269 };
 270
 271 /*
 272  * CTRL1 register
 273  * see
 274  *      Table 11/12/13/14
 275  */
 276 #define AUDIO_IFACE(_dif, _width, _fmt)         \
 277         {                                       \
 278                 .dif    = _dif,                 \
 279                 .width  = _width,               \
 280                 .fmt    = SND_SOC_DAIFMT_##_fmt,\
 281         }
 282 static const struct ak4613_interface ak4613_iface[] = {
 283         /* It doesn't support asymmetric format */
 284
 285         AUDIO_IFACE(0x03, 24, LEFT_J),
 286         AUDIO_IFACE(0x04, 24, I2S),
 287 };
 288 #define AK4613_CTRL1_TO_MODE(priv)      ((priv)->ctrl1 >> 6) /* AK4613_CONFIG_MODE_x */
 289
 290 static const struct regmap_config ak4613_regmap_cfg = {
 291         .reg_bits               = 8,
 292         .val_bits               = 8,
 293         .max_register           = 0x16,
 294         .reg_defaults           = ak4613_reg,
 295         .num_reg_defaults       = ARRAY_SIZE(ak4613_reg),
 296         .cache_type             = REGCACHE_RBTREE,
 297 };
 298
 299 static const struct of_device_id ak4613_of_match[] = {
 300         { .compatible = "asahi-kasei,ak4613",   .data = &ak4613_regmap_cfg },
 301         {},
 302 };
 303 MODULE_DEVICE_TABLE(of, ak4613_of_match);
 304
 305 static const struct i2c_device_id ak4613_i2c_id[] = {
 306         { "ak4613", (kernel_ulong_t)&ak4613_regmap_cfg },
 307         { }
 308 };
 309 MODULE_DEVICE_TABLE(i2c, ak4613_i2c_id);
 310
 311 static const struct snd_soc_dapm_widget ak4613_dapm_widgets[] = {
 312
 313         /* Outputs */
 314         SND_SOC_DAPM_OUTPUT("LOUT1"),
 315         SND_SOC_DAPM_OUTPUT("LOUT2"),
 316         SND_SOC_DAPM_OUTPUT("LOUT3"),
 317         SND_SOC_DAPM_OUTPUT("LOUT4"),
 318         SND_SOC_DAPM_OUTPUT("LOUT5"),
 319         SND_SOC_DAPM_OUTPUT("LOUT6"),
 320
 321         SND_SOC_DAPM_OUTPUT("ROUT1"),
 322         SND_SOC_DAPM_OUTPUT("ROUT2"),
 323         SND_SOC_DAPM_OUTPUT("ROUT3"),
 324         SND_SOC_DAPM_OUTPUT("ROUT4"),
 325         SND_SOC_DAPM_OUTPUT("ROUT5"),
 326         SND_SOC_DAPM_OUTPUT("ROUT6"),
 327
 328         /* Inputs */
 329         SND_SOC_DAPM_INPUT("LIN1"),
 330         SND_SOC_DAPM_INPUT("LIN2"),
 331
 332         SND_SOC_DAPM_INPUT("RIN1"),
 333         SND_SOC_DAPM_INPUT("RIN2"),
 334
 335         /* DAC */
 336         SND_SOC_DAPM_DAC("DAC1", NULL, PW_MGMT3, 0, 0),
 337         SND_SOC_DAPM_DAC("DAC2", NULL, PW_MGMT3, 1, 0),
 338         SND_SOC_DAPM_DAC("DAC3", NULL, PW_MGMT3, 2, 0),
 339         SND_SOC_DAPM_DAC("DAC4", NULL, PW_MGMT3, 3, 0),
 340         SND_SOC_DAPM_DAC("DAC5", NULL, PW_MGMT3, 4, 0),
 341         SND_SOC_DAPM_DAC("DAC6", NULL, PW_MGMT3, 5, 0),
 342
 343         /* ADC */
 344         SND_SOC_DAPM_ADC("ADC1", NULL, PW_MGMT2, 0, 0),
 345         SND_SOC_DAPM_ADC("ADC2", NULL, PW_MGMT2, 1, 0),
 346 };
 347
 348 static const struct snd_soc_dapm_route ak4613_intercon[] = {
 349         {"LOUT1", NULL, "DAC1"},
 350         {"LOUT2", NULL, "DAC2"},
 351         {"LOUT3", NULL, "DAC3"},
 352         {"LOUT4", NULL, "DAC4"},
 353         {"LOUT5", NULL, "DAC5"},
 354         {"LOUT6", NULL, "DAC6"},
 355
 356         {"ROUT1", NULL, "DAC1"},
 357         {"ROUT2", NULL, "DAC2"},
 358         {"ROUT3", NULL, "DAC3"},
 359         {"ROUT4", NULL, "DAC4"},
 360         {"ROUT5", NULL, "DAC5"},
 361         {"ROUT6", NULL, "DAC6"},
 362
 363         {"DAC1", NULL, "Playback"},
 364         {"DAC2", NULL, "Playback"},
 365         {"DAC3", NULL, "Playback"},
 366         {"DAC4", NULL, "Playback"},
 367         {"DAC5", NULL, "Playback"},
 368         {"DAC6", NULL, "Playback"},
 369
 370         {"Capture", NULL, "ADC1"},
 371         {"Capture", NULL, "ADC2"},
 372
 373         {"ADC1", NULL, "LIN1"},
 374         {"ADC2", NULL, "LIN2"},
 375
 376         {"ADC1", NULL, "RIN1"},
 377         {"ADC2", NULL, "RIN2"},
 378 };
 379
 380 static void ak4613_dai_shutdown(struct snd_pcm_substream *substream,
 381                                struct snd_soc_dai *dai)
 382 {
 383         struct snd_soc_component *component = dai->component;
 384         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 385         struct device *dev = component->dev;
 386
 387         mutex_lock(&priv->lock);
 388         priv->cnt--;
 389         if (priv->cnt < 0) {
 390                 dev_err(dev, "unexpected counter error\n");
 391                 priv->cnt = 0;
 392         }
 393         if (!priv->cnt)
 394                 priv->ctrl1 = 0;
 395         mutex_unlock(&priv->lock);
 396 }
 397
 398 static void ak4613_hw_constraints(struct ak4613_priv *priv,
 399                                   struct snd_pcm_substream *substream)
 400 {
 401         struct snd_pcm_runtime *runtime = substream->runtime;
 402         static const unsigned int ak4613_rates[] = {
 403                  32000,
 404                  44100,
 405                  48000,
 406                  64000,
 407                  88200,
 408                  96000,
 409                 176400,
 410                 192000,
 411         };
 412 #define AK4613_CHANNEL_2         0
 413 #define AK4613_CHANNEL_4         1
 414 #define AK4613_CHANNEL_8         2
 415 #define AK4613_CHANNEL_12        3
 416 #define AK4613_CHANNEL_NONE     -1
 417         static const unsigned int ak4613_channels[] = {
 418                 [AK4613_CHANNEL_2]  =  2,
 419                 [AK4613_CHANNEL_4]  =  4,
 420                 [AK4613_CHANNEL_8]  =  8,
 421                 [AK4613_CHANNEL_12] = 12,
 422         };
 423 #define MODE_MAX 4
 424 #define SDTx_MAX 4
 425 #define MASK(x) (1 << AK4613_CHANNEL_##x)
 426         static const int mask_list[MODE_MAX][SDTx_MAX] = {
 427                 /*                              SDTO     SDTIx1    SDTIx2               SDTIx3 */
 428                 [AK4613_CONFIG_MODE_STEREO] = { MASK(2), MASK(2),  MASK(2),             MASK(2)},
 429                 [AK4613_CONFIG_MODE_TDM512] = { MASK(4), MASK(12), MASK(12),            MASK(12)},
 430                 [AK4613_CONFIG_MODE_TDM256] = { MASK(4), MASK(8),  MASK(8)|MASK(12),    MASK(8)|MASK(12)},
 431                 [AK4613_CONFIG_MODE_TDM128] = { MASK(4), MASK(4),  MASK(4)|MASK(8),     MASK(4)|MASK(8)|MASK(12)},
 432         };
 433         struct snd_pcm_hw_constraint_list *constraint;
 434         unsigned int mask;
 435         unsigned int mode;
 436         unsigned int fs;
 437         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 438         int sdti_num;
 439         int i;
 440
 441         constraint              = &priv->constraint_rates;
 442         constraint->list        = ak4613_rates;
 443         constraint->mask        = 0;
 444         constraint->count       = 0;
 445
 446         /*
 447          * Slave Mode
 448          *      Normal: [32kHz, 48kHz] : 256fs,384fs or 512fs
 449          *      Double: [64kHz, 96kHz] : 256fs
 450          *      Quad  : [128kHz,192kHz]: 128fs
 451          *
 452          * Master mode
 453          *      Normal: [32kHz, 48kHz] : 256fs or 512fs
 454          *      Double: [64kHz, 96kHz] : 256fs
 455          *      Quad  : [128kHz,192kHz]: 128fs
 456         */
 457         for (i = 0; i < ARRAY_SIZE(ak4613_rates); i++) {
 458                 /* minimum fs on each range */
 459                 fs = (ak4613_rates[i] <= 96000) ? 256 : 128;
 460
 461                 if (priv->sysclk >= ak4613_rates[i] * fs)
 462                         constraint->count = i + 1;
 463         }
 464
 465         snd_pcm_hw_constraint_list(runtime, 0,
 466                                 SNDRV_PCM_HW_PARAM_RATE, constraint);
 467
 468
 469         sdti_num = AK4613_CONFIG_SDTI_get(priv);
 470         if (WARN_ON(sdti_num >= SDTx_MAX))
 471                 return;
 472
 473         if (priv->cnt) {
 474                 /*
 475                  * If it was already working,
 476                  * the constraint is same as working mode.
 477                  */
 478                 mode = AK4613_CTRL1_TO_MODE(priv);
 479                 mask = 0; /* no default */
 480         } else {
 481                 /*
 482                  * It is not yet working,
 483                  * the constraint is based on board configs.
 484                  * STEREO mask is default
 485                  */
 486                 mode = AK4613_CONFIG_GET(priv, MODE);
 487                 mask = mask_list[AK4613_CONFIG_MODE_STEREO][is_play * sdti_num];
 488         }
 489
 490         if (WARN_ON(mode >= MODE_MAX))
 491                 return;
 492
 493         /* add each mode mask */
 494         mask |= mask_list[mode][is_play * sdti_num];
 495
 496         constraint              = &priv->constraint_channels;
 497         constraint->list        = ak4613_channels;
 498         constraint->mask        = mask;
 499         constraint->count       = sizeof(ak4613_channels);
 500         snd_pcm_hw_constraint_list(runtime, 0,
 501                                    SNDRV_PCM_HW_PARAM_CHANNELS, constraint);
 502 }
 503
 504 static int ak4613_dai_startup(struct snd_pcm_substream *substream,
 505                               struct snd_soc_dai *dai)
 506 {
 507         struct snd_soc_component *component = dai->component;
 508         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 509
 510         mutex_lock(&priv->lock);
 511         ak4613_hw_constraints(priv, substream);
 512         priv->cnt++;
 513         mutex_unlock(&priv->lock);
 514
 515         return 0;
 516 }
 517
 518 static int ak4613_dai_set_sysclk(struct snd_soc_dai *codec_dai,
 519                                  int clk_id, unsigned int freq, int dir)
 520 {
 521         struct snd_soc_component *component = codec_dai->component;
 522         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 523
 524         priv->sysclk = freq;
 525
 526         return 0;
 527 }
 528
 529 static int ak4613_dai_set_fmt(struct snd_soc_dai *dai, unsigned int format)
 530 {
 531         struct snd_soc_component *component = dai->component;
 532         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 533         unsigned int fmt;
 534
 535         fmt = format & SND_SOC_DAIFMT_FORMAT_MASK;
 536         switch (fmt) {
 537         case SND_SOC_DAIFMT_LEFT_J:
 538         case SND_SOC_DAIFMT_I2S:
 539                 priv->fmt = fmt;
 540                 break;
 541         default:
 542                 return -EINVAL;
 543         }
 544
 545         fmt = format & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
 546         switch (fmt) {
 547         case SND_SOC_DAIFMT_CBC_CFC:
 548                 break;
 549         default:
 550                 /*
 551                  * SUPPORTME
 552                  *
 553                  * "clock provider" is not yet supperted
 554                  */
 555                 return -EINVAL;
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int ak4613_dai_hw_params(struct snd_pcm_substream *substream,
 562                                 struct snd_pcm_hw_params *params,
 563                                 struct snd_soc_dai *dai)
 564 {
 565         struct snd_soc_component *component = dai->component;
 566         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 567         struct device *dev = component->dev;
 568         unsigned int width = params_width(params);
 569         unsigned int fmt = priv->fmt;
 570         unsigned int rate;
 571         int i, ret;
 572         u8 ctrl2;
 573
 574         rate = params_rate(params);
 575         switch (rate) {
 576         case 32000:
 577         case 44100:
 578         case 48000:
 579                 ctrl2 = DFS_NORMAL_SPEED;
 580                 break;
 581         case 64000:
 582         case 88200:
 583         case 96000:
 584                 ctrl2 = DFS_DOUBLE_SPEED;
 585                 break;
 586         case 176400:
 587         case 192000:
 588                 ctrl2 = DFS_QUAD_SPEED;
 589                 break;
 590         default:
 591                 return -EINVAL;
 592         }
 593         priv->rate = rate;
 594
 595         /*
 596          * FIXME
 597          *
 598          * It doesn't have full TDM suppert yet
 599          */
 600         ret = -EINVAL;
 601
 602         mutex_lock(&priv->lock);
 603         if (priv->cnt > 1) {
 604                 /*
 605                  * If it was already working, use current priv->ctrl1
 606                  */
 607                 ret = 0;
 608         } else {
 609                 /*
 610                  * It is not yet working,
 611                  */
 612                 unsigned int channel = params_channels(params);
 613                 u8 tdm;
 614
 615                 /* STEREO or TDM */
 616                 if (channel == 2)
 617                         tdm = AK4613_CONFIG_MODE_STEREO;
 618                 else
 619                         tdm = AK4613_CONFIG_GET(priv, MODE);
 620
 621                 for (i = ARRAY_SIZE(ak4613_iface) - 1; i >= 0; i--) {
 622                         const struct ak4613_interface *iface = ak4613_iface + i;
 623
 624                         if ((iface->fmt == fmt) && (iface->width == width)) {
 625                                 /*
 626                                  * Ctrl1
 627                                  * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0  |
 628                                  * |TDM1|TDM0|DIF2|DIF1|DIF0|ATS1|ATS0|SMUTE|
 629                                  *  <  tdm  > < iface->dif >
 630                                  */
 631                                 priv->ctrl1 = (tdm << 6) | (iface->dif << 3);
 632                                 ret = 0;
 633                                 break;
 634                         }
 635                 }
 636         }
 637         mutex_unlock(&priv->lock);
 638
 639         if (ret < 0)
 640                 goto hw_params_end;
 641
 642         snd_soc_component_update_bits(component, CTRL1, FMT_MASK, priv->ctrl1);
 643         snd_soc_component_update_bits(component, CTRL2, DFS_MASK, ctrl2);
 644
 645         snd_soc_component_update_bits(component, ICTRL, ICTRL_MASK, priv->ic);
 646         snd_soc_component_update_bits(component, OCTRL, OCTRL_MASK, priv->oc);
 647
 648 hw_params_end:
 649         if (ret < 0)
 650                 dev_warn(dev, "unsupported data width/format combination\n");
 651
 652         return ret;
 653 }
 654
 655 static int ak4613_set_bias_level(struct snd_soc_component *component,
 656                                  enum snd_soc_bias_level level)
 657 {
 658         u8 mgmt1 = 0;
 659
 660         switch (level) {
 661         case SND_SOC_BIAS_ON:
 662                 mgmt1 |= RSTN;
 663                 fallthrough;
 664         case SND_SOC_BIAS_PREPARE:
 665                 mgmt1 |= PMADC | PMDAC;
 666                 fallthrough;
 667         case SND_SOC_BIAS_STANDBY:
 668                 mgmt1 |= PMVR;
 669                 fallthrough;
 670         case SND_SOC_BIAS_OFF:
 671         default:
 672                 break;
 673         }
 674
 675         snd_soc_component_write(component, PW_MGMT1, mgmt1);
 676
 677         return 0;
 678 }
 679
 680 static void ak4613_dummy_write(struct work_struct *work)
 681 {
 682         struct ak4613_priv *priv = container_of(work,
 683                                                 struct ak4613_priv,
 684                                                 dummy_write_work);
 685         struct snd_soc_component *component = priv->component;
 686         unsigned int mgmt1;
 687         unsigned int mgmt3;
 688
 689         /*
 690          * PW_MGMT1 / PW_MGMT3 needs dummy write at least after 5 LR clocks
 691          *
 692          * Note
 693          *
 694          * To avoid extra delay, we want to avoid preemption here,
 695          * but we can't. Because it uses I2C access which is using IRQ
 696          * and sleep. Thus, delay might be more than 5 LR clocks
 697          * see also
 698          *      ak4613_dai_trigger()
 699          */
 700         udelay(5000000 / priv->rate);
 701
 702         mgmt1 = snd_soc_component_read(component, PW_MGMT1);
 703         mgmt3 = snd_soc_component_read(component, PW_MGMT3);
 704
 705         snd_soc_component_write(component, PW_MGMT1, mgmt1);
 706         snd_soc_component_write(component, PW_MGMT3, mgmt3);
 707 }
 708
 709 static int ak4613_dai_trigger(struct snd_pcm_substream *substream, int cmd,
 710                               struct snd_soc_dai *dai)
 711 {
 712         struct snd_soc_component *component = dai->component;
 713         struct ak4613_priv *priv = snd_soc_component_get_drvdata(component);
 714
 715         /*
 716          * FIXME
 717          *
 718          * PW_MGMT1 / PW_MGMT3 needs dummy write at least after 5 LR clocks
 719          * from Power Down Release. Otherwise, Playback volume will be 0dB.
 720          * To avoid complex multiple delay/dummy_write method from
 721          * ak4613_set_bias_level() / SND_SOC_DAPM_DAC_E("DACx", ...),
 722          * call it once here.
 723          *
 724          * But, unfortunately, we can't "write" here because here is atomic
 725          * context (It uses I2C access for writing).
 726          * Thus, use schedule_work() to switching to normal context
 727          * immediately.
 728          *
 729          * Note
 730          *
 731          * Calling ak4613_dummy_write() function might be delayed.
 732          * In such case, ak4613 volume might be temporarily 0dB when
 733          * beggining of playback.
 734          * see also
 735          *      ak4613_dummy_write()
 736          */
 737
 738         if ((cmd != SNDRV_PCM_TRIGGER_START) &&
 739             (cmd != SNDRV_PCM_TRIGGER_RESUME))
 740                 return 0;
 741
 742         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
 743                 return  0;
 744
 745         priv->component = component;
 746         schedule_work(&priv->dummy_write_work);
 747
 748         return 0;
 749 }
 750
 751 /*
 752  * Select below from Sound Card, not Auto
 753  *      SND_SOC_DAIFMT_CBC_CFC
 754  *      SND_SOC_DAIFMT_CBP_CFP
 755  */
 756 static const u64 ak4613_dai_formats =
 757         SND_SOC_POSSIBLE_DAIFMT_I2S     |
 758         SND_SOC_POSSIBLE_DAIFMT_LEFT_J;
 759
 760 static const struct snd_soc_dai_ops ak4613_dai_ops = {
 761         .startup        = ak4613_dai_startup,
 762         .shutdown       = ak4613_dai_shutdown,
 763         .set_sysclk     = ak4613_dai_set_sysclk,
 764         .set_fmt        = ak4613_dai_set_fmt,
 765         .trigger        = ak4613_dai_trigger,
 766         .hw_params      = ak4613_dai_hw_params,
 767         .auto_selectable_formats        = &ak4613_dai_formats,
 768         .num_auto_selectable_formats    = 1,
 769 };
 770
 771 #define AK4613_PCM_RATE         (SNDRV_PCM_RATE_32000  |\
 772                                  SNDRV_PCM_RATE_44100  |\
 773                                  SNDRV_PCM_RATE_48000  |\
 774                                  SNDRV_PCM_RATE_64000  |\
 775                                  SNDRV_PCM_RATE_88200  |\
 776                                  SNDRV_PCM_RATE_96000  |\
 777                                  SNDRV_PCM_RATE_176400 |\
 778                                  SNDRV_PCM_RATE_192000)
 779 #define AK4613_PCM_FMTBIT       (SNDRV_PCM_FMTBIT_S24_LE)
 780
 781 static struct snd_soc_dai_driver ak4613_dai = {
 782         .name = "ak4613-hifi",
 783         .playback = {
 784                 .stream_name    = "Playback",
 785                 .channels_min   = 2,
 786                 .channels_max   = 12,
 787                 .rates          = AK4613_PCM_RATE,
 788                 .formats        = AK4613_PCM_FMTBIT,
 789         },
 790         .capture = {
 791                 .stream_name    = "Capture",
 792                 .channels_min   = 2,
 793                 .channels_max   = 4,
 794                 .rates          = AK4613_PCM_RATE,
 795                 .formats        = AK4613_PCM_FMTBIT,
 796         },
 797         .ops = &ak4613_dai_ops,
 798         .symmetric_rate = 1,
 799 };
 800
 801 static int ak4613_suspend(struct snd_soc_component *component)
 802 {
 803         struct regmap *regmap = dev_get_regmap(component->dev, NULL);
 804
 805         regcache_cache_only(regmap, true);
 806         regcache_mark_dirty(regmap);
 807         return 0;
 808 }
 809
 810 static int ak4613_resume(struct snd_soc_component *component)
 811 {
 812         struct regmap *regmap = dev_get_regmap(component->dev, NULL);
 813
 814         regcache_cache_only(regmap, false);
 815         return regcache_sync(regmap);
 816 }
 817
 818 static const struct snd_soc_component_driver soc_component_dev_ak4613 = {
 819         .suspend                = ak4613_suspend,
 820         .resume                 = ak4613_resume,
 821         .set_bias_level         = ak4613_set_bias_level,
 822         .controls               = ak4613_snd_controls,
 823         .num_controls           = ARRAY_SIZE(ak4613_snd_controls),
 824         .dapm_widgets           = ak4613_dapm_widgets,
 825         .num_dapm_widgets       = ARRAY_SIZE(ak4613_dapm_widgets),
 826         .dapm_routes            = ak4613_intercon,
 827         .num_dapm_routes        = ARRAY_SIZE(ak4613_intercon),
 828         .idle_bias_on           = 1,
 829         .endianness             = 1,
 830 };
 831
 832 static void ak4613_parse_of(struct ak4613_priv *priv,
 833                             struct device *dev)
 834 {
 835         struct device_node *np = dev->of_node;
 836         char prop[32];
 837         int sdti_num;
 838         int i;
 839
 840         /* Input 1 - 2 */
 841         for (i = 0; i < 2; i++) {
 842                 snprintf(prop, sizeof(prop), "asahi-kasei,in%d-single-end", i + 1);
 843                 if (!of_property_read_bool(np, prop))
 844                         priv->ic |= 1 << i;
 845         }
 846
 847         /* Output 1 - 6 */
 848         for (i = 0; i < 6; i++) {
 849                 snprintf(prop, sizeof(prop), "asahi-kasei,out%d-single-end", i + 1);
 850                 if (!of_property_read_bool(np, prop))
 851                         priv->oc |= 1 << i;
 852         }
 853
 854         /*
 855          * enable TDM256 test
 856          *
 857          * !!! FIXME !!!
 858          *
 859          * It should be configured by DT or other way
 860          * if it was full supported.
 861          * But it is using ifdef style for now for test
 862          * purpose.
 863          */
 864 #if defined(AK4613_ENABLE_TDM_TEST)
 865         AK4613_CONFIG_SET(priv, MODE_TDM256);
 866 #endif
 867
 868         /*
 869          * connected STDI
 870          * TDM support is assuming it is probed via Audio-Graph-Card style here.
 871          * Default is SDTIx1 if it was probed via Simple-Audio-Card for now.
 872          */
 873         sdti_num = of_graph_get_endpoint_count(np);
 874         if ((sdti_num >= SDTx_MAX) || (sdti_num < 1))
 875                 sdti_num = 1;
 876
 877         AK4613_CONFIG_SDTI_set(priv, sdti_num);
 878 }
 879
 880 static int ak4613_i2c_probe(struct i2c_client *i2c)
 881 {
 882         struct device *dev = &i2c->dev;
 883         const struct regmap_config *regmap_cfg;
 884         struct regmap *regmap;
 885         struct ak4613_priv *priv;
 886
 887         regmap_cfg = i2c_get_match_data(i2c);
 888         if (!regmap_cfg)
 889                 return -EINVAL;
 890
 891         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 892         if (!priv)
 893                 return -ENOMEM;
 894
 895         ak4613_parse_of(priv, dev);
 896
 897         priv->ctrl1             = 0;
 898         priv->cnt               = 0;
 899         priv->sysclk            = 0;
 900         INIT_WORK(&priv->dummy_write_work, ak4613_dummy_write);
 901
 902         mutex_init(&priv->lock);
 903
 904         i2c_set_clientdata(i2c, priv);
 905
 906         regmap = devm_regmap_init_i2c(i2c, regmap_cfg);
 907         if (IS_ERR(regmap))
 908                 return PTR_ERR(regmap);
 909
 910         return devm_snd_soc_register_component(dev, &soc_component_dev_ak4613,
 911                                       &ak4613_dai, 1);
 912 }
 913
 914 static struct i2c_driver ak4613_i2c_driver = {
 915         .driver = {
 916                 .name = "ak4613-codec",
 917                 .of_match_table = ak4613_of_match,
 918         },
 919         .probe          = ak4613_i2c_probe,
 920         .id_table       = ak4613_i2c_id,
 921 };
 922
 923 module_i2c_driver(ak4613_i2c_driver);
 924
 925 MODULE_DESCRIPTION("Soc AK4613 driver");
 926 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
 927 MODULE_LICENSE("GPL v2");