sound/soc/qcom/sdm845.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/module.h>
   7 #include <linux/platform_device.h>
   8 #include <linux/of_device.h>
   9 #include <sound/core.h>
  10 #include <sound/pcm.h>
  11 #include <sound/pcm_params.h>
  12 #include <sound/jack.h>
  13 #include <sound/soc.h>
  14 #include <uapi/linux/input-event-codes.h>
  15 #include "common.h"
  16 #include "qdsp6/q6afe.h"
  17 #include "../codecs/rt5663.h"
  18
  19 #define DEFAULT_SAMPLE_RATE_48K         48000
  20 #define DEFAULT_MCLK_RATE               24576000
  21 #define TDM_BCLK_RATE           6144000
  22 #define MI2S_BCLK_RATE          1536000
  23 #define LEFT_SPK_TDM_TX_MASK    0x30
  24 #define RIGHT_SPK_TDM_TX_MASK   0xC0
  25 #define SPK_TDM_RX_MASK         0x03
  26 #define NUM_TDM_SLOTS           8
  27 #define SLIM_MAX_TX_PORTS 16
  28 #define SLIM_MAX_RX_PORTS 16
  29 #define WCD934X_DEFAULT_MCLK_RATE       9600000
  30
  31 struct sdm845_snd_data {
  32         struct snd_soc_jack jack;
  33         bool jack_setup;
  34         struct snd_soc_card *card;
  35         uint32_t pri_mi2s_clk_count;
  36         uint32_t sec_mi2s_clk_count;
  37         uint32_t quat_tdm_clk_count;
  38 };
  39
  40 static unsigned int tdm_slot_offset[8] = {0, 4, 8, 12, 16, 20, 24, 28};
  41
  42 static int sdm845_slim_snd_hw_params(struct snd_pcm_substream *substream,
  43                                      struct snd_pcm_hw_params *params)
  44 {
  45         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  46         struct snd_soc_dai_link *dai_link = rtd->dai_link;
  47         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
  48         u32 rx_ch[SLIM_MAX_RX_PORTS], tx_ch[SLIM_MAX_TX_PORTS];
  49         u32 rx_ch_cnt = 0, tx_ch_cnt = 0;
  50         int ret = 0, i;
  51
  52         for (i = 0 ; i < dai_link->num_codecs; i++) {
  53                 ret = snd_soc_dai_get_channel_map(rtd->codec_dais[i],
  54                                 &tx_ch_cnt, tx_ch, &rx_ch_cnt, rx_ch);
  55
  56                 if (ret != 0 && ret != -ENOTSUPP) {
  57                         pr_err("failed to get codec chan map, err:%d\n", ret);
  58                         return ret;
  59                 } else if (ret == -ENOTSUPP) {
  60                         /* Ignore unsupported */
  61                         continue;
  62                 }
  63
  64                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  65                         ret = snd_soc_dai_set_channel_map(cpu_dai, 0, NULL,
  66                                                           rx_ch_cnt, rx_ch);
  67                 else
  68                         ret = snd_soc_dai_set_channel_map(cpu_dai, tx_ch_cnt,
  69                                                           tx_ch, 0, NULL);
  70         }
  71
  72         return 0;
  73 }
  74
  75 static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream *substream,
  76                                         struct snd_pcm_hw_params *params)
  77 {
  78         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  79         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
  80         int ret = 0, j;
  81         int channels, slot_width;
  82
  83         switch (params_format(params)) {
  84         case SNDRV_PCM_FORMAT_S16_LE:
  85                 slot_width = 16;
  86                 break;
  87         default:
  88                 dev_err(rtd->dev, "%s: invalid param format 0x%x\n",
  89                                 __func__, params_format(params));
  90                 return -EINVAL;
  91         }
  92
  93         channels = params_channels(params);
  94         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  95                 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0, 0x3,
  96                                 8, slot_width);
  97                 if (ret < 0) {
  98                         dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
  99                                         __func__, ret);
 100                         goto end;
 101                 }
 102
 103                 ret = snd_soc_dai_set_channel_map(cpu_dai, 0, NULL,
 104                                 channels, tdm_slot_offset);
 105                 if (ret < 0) {
 106                         dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
 107                                         __func__, ret);
 108                         goto end;
 109                 }
 110         } else {
 111                 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xf, 0,
 112                                 8, slot_width);
 113                 if (ret < 0) {
 114                         dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
 115                                         __func__, ret);
 116                         goto end;
 117                 }
 118
 119                 ret = snd_soc_dai_set_channel_map(cpu_dai, channels,
 120                                 tdm_slot_offset, 0, NULL);
 121                 if (ret < 0) {
 122                         dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
 123                                         __func__, ret);
 124                         goto end;
 125                 }
 126         }
 127
 128         for (j = 0; j < rtd->num_codecs; j++) {
 129                 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
 130
 131                 if (!strcmp(codec_dai->component->name_prefix, "Left")) {
 132                         ret = snd_soc_dai_set_tdm_slot(
 133                                         codec_dai, LEFT_SPK_TDM_TX_MASK,
 134                                         SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
 135                                         slot_width);
 136                         if (ret < 0) {
 137                                 dev_err(rtd->dev,
 138                                         "DEV0 TDM slot err:%d\n", ret);
 139                                 return ret;
 140                         }
 141                 }
 142
 143                 if (!strcmp(codec_dai->component->name_prefix, "Right")) {
 144                         ret = snd_soc_dai_set_tdm_slot(
 145                                         codec_dai, RIGHT_SPK_TDM_TX_MASK,
 146                                         SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
 147                                         slot_width);
 148                         if (ret < 0) {
 149                                 dev_err(rtd->dev,
 150                                         "DEV1 TDM slot err:%d\n", ret);
 151                                 return ret;
 152                         }
 153                 }
 154         }
 155
 156 end:
 157         return ret;
 158 }
 159
 160 static int sdm845_snd_hw_params(struct snd_pcm_substream *substream,
 161                                         struct snd_pcm_hw_params *params)
 162 {
 163         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 164         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 165         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 166         int ret = 0;
 167
 168         switch (cpu_dai->id) {
 169         case PRIMARY_MI2S_RX:
 170         case PRIMARY_MI2S_TX:
 171                 /*
 172                  * Use ASRC for internal clocks, as PLL rate isn't multiple
 173                  * of BCLK.
 174                  */
 175                 rt5663_sel_asrc_clk_src(
 176                         codec_dai->component,
 177                         RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
 178                         RT5663_CLK_SEL_I2S1_ASRC);
 179                 ret = snd_soc_dai_set_sysclk(
 180                         codec_dai, RT5663_SCLK_S_MCLK, DEFAULT_MCLK_RATE,
 181                         SND_SOC_CLOCK_IN);
 182                 if (ret < 0)
 183                         dev_err(rtd->dev,
 184                                 "snd_soc_dai_set_sysclk err = %d\n", ret);
 185                 break;
 186         case QUATERNARY_TDM_RX_0:
 187         case QUATERNARY_TDM_TX_0:
 188                 ret = sdm845_tdm_snd_hw_params(substream, params);
 189                 break;
 190         case SLIMBUS_0_RX...SLIMBUS_6_TX:
 191                 ret = sdm845_slim_snd_hw_params(substream, params);
 192                 break;
 193         case QUATERNARY_MI2S_RX:
 194                 break;
 195         default:
 196                 pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
 197                 break;
 198         }
 199         return ret;
 200 }
 201
 202 static void sdm845_jack_free(struct snd_jack *jack)
 203 {
 204         struct snd_soc_component *component = jack->private_data;
 205
 206         snd_soc_component_set_jack(component, NULL, NULL);
 207 }
 208
 209 static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd)
 210 {
 211         struct snd_soc_component *component;
 212         struct snd_soc_card *card = rtd->card;
 213         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 214         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 215         struct sdm845_snd_data *pdata = snd_soc_card_get_drvdata(card);
 216         struct snd_jack *jack;
 217         struct snd_soc_dai_link *dai_link = rtd->dai_link;
 218         /*
 219          * Codec SLIMBUS configuration
 220          * RX1, RX2, RX3, RX4, RX5, RX6, RX7, RX8, RX9, RX10, RX11, RX12, RX13
 221          * TX1, TX2, TX3, TX4, TX5, TX6, TX7, TX8, TX9, TX10, TX11, TX12, TX13
 222          * TX14, TX15, TX16
 223          */
 224         unsigned int rx_ch[SLIM_MAX_RX_PORTS] = {144, 145, 146, 147, 148, 149,
 225                                         150, 151, 152, 153, 154, 155, 156};
 226         unsigned int tx_ch[SLIM_MAX_TX_PORTS] = {128, 129, 130, 131, 132, 133,
 227                                             134, 135, 136, 137, 138, 139,
 228                                             140, 141, 142, 143};
 229         int rval, i;
 230
 231
 232         if (!pdata->jack_setup) {
 233                 rval = snd_soc_card_jack_new(card, "Headset Jack",
 234                                 SND_JACK_HEADSET |
 235                                 SND_JACK_HEADPHONE |
 236                                 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 237                                 SND_JACK_BTN_2 | SND_JACK_BTN_3,
 238                                 &pdata->jack, NULL, 0);
 239
 240                 if (rval < 0) {
 241                         dev_err(card->dev, "Unable to add Headphone Jack\n");
 242                         return rval;
 243                 }
 244
 245                 jack = pdata->jack.jack;
 246
 247                 snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
 248                 snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
 249                 snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
 250                 snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
 251                 pdata->jack_setup = true;
 252         }
 253
 254         switch (cpu_dai->id) {
 255         case PRIMARY_MI2S_RX:
 256                 jack  = pdata->jack.jack;
 257                 component = codec_dai->component;
 258
 259                 jack->private_data = component;
 260                 jack->private_free = sdm845_jack_free;
 261                 rval = snd_soc_component_set_jack(component,
 262                                                   &pdata->jack, NULL);
 263                 if (rval != 0 && rval != -ENOTSUPP) {
 264                         dev_warn(card->dev, "Failed to set jack: %d\n", rval);
 265                         return rval;
 266                 }
 267                 break;
 268         case SLIMBUS_0_RX...SLIMBUS_6_TX:
 269                 for (i = 0 ; i < dai_link->num_codecs; i++) {
 270                         rval = snd_soc_dai_set_channel_map(rtd->codec_dais[i],
 271                                                           ARRAY_SIZE(tx_ch),
 272                                                           tx_ch,
 273                                                           ARRAY_SIZE(rx_ch),
 274                                                           rx_ch);
 275                         if (rval != 0 && rval != -ENOTSUPP)
 276                                 return rval;
 277
 278                         snd_soc_dai_set_sysclk(rtd->codec_dais[i], 0,
 279                                                WCD934X_DEFAULT_MCLK_RATE,
 280                                                SNDRV_PCM_STREAM_PLAYBACK);
 281                 }
 282                 break;
 283         default:
 284                 break;
 285         }
 286
 287         return 0;
 288 }
 289
 290
 291 static int sdm845_snd_startup(struct snd_pcm_substream *substream)
 292 {
 293         unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS;
 294         unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS;
 295         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 296         struct snd_soc_card *card = rtd->card;
 297         struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
 298         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 299         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 300         int j;
 301         int ret;
 302
 303         switch (cpu_dai->id) {
 304         case PRIMARY_MI2S_RX:
 305         case PRIMARY_MI2S_TX:
 306                 codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF;
 307                 if (++(data->pri_mi2s_clk_count) == 1) {
 308                         snd_soc_dai_set_sysclk(cpu_dai,
 309                                 Q6AFE_LPASS_CLK_ID_MCLK_1,
 310                                 DEFAULT_MCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
 311                         snd_soc_dai_set_sysclk(cpu_dai,
 312                                 Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
 313                                 MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
 314                 }
 315                 snd_soc_dai_set_fmt(cpu_dai, fmt);
 316                 snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
 317                 break;
 318
 319         case SECONDARY_MI2S_TX:
 320                 codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_I2S;
 321                 if (++(data->sec_mi2s_clk_count) == 1) {
 322                         snd_soc_dai_set_sysclk(cpu_dai,
 323                                 Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
 324                                 MI2S_BCLK_RATE, SNDRV_PCM_STREAM_CAPTURE);
 325                 }
 326                 snd_soc_dai_set_fmt(cpu_dai, fmt);
 327                 snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
 328                 break;
 329         case QUATERNARY_MI2S_RX:
 330                 snd_soc_dai_set_sysclk(cpu_dai,
 331                         Q6AFE_LPASS_CLK_ID_QUAD_MI2S_IBIT,
 332                         MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
 333                 snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_CBS_CFS);
 334
 335
 336                 break;
 337
 338         case QUATERNARY_TDM_RX_0:
 339         case QUATERNARY_TDM_TX_0:
 340                 if (++(data->quat_tdm_clk_count) == 1) {
 341                         snd_soc_dai_set_sysclk(cpu_dai,
 342                                 Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
 343                                 TDM_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
 344                 }
 345
 346                 codec_dai_fmt |= SND_SOC_DAIFMT_IB_NF | SND_SOC_DAIFMT_DSP_B;
 347
 348                 for (j = 0; j < rtd->num_codecs; j++) {
 349                         codec_dai = rtd->codec_dais[j];
 350
 351                         if (!strcmp(codec_dai->component->name_prefix,
 352                                     "Left")) {
 353                                 ret = snd_soc_dai_set_fmt(
 354                                                 codec_dai, codec_dai_fmt);
 355                                 if (ret < 0) {
 356                                         dev_err(rtd->dev,
 357                                                 "Left TDM fmt err:%d\n", ret);
 358                                         return ret;
 359                                 }
 360                         }
 361
 362                         if (!strcmp(codec_dai->component->name_prefix,
 363                                     "Right")) {
 364                                 ret = snd_soc_dai_set_fmt(
 365                                                 codec_dai, codec_dai_fmt);
 366                                 if (ret < 0) {
 367                                         dev_err(rtd->dev,
 368                                                 "Right TDM slot err:%d\n", ret);
 369                                         return ret;
 370                                 }
 371                         }
 372                 }
 373                 break;
 374         case SLIMBUS_0_RX...SLIMBUS_6_TX:
 375                 break;
 376
 377         default:
 378                 pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
 379                 break;
 380         }
 381         return 0;
 382 }
 383
 384 static void  sdm845_snd_shutdown(struct snd_pcm_substream *substream)
 385 {
 386         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 387         struct snd_soc_card *card = rtd->card;
 388         struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
 389         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 390
 391         switch (cpu_dai->id) {
 392         case PRIMARY_MI2S_RX:
 393         case PRIMARY_MI2S_TX:
 394                 if (--(data->pri_mi2s_clk_count) == 0) {
 395                         snd_soc_dai_set_sysclk(cpu_dai,
 396                                 Q6AFE_LPASS_CLK_ID_MCLK_1,
 397                                 0, SNDRV_PCM_STREAM_PLAYBACK);
 398                         snd_soc_dai_set_sysclk(cpu_dai,
 399                                 Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
 400                                 0, SNDRV_PCM_STREAM_PLAYBACK);
 401                 }
 402                 break;
 403
 404         case SECONDARY_MI2S_TX:
 405                 if (--(data->sec_mi2s_clk_count) == 0) {
 406                         snd_soc_dai_set_sysclk(cpu_dai,
 407                                 Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
 408                                 0, SNDRV_PCM_STREAM_CAPTURE);
 409                 }
 410                 break;
 411
 412         case QUATERNARY_TDM_RX_0:
 413         case QUATERNARY_TDM_TX_0:
 414                 if (--(data->quat_tdm_clk_count) == 0) {
 415                         snd_soc_dai_set_sysclk(cpu_dai,
 416                                 Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
 417                                 0, SNDRV_PCM_STREAM_PLAYBACK);
 418                 }
 419                 break;
 420         case SLIMBUS_0_RX...SLIMBUS_6_TX:
 421         case QUATERNARY_MI2S_RX:
 422                 break;
 423
 424         default:
 425                 pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
 426                 break;
 427         }
 428 }
 429
 430 static const struct snd_soc_ops sdm845_be_ops = {
 431         .hw_params = sdm845_snd_hw_params,
 432         .startup = sdm845_snd_startup,
 433         .shutdown = sdm845_snd_shutdown,
 434 };
 435
 436 static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
 437                                 struct snd_pcm_hw_params *params)
 438 {
 439         struct snd_interval *rate = hw_param_interval(params,
 440                                         SNDRV_PCM_HW_PARAM_RATE);
 441         struct snd_interval *channels = hw_param_interval(params,
 442                                         SNDRV_PCM_HW_PARAM_CHANNELS);
 443         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 444
 445         rate->min = rate->max = DEFAULT_SAMPLE_RATE_48K;
 446         channels->min = channels->max = 2;
 447         snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
 448
 449         return 0;
 450 }
 451
 452 static const struct snd_soc_dapm_widget sdm845_snd_widgets[] = {
 453         SND_SOC_DAPM_HP("Headphone Jack", NULL),
 454         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 455         SND_SOC_DAPM_SPK("Left Spk", NULL),
 456         SND_SOC_DAPM_SPK("Right Spk", NULL),
 457         SND_SOC_DAPM_MIC("Int Mic", NULL),
 458 };
 459
 460 static void sdm845_add_ops(struct snd_soc_card *card)
 461 {
 462         struct snd_soc_dai_link *link;
 463         int i;
 464
 465         for_each_card_prelinks(card, i, link) {
 466                 if (link->no_pcm == 1) {
 467                         link->ops = &sdm845_be_ops;
 468                         link->be_hw_params_fixup = sdm845_be_hw_params_fixup;
 469                 }
 470                 link->init = sdm845_dai_init;
 471         }
 472 }
 473
 474 static int sdm845_snd_platform_probe(struct platform_device *pdev)
 475 {
 476         struct snd_soc_card *card;
 477         struct sdm845_snd_data *data;
 478         struct device *dev = &pdev->dev;
 479         int ret;
 480
 481         card = kzalloc(sizeof(*card), GFP_KERNEL);
 482         if (!card)
 483                 return -ENOMEM;
 484
 485         /* Allocate the private data */
 486         data = kzalloc(sizeof(*data), GFP_KERNEL);
 487         if (!data) {
 488                 ret = -ENOMEM;
 489                 goto data_alloc_fail;
 490         }
 491
 492         card->dapm_widgets = sdm845_snd_widgets;
 493         card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets);
 494         card->dev = dev;
 495         dev_set_drvdata(dev, card);
 496         ret = qcom_snd_parse_of(card);
 497         if (ret) {
 498                 dev_err(dev, "Error parsing OF data\n");
 499                 goto parse_dt_fail;
 500         }
 501
 502         data->card = card;
 503         snd_soc_card_set_drvdata(card, data);
 504
 505         sdm845_add_ops(card);
 506         ret = snd_soc_register_card(card);
 507         if (ret) {
 508                 dev_err(dev, "Sound card registration failed\n");
 509                 goto register_card_fail;
 510         }
 511         return ret;
 512
 513 register_card_fail:
 514         kfree(card->dai_link);
 515 parse_dt_fail:
 516         kfree(data);
 517 data_alloc_fail:
 518         kfree(card);
 519         return ret;
 520 }
 521
 522 static int sdm845_snd_platform_remove(struct platform_device *pdev)
 523 {
 524         struct snd_soc_card *card = dev_get_drvdata(&pdev->dev);
 525         struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
 526
 527         snd_soc_unregister_card(card);
 528         kfree(card->dai_link);
 529         kfree(data);
 530         kfree(card);
 531         return 0;
 532 }
 533
 534 static const struct of_device_id sdm845_snd_device_id[]  = {
 535         { .compatible = "qcom,sdm845-sndcard" },
 536         { .compatible = "qcom,db845c-sndcard" },
 537         { .compatible = "lenovo,yoga-c630-sndcard" },
 538         {},
 539 };
 540 MODULE_DEVICE_TABLE(of, sdm845_snd_device_id);
 541
 542 static struct platform_driver sdm845_snd_driver = {
 543         .probe = sdm845_snd_platform_probe,
 544         .remove = sdm845_snd_platform_remove,
 545         .driver = {
 546                 .name = "msm-snd-sdm845",
 547                 .of_match_table = sdm845_snd_device_id,
 548         },
 549 };
 550 module_platform_driver(sdm845_snd_driver);
 551
 552 MODULE_DESCRIPTION("sdm845 ASoC Machine Driver");
 553 MODULE_LICENSE("GPL v2");