sound/soc/samsung/tm2_wm5110.c

   1 /*
   2  * Copyright (C) 2015 - 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Authors: Inha Song <ideal.song@samsung.com>
   5  *          Sylwester Nawrocki <s.nawrocki@samsung.com>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  */
  12
  13 #include <linux/clk.h>
  14 #include <linux/gpio.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <sound/pcm_params.h>
  18 #include <sound/soc.h>
  19
  20 #include "i2s.h"
  21 #include "../codecs/wm5110.h"
  22
  23 /*
  24  * The source clock is XCLKOUT with its mux set to the external fixed rate
  25  * oscillator (XXTI).
  26  */
  27 #define MCLK_RATE       24000000U
  28
  29 #define TM2_DAI_AIF1    0
  30 #define TM2_DAI_AIF2    1
  31
  32 struct tm2_machine_priv {
  33         struct snd_soc_codec *codec;
  34         unsigned int sysclk_rate;
  35         struct gpio_desc *gpio_mic_bias;
  36 };
  37
  38 static int tm2_start_sysclk(struct snd_soc_card *card)
  39 {
  40         struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card);
  41         struct snd_soc_codec *codec = priv->codec;
  42         int ret;
  43
  44         ret = snd_soc_codec_set_pll(codec, WM5110_FLL1_REFCLK,
  45                                     ARIZONA_FLL_SRC_MCLK1,
  46                                     MCLK_RATE,
  47                                     priv->sysclk_rate);
  48         if (ret < 0) {
  49                 dev_err(codec->dev, "Failed to set FLL1 source: %d\n", ret);
  50                 return ret;
  51         }
  52
  53         ret = snd_soc_codec_set_pll(codec, WM5110_FLL1,
  54                                     ARIZONA_FLL_SRC_MCLK1,
  55                                     MCLK_RATE,
  56                                     priv->sysclk_rate);
  57         if (ret < 0) {
  58                 dev_err(codec->dev, "Failed to start FLL1: %d\n", ret);
  59                 return ret;
  60         }
  61
  62         ret = snd_soc_codec_set_sysclk(codec, ARIZONA_CLK_SYSCLK,
  63                                        ARIZONA_CLK_SRC_FLL1,
  64                                        priv->sysclk_rate,
  65                                        SND_SOC_CLOCK_IN);
  66         if (ret < 0) {
  67                 dev_err(codec->dev, "Failed to set SYSCLK source: %d\n", ret);
  68                 return ret;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static int tm2_stop_sysclk(struct snd_soc_card *card)
  75 {
  76         struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card);
  77         struct snd_soc_codec *codec = priv->codec;
  78         int ret;
  79
  80         ret = snd_soc_codec_set_pll(codec, WM5110_FLL1, 0, 0, 0);
  81         if (ret < 0) {
  82                 dev_err(codec->dev, "Failed to stop FLL1: %d\n", ret);
  83                 return ret;
  84         }
  85
  86         ret = snd_soc_codec_set_sysclk(codec, ARIZONA_CLK_SYSCLK,
  87                                        ARIZONA_CLK_SRC_FLL1, 0, 0);
  88         if (ret < 0) {
  89                 dev_err(codec->dev, "Failed to stop SYSCLK: %d\n", ret);
  90                 return ret;
  91         }
  92
  93         return 0;
  94 }
  95
  96 static int tm2_aif1_hw_params(struct snd_pcm_substream *substream,
  97                                 struct snd_pcm_hw_params *params)
  98 {
  99         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 100         struct snd_soc_codec *codec = rtd->codec;
 101         struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 102
 103         switch (params_rate(params)) {
 104         case 4000:
 105         case 8000:
 106         case 12000:
 107         case 16000:
 108         case 24000:
 109         case 32000:
 110         case 48000:
 111         case 96000:
 112         case 192000:
 113                 /* Highest possible SYSCLK frequency: 147.456MHz */
 114                 priv->sysclk_rate = 147456000U;
 115                 break;
 116         case 11025:
 117         case 22050:
 118         case 44100:
 119         case 88200:
 120         case 176400:
 121                 /* Highest possible SYSCLK frequency: 135.4752 MHz */
 122                 priv->sysclk_rate = 135475200U;
 123                 break;
 124         default:
 125                 dev_err(codec->dev, "Not supported sample rate: %d\n",
 126                         params_rate(params));
 127                 return -EINVAL;
 128         }
 129
 130         return tm2_start_sysclk(rtd->card);
 131 }
 132
 133 static struct snd_soc_ops tm2_aif1_ops = {
 134         .hw_params = tm2_aif1_hw_params,
 135 };
 136
 137 static int tm2_aif2_hw_params(struct snd_pcm_substream *substream,
 138                                 struct snd_pcm_hw_params *params)
 139 {
 140         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 141         struct snd_soc_codec *codec = rtd->codec;
 142         unsigned int asyncclk_rate;
 143         int ret;
 144
 145         switch (params_rate(params)) {
 146         case 8000:
 147         case 12000:
 148         case 16000:
 149                 /* Highest possible ASYNCCLK frequency: 49.152MHz */
 150                 asyncclk_rate = 49152000U;
 151                 break;
 152         case 11025:
 153                 /* Highest possible ASYNCCLK frequency: 45.1584 MHz */
 154                 asyncclk_rate = 45158400U;
 155                 break;
 156         default:
 157                 dev_err(codec->dev, "Not supported sample rate: %d\n",
 158                         params_rate(params));
 159                 return -EINVAL;
 160         }
 161
 162         ret = snd_soc_codec_set_pll(codec, WM5110_FLL2_REFCLK,
 163                                     ARIZONA_FLL_SRC_MCLK1,
 164                                     MCLK_RATE,
 165                                     asyncclk_rate);
 166         if (ret < 0) {
 167                 dev_err(codec->dev, "Failed to set FLL2 source: %d\n", ret);
 168                 return ret;
 169         }
 170
 171         ret = snd_soc_codec_set_pll(codec, WM5110_FLL2,
 172                                     ARIZONA_FLL_SRC_MCLK1,
 173                                     MCLK_RATE,
 174                                     asyncclk_rate);
 175         if (ret < 0) {
 176                 dev_err(codec->dev, "Failed to start FLL2: %d\n", ret);
 177                 return ret;
 178         }
 179
 180         ret = snd_soc_codec_set_sysclk(codec, ARIZONA_CLK_ASYNCCLK,
 181                                        ARIZONA_CLK_SRC_FLL2,
 182                                        asyncclk_rate,
 183                                        SND_SOC_CLOCK_IN);
 184         if (ret < 0) {
 185                 dev_err(codec->dev, "Failed to set ASYNCCLK source: %d\n", ret);
 186                 return ret;
 187         }
 188
 189         return 0;
 190 }
 191
 192 static int tm2_aif2_hw_free(struct snd_pcm_substream *substream)
 193 {
 194         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 195         struct snd_soc_codec *codec = rtd->codec;
 196         int ret;
 197
 198         /* disable FLL2 */
 199         ret = snd_soc_codec_set_pll(codec, WM5110_FLL2, ARIZONA_FLL_SRC_MCLK1,
 200                                     0, 0);
 201         if (ret < 0)
 202                 dev_err(codec->dev, "Failed to stop FLL2: %d\n", ret);
 203
 204         return ret;
 205 }
 206
 207 static struct snd_soc_ops tm2_aif2_ops = {
 208         .hw_params = tm2_aif2_hw_params,
 209         .hw_free = tm2_aif2_hw_free,
 210 };
 211
 212 static int tm2_mic_bias(struct snd_soc_dapm_widget *w,
 213                                 struct snd_kcontrol *kcontrol, int event)
 214 {
 215         struct snd_soc_card *card = w->dapm->card;
 216         struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card);
 217
 218         switch (event) {
 219         case SND_SOC_DAPM_PRE_PMU:
 220                 gpiod_set_value_cansleep(priv->gpio_mic_bias,  1);
 221                 break;
 222         case SND_SOC_DAPM_POST_PMD:
 223                 gpiod_set_value_cansleep(priv->gpio_mic_bias,  0);
 224                 break;
 225         }
 226
 227         return 0;
 228 }
 229
 230 static int tm2_set_bias_level(struct snd_soc_card *card,
 231                                 struct snd_soc_dapm_context *dapm,
 232                                 enum snd_soc_bias_level level)
 233 {
 234         struct snd_soc_pcm_runtime *rtd;
 235
 236         rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
 237
 238         if (dapm->dev != rtd->codec_dai->dev)
 239                 return 0;
 240
 241         switch (level) {
 242         case SND_SOC_BIAS_STANDBY:
 243                 if (card->dapm.bias_level == SND_SOC_BIAS_OFF)
 244                         tm2_start_sysclk(card);
 245                 break;
 246         case SND_SOC_BIAS_OFF:
 247                 tm2_stop_sysclk(card);
 248                 break;
 249         default:
 250                 break;
 251         }
 252
 253         return 0;
 254 }
 255
 256 static struct snd_soc_aux_dev tm2_speaker_amp_dev;
 257
 258 static int tm2_late_probe(struct snd_soc_card *card)
 259 {
 260         struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card);
 261         struct snd_soc_dai_link_component dlc = { 0 };
 262         unsigned int ch_map[] = { 0, 1 };
 263         struct snd_soc_dai *amp_pdm_dai;
 264         struct snd_soc_pcm_runtime *rtd;
 265         struct snd_soc_dai *aif1_dai;
 266         struct snd_soc_dai *aif2_dai;
 267         int ret;
 268
 269         rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF1].name);
 270         aif1_dai = rtd->codec_dai;
 271         priv->codec = rtd->codec;
 272
 273         ret = snd_soc_dai_set_sysclk(aif1_dai, ARIZONA_CLK_SYSCLK, 0, 0);
 274         if (ret < 0) {
 275                 dev_err(aif1_dai->dev, "Failed to set SYSCLK: %d\n", ret);
 276                 return ret;
 277         }
 278
 279         rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF2].name);
 280         aif2_dai = rtd->codec_dai;
 281
 282         ret = snd_soc_dai_set_sysclk(aif2_dai, ARIZONA_CLK_ASYNCCLK, 0, 0);
 283         if (ret < 0) {
 284                 dev_err(aif2_dai->dev, "Failed to set ASYNCCLK: %d\n", ret);
 285                 return ret;
 286         }
 287
 288         dlc.of_node = tm2_speaker_amp_dev.codec_of_node;
 289         amp_pdm_dai = snd_soc_find_dai(&dlc);
 290         if (!amp_pdm_dai)
 291                 return -ENODEV;
 292
 293         /* Set the MAX98504 V/I sense PDM Tx DAI channel mapping */
 294         ret = snd_soc_dai_set_channel_map(amp_pdm_dai, ARRAY_SIZE(ch_map),
 295                                           ch_map, 0, NULL);
 296         if (ret < 0)
 297                 return ret;
 298
 299         ret = snd_soc_dai_set_tdm_slot(amp_pdm_dai, 0x3, 0x0, 2, 16);
 300         if (ret < 0)
 301                 return ret;
 302
 303         return 0;
 304 }
 305
 306 static const struct snd_kcontrol_new tm2_controls[] = {
 307         SOC_DAPM_PIN_SWITCH("HP"),
 308         SOC_DAPM_PIN_SWITCH("SPK"),
 309         SOC_DAPM_PIN_SWITCH("RCV"),
 310         SOC_DAPM_PIN_SWITCH("VPS"),
 311         SOC_DAPM_PIN_SWITCH("HDMI"),
 312
 313         SOC_DAPM_PIN_SWITCH("Main Mic"),
 314         SOC_DAPM_PIN_SWITCH("Sub Mic"),
 315         SOC_DAPM_PIN_SWITCH("Third Mic"),
 316
 317         SOC_DAPM_PIN_SWITCH("Headset Mic"),
 318 };
 319
 320 const struct snd_soc_dapm_widget tm2_dapm_widgets[] = {
 321         SND_SOC_DAPM_HP("HP", NULL),
 322         SND_SOC_DAPM_SPK("SPK", NULL),
 323         SND_SOC_DAPM_SPK("RCV", NULL),
 324         SND_SOC_DAPM_LINE("VPS", NULL),
 325         SND_SOC_DAPM_LINE("HDMI", NULL),
 326
 327         SND_SOC_DAPM_MIC("Main Mic", tm2_mic_bias),
 328         SND_SOC_DAPM_MIC("Sub Mic", NULL),
 329         SND_SOC_DAPM_MIC("Third Mic", NULL),
 330
 331         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 332 };
 333
 334 static const struct snd_soc_component_driver tm2_component = {
 335         .name   = "tm2-audio",
 336 };
 337
 338 static struct snd_soc_dai_driver tm2_ext_dai[] = {
 339         {
 340                 .name = "Voice call",
 341                 .playback = {
 342                         .channels_min = 1,
 343                         .channels_max = 4,
 344                         .rate_min = 8000,
 345                         .rate_max = 48000,
 346                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
 347                                         SNDRV_PCM_RATE_48000),
 348                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 349                 },
 350                 .capture = {
 351                         .channels_min = 1,
 352                         .channels_max = 4,
 353                         .rate_min = 8000,
 354                         .rate_max = 48000,
 355                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
 356                                         SNDRV_PCM_RATE_48000),
 357                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 358                 },
 359         },
 360         {
 361                 .name = "Bluetooth",
 362                 .playback = {
 363                         .channels_min = 1,
 364                         .channels_max = 4,
 365                         .rate_min = 8000,
 366                         .rate_max = 16000,
 367                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000),
 368                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 369                 },
 370                 .capture = {
 371                         .channels_min = 1,
 372                         .channels_max = 2,
 373                         .rate_min = 8000,
 374                         .rate_max = 16000,
 375                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000),
 376                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 377                 },
 378         },
 379 };
 380
 381 static struct snd_soc_dai_link tm2_dai_links[] = {
 382         {
 383                 .name           = "WM5110 AIF1",
 384                 .stream_name    = "HiFi Primary",
 385                 .codec_dai_name = "wm5110-aif1",
 386                 .ops            = &tm2_aif1_ops,
 387                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 388                                   SND_SOC_DAIFMT_CBM_CFM,
 389         }, {
 390                 .name           = "WM5110 Voice",
 391                 .stream_name    = "Voice call",
 392                 .codec_dai_name = "wm5110-aif2",
 393                 .ops            = &tm2_aif2_ops,
 394                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 395                                   SND_SOC_DAIFMT_CBM_CFM,
 396                 .ignore_suspend = 1,
 397         }, {
 398                 .name           = "WM5110 BT",
 399                 .stream_name    = "Bluetooth",
 400                 .codec_dai_name = "wm5110-aif3",
 401                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 402                                   SND_SOC_DAIFMT_CBM_CFM,
 403                 .ignore_suspend = 1,
 404         }
 405 };
 406
 407 static struct snd_soc_card tm2_card = {
 408         .owner                  = THIS_MODULE,
 409
 410         .dai_link               = tm2_dai_links,
 411         .num_links              = ARRAY_SIZE(tm2_dai_links),
 412         .controls               = tm2_controls,
 413         .num_controls           = ARRAY_SIZE(tm2_controls),
 414         .dapm_widgets           = tm2_dapm_widgets,
 415         .num_dapm_widgets       = ARRAY_SIZE(tm2_dapm_widgets),
 416         .aux_dev                = &tm2_speaker_amp_dev,
 417         .num_aux_devs           = 1,
 418
 419         .late_probe             = tm2_late_probe,
 420         .set_bias_level         = tm2_set_bias_level,
 421 };
 422
 423 static int tm2_probe(struct platform_device *pdev)
 424 {
 425         struct device *dev = &pdev->dev;
 426         struct snd_soc_card *card = &tm2_card;
 427         struct tm2_machine_priv *priv;
 428         struct device_node *cpu_dai_node, *codec_dai_node;
 429         int ret, i;
 430
 431         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 432         if (!priv)
 433                 return -ENOMEM;
 434
 435         snd_soc_card_set_drvdata(card, priv);
 436         card->dev = dev;
 437
 438         priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias",
 439                                                 GPIOF_OUT_INIT_LOW);
 440         if (IS_ERR(priv->gpio_mic_bias)) {
 441                 dev_err(dev, "Failed to get mic bias gpio\n");
 442                 return PTR_ERR(priv->gpio_mic_bias);
 443         }
 444
 445         ret = snd_soc_of_parse_card_name(card, "model");
 446         if (ret < 0) {
 447                 dev_err(dev, "Card name is not specified\n");
 448                 return ret;
 449         }
 450
 451         ret = snd_soc_of_parse_audio_routing(card, "samsung,audio-routing");
 452         if (ret < 0) {
 453                 dev_err(dev, "Audio routing is not specified or invalid\n");
 454                 return ret;
 455         }
 456
 457         card->aux_dev[0].codec_of_node = of_parse_phandle(dev->of_node,
 458                                                         "audio-amplifier", 0);
 459         if (!card->aux_dev[0].codec_of_node) {
 460                 dev_err(dev, "audio-amplifier property invalid or missing\n");
 461                 return -EINVAL;
 462         }
 463
 464         cpu_dai_node = of_parse_phandle(dev->of_node, "i2s-controller", 0);
 465         if (!cpu_dai_node) {
 466                 dev_err(dev, "i2s-controllers property invalid or missing\n");
 467                 ret = -EINVAL;
 468                 goto amp_node_put;
 469         }
 470
 471         codec_dai_node = of_parse_phandle(dev->of_node, "audio-codec", 0);
 472         if (!codec_dai_node) {
 473                 dev_err(dev, "audio-codec property invalid or missing\n");
 474                 ret = -EINVAL;
 475                 goto cpu_dai_node_put;
 476         }
 477
 478         for (i = 0; i < card->num_links; i++) {
 479                 card->dai_link[i].cpu_dai_name = NULL;
 480                 card->dai_link[i].cpu_name = NULL;
 481                 card->dai_link[i].platform_name = NULL;
 482                 card->dai_link[i].codec_of_node = codec_dai_node;
 483                 card->dai_link[i].cpu_of_node = cpu_dai_node;
 484                 card->dai_link[i].platform_of_node = cpu_dai_node;
 485         }
 486
 487         ret = devm_snd_soc_register_component(dev, &tm2_component,
 488                                 tm2_ext_dai, ARRAY_SIZE(tm2_ext_dai));
 489         if (ret < 0) {
 490                 dev_err(dev, "Failed to register component: %d\n", ret);
 491                 goto codec_dai_node_put;
 492         }
 493
 494         ret = devm_snd_soc_register_card(dev, card);
 495         if (ret < 0) {
 496                 dev_err(dev, "Failed to register card: %d\n", ret);
 497                 goto codec_dai_node_put;
 498         }
 499
 500 codec_dai_node_put:
 501         of_node_put(codec_dai_node);
 502 cpu_dai_node_put:
 503         of_node_put(cpu_dai_node);
 504 amp_node_put:
 505         of_node_put(card->aux_dev[0].codec_of_node);
 506         return ret;
 507 }
 508
 509 static int tm2_pm_prepare(struct device *dev)
 510 {
 511         struct snd_soc_card *card = dev_get_drvdata(dev);
 512
 513         return tm2_stop_sysclk(card);
 514 }
 515
 516 static void tm2_pm_complete(struct device *dev)
 517 {
 518         struct snd_soc_card *card = dev_get_drvdata(dev);
 519
 520         tm2_start_sysclk(card);
 521 }
 522
 523 const struct dev_pm_ops tm2_pm_ops = {
 524         .prepare        = tm2_pm_prepare,
 525         .suspend        = snd_soc_suspend,
 526         .resume         = snd_soc_resume,
 527         .complete       = tm2_pm_complete,
 528         .freeze         = snd_soc_suspend,
 529         .thaw           = snd_soc_resume,
 530         .poweroff       = snd_soc_poweroff,
 531         .restore        = snd_soc_resume,
 532 };
 533
 534 static const struct of_device_id tm2_of_match[] = {
 535         { .compatible = "samsung,tm2-audio" },
 536         { },
 537 };
 538 MODULE_DEVICE_TABLE(of, tm2_of_match);
 539
 540 static struct platform_driver tm2_driver = {
 541         .driver = {
 542                 .name           = "tm2-audio",
 543                 .pm             = &tm2_pm_ops,
 544                 .of_match_table = tm2_of_match,
 545         },
 546         .probe  = tm2_probe,
 547 };
 548 module_platform_driver(tm2_driver);
 549
 550 MODULE_AUTHOR("Inha Song <ideal.song@samsung.com>");
 551 MODULE_DESCRIPTION("ALSA SoC Exynos TM2 Audio Support");
 552 MODULE_LICENSE("GPL v2");