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_device.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 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 .non_legacy_dai_naming = 1, 831 }; 832 833 static void ak4613_parse_of(struct ak4613_priv *priv, 834 struct device *dev) 835 { 836 struct device_node *np = dev->of_node; 837 char prop[32]; 838 int sdti_num; 839 int i; 840 841 /* Input 1 - 2 */ 842 for (i = 0; i < 2; i++) { 843 snprintf(prop, sizeof(prop), "asahi-kasei,in%d-single-end", i + 1); 844 if (!of_get_property(np, prop, NULL)) 845 priv->ic |= 1 << i; 846 } 847 848 /* Output 1 - 6 */ 849 for (i = 0; i < 6; i++) { 850 snprintf(prop, sizeof(prop), "asahi-kasei,out%d-single-end", i + 1); 851 if (!of_get_property(np, prop, NULL)) 852 priv->oc |= 1 << i; 853 } 854 855 /* 856 * enable TDM256 test 857 * 858 * !!! FIXME !!! 859 * 860 * It should be configured by DT or other way 861 * if it was full supported. 862 * But it is using ifdef style for now for test 863 * purpose. 864 */ 865 #if defined(AK4613_ENABLE_TDM_TEST) 866 AK4613_CONFIG_SET(priv, MODE_TDM256); 867 #endif 868 869 /* 870 * connected STDI 871 */ 872 sdti_num = of_graph_get_endpoint_count(np); 873 if (WARN_ON((sdti_num > 3) || (sdti_num < 1))) 874 return; 875 876 AK4613_CONFIG_SDTI_set(priv, sdti_num); 877 } 878 879 static int ak4613_i2c_probe(struct i2c_client *i2c) 880 { 881 struct device *dev = &i2c->dev; 882 struct device_node *np = dev->of_node; 883 const struct regmap_config *regmap_cfg; 884 struct regmap *regmap; 885 struct ak4613_priv *priv; 886 887 regmap_cfg = NULL; 888 if (np) 889 regmap_cfg = of_device_get_match_data(dev); 890 else { 891 const struct i2c_device_id *id = 892 i2c_match_id(ak4613_i2c_id, i2c); 893 regmap_cfg = (const struct regmap_config *)id->driver_data; 894 } 895 896 if (!regmap_cfg) 897 return -EINVAL; 898 899 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 900 if (!priv) 901 return -ENOMEM; 902 903 ak4613_parse_of(priv, dev); 904 905 priv->ctrl1 = 0; 906 priv->cnt = 0; 907 priv->sysclk = 0; 908 INIT_WORK(&priv->dummy_write_work, ak4613_dummy_write); 909 910 mutex_init(&priv->lock); 911 912 i2c_set_clientdata(i2c, priv); 913 914 regmap = devm_regmap_init_i2c(i2c, regmap_cfg); 915 if (IS_ERR(regmap)) 916 return PTR_ERR(regmap); 917 918 return devm_snd_soc_register_component(dev, &soc_component_dev_ak4613, 919 &ak4613_dai, 1); 920 } 921 922 static int ak4613_i2c_remove(struct i2c_client *client) 923 { 924 return 0; 925 } 926 927 static struct i2c_driver ak4613_i2c_driver = { 928 .driver = { 929 .name = "ak4613-codec", 930 .of_match_table = ak4613_of_match, 931 }, 932 .probe_new = ak4613_i2c_probe, 933 .remove = ak4613_i2c_remove, 934 .id_table = ak4613_i2c_id, 935 }; 936 937 module_i2c_driver(ak4613_i2c_driver); 938 939 MODULE_DESCRIPTION("Soc AK4613 driver"); 940 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 941 MODULE_LICENSE("GPL v2"); 942