sound/soc/intel/boards/sof_cs42l42.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright(c) 2021 Intel Corporation.
   3
   4 /*
   5  * Intel SOF Machine Driver with Cirrus Logic CS42L42 Codec
   6  * and speaker codec MAX98357A
   7  */
   8 #include <linux/i2c.h>
   9 #include <linux/input.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/regulator/consumer.h>
  13 #include <linux/dmi.h>
  14 #include <sound/core.h>
  15 #include <sound/jack.h>
  16 #include <sound/pcm.h>
  17 #include <sound/pcm_params.h>
  18 #include <sound/soc.h>
  19 #include <sound/sof.h>
  20 #include <sound/soc-acpi.h>
  21 #include <dt-bindings/sound/cs42l42.h>
  22 #include "../../codecs/hdac_hdmi.h"
  23 #include "../common/soc-intel-quirks.h"
  24 #include "hda_dsp_common.h"
  25 #include "sof_maxim_common.h"
  26
  27 #define NAME_SIZE 32
  28
  29 #define SOF_CS42L42_SSP_CODEC(quirk)            ((quirk) & GENMASK(2, 0))
  30 #define SOF_CS42L42_SSP_CODEC_MASK              (GENMASK(2, 0))
  31 #define SOF_SPEAKER_AMP_PRESENT                 BIT(3)
  32 #define SOF_CS42L42_SSP_AMP_SHIFT               4
  33 #define SOF_CS42L42_SSP_AMP_MASK                (GENMASK(6, 4))
  34 #define SOF_CS42L42_SSP_AMP(quirk)      \
  35         (((quirk) << SOF_CS42L42_SSP_AMP_SHIFT) & SOF_CS42L42_SSP_AMP_MASK)
  36 #define SOF_CS42L42_NUM_HDMIDEV_SHIFT           7
  37 #define SOF_CS42L42_NUM_HDMIDEV_MASK            (GENMASK(9, 7))
  38 #define SOF_CS42L42_NUM_HDMIDEV(quirk)  \
  39         (((quirk) << SOF_CS42L42_NUM_HDMIDEV_SHIFT) & SOF_CS42L42_NUM_HDMIDEV_MASK)
  40 #define SOF_CS42L42_DAILINK_SHIFT               10
  41 #define SOF_CS42L42_DAILINK_MASK                (GENMASK(24, 10))
  42 #define SOF_CS42L42_DAILINK(link1, link2, link3, link4, link5) \
  43         ((((link1) | ((link2) << 3) | ((link3) << 6) | ((link4) << 9) | ((link5) << 12)) << SOF_CS42L42_DAILINK_SHIFT) & SOF_CS42L42_DAILINK_MASK)
  44 #define SOF_MAX98357A_SPEAKER_AMP_PRESENT       BIT(25)
  45 #define SOF_MAX98360A_SPEAKER_AMP_PRESENT       BIT(26)
  46
  47 enum {
  48         LINK_NONE = 0,
  49         LINK_HP = 1,
  50         LINK_SPK = 2,
  51         LINK_DMIC = 3,
  52         LINK_HDMI = 4,
  53 };
  54
  55 /* Default: SSP2 */
  56 static unsigned long sof_cs42l42_quirk = SOF_CS42L42_SSP_CODEC(2);
  57
  58 struct sof_hdmi_pcm {
  59         struct list_head head;
  60         struct snd_soc_dai *codec_dai;
  61         struct snd_soc_jack hdmi_jack;
  62         int device;
  63 };
  64
  65 struct sof_card_private {
  66         struct snd_soc_jack headset_jack;
  67         struct list_head hdmi_pcm_list;
  68         bool common_hdmi_codec_drv;
  69 };
  70
  71 static int sof_hdmi_init(struct snd_soc_pcm_runtime *rtd)
  72 {
  73         struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
  74         struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
  75         struct sof_hdmi_pcm *pcm;
  76
  77         pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
  78         if (!pcm)
  79                 return -ENOMEM;
  80
  81         /* dai_link id is 1:1 mapped to the PCM device */
  82         pcm->device = rtd->dai_link->id;
  83         pcm->codec_dai = dai;
  84
  85         list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
  86
  87         return 0;
  88 }
  89
  90 static int sof_cs42l42_init(struct snd_soc_pcm_runtime *rtd)
  91 {
  92         struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
  93         struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
  94         struct snd_soc_jack *jack = &ctx->headset_jack;
  95         int ret;
  96
  97         /*
  98          * Headset buttons map to the google Reference headset.
  99          * These can be configured by userspace.
 100          */
 101         ret = snd_soc_card_jack_new(rtd->card, "Headset Jack",
 102                                     SND_JACK_HEADSET | SND_JACK_BTN_0 |
 103                                     SND_JACK_BTN_1 | SND_JACK_BTN_2 |
 104                                     SND_JACK_BTN_3,
 105                                     jack);
 106         if (ret) {
 107                 dev_err(rtd->dev, "Headset Jack creation failed: %d\n", ret);
 108                 return ret;
 109         }
 110
 111         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
 112         snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
 113         snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
 114         snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
 115
 116         ret = snd_soc_component_set_jack(component, jack, NULL);
 117         if (ret) {
 118                 dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret);
 119                 return ret;
 120         }
 121
 122         return ret;
 123 };
 124
 125 static void sof_cs42l42_exit(struct snd_soc_pcm_runtime *rtd)
 126 {
 127         struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
 128
 129         snd_soc_component_set_jack(component, NULL, NULL);
 130 }
 131
 132 static int sof_cs42l42_hw_params(struct snd_pcm_substream *substream,
 133                                  struct snd_pcm_hw_params *params)
 134 {
 135         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 136         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 137         int clk_freq, ret;
 138
 139         clk_freq = sof_dai_get_bclk(rtd); /* BCLK freq */
 140
 141         if (clk_freq <= 0) {
 142                 dev_err(rtd->dev, "get bclk freq failed: %d\n", clk_freq);
 143                 return -EINVAL;
 144         }
 145
 146         /* Configure sysclk for codec */
 147         ret = snd_soc_dai_set_sysclk(codec_dai, 0,
 148                                      clk_freq, SND_SOC_CLOCK_IN);
 149         if (ret < 0)
 150                 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
 151
 152         return ret;
 153 }
 154
 155 static const struct snd_soc_ops sof_cs42l42_ops = {
 156         .hw_params = sof_cs42l42_hw_params,
 157 };
 158
 159 static struct snd_soc_dai_link_component platform_component[] = {
 160         {
 161                 /* name might be overridden during probe */
 162                 .name = "0000:00:1f.3"
 163         }
 164 };
 165
 166 static int sof_card_late_probe(struct snd_soc_card *card)
 167 {
 168         struct sof_card_private *ctx = snd_soc_card_get_drvdata(card);
 169         struct snd_soc_component *component = NULL;
 170         char jack_name[NAME_SIZE];
 171         struct sof_hdmi_pcm *pcm;
 172         int err;
 173
 174         if (list_empty(&ctx->hdmi_pcm_list))
 175                 return -EINVAL;
 176
 177         if (ctx->common_hdmi_codec_drv) {
 178                 pcm = list_first_entry(&ctx->hdmi_pcm_list, struct sof_hdmi_pcm,
 179                                        head);
 180                 component = pcm->codec_dai->component;
 181                 return hda_dsp_hdmi_build_controls(card, component);
 182         }
 183
 184         list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
 185                 component = pcm->codec_dai->component;
 186                 snprintf(jack_name, sizeof(jack_name),
 187                          "HDMI/DP, pcm=%d Jack", pcm->device);
 188                 err = snd_soc_card_jack_new(card, jack_name,
 189                                             SND_JACK_AVOUT, &pcm->hdmi_jack);
 190
 191                 if (err)
 192                         return err;
 193
 194                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
 195                                           &pcm->hdmi_jack);
 196                 if (err < 0)
 197                         return err;
 198         }
 199
 200         return hdac_hdmi_jack_port_init(component, &card->dapm);
 201 }
 202
 203 static const struct snd_kcontrol_new sof_controls[] = {
 204         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
 205         SOC_DAPM_PIN_SWITCH("Headset Mic"),
 206 };
 207
 208 static const struct snd_soc_dapm_widget sof_widgets[] = {
 209         SND_SOC_DAPM_HP("Headphone Jack", NULL),
 210         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 211 };
 212
 213 static const struct snd_soc_dapm_widget dmic_widgets[] = {
 214         SND_SOC_DAPM_MIC("SoC DMIC", NULL),
 215 };
 216
 217 static const struct snd_soc_dapm_route sof_map[] = {
 218         /* HP jack connectors - unknown if we have jack detection */
 219         {"Headphone Jack", NULL, "HP"},
 220
 221         /* other jacks */
 222         {"HS", NULL, "Headset Mic"},
 223 };
 224
 225 static const struct snd_soc_dapm_route dmic_map[] = {
 226         /* digital mics */
 227         {"DMic", NULL, "SoC DMIC"},
 228 };
 229
 230 static int dmic_init(struct snd_soc_pcm_runtime *rtd)
 231 {
 232         struct snd_soc_card *card = rtd->card;
 233         int ret;
 234
 235         ret = snd_soc_dapm_new_controls(&card->dapm, dmic_widgets,
 236                                         ARRAY_SIZE(dmic_widgets));
 237         if (ret) {
 238                 dev_err(card->dev, "DMic widget addition failed: %d\n", ret);
 239                 /* Don't need to add routes if widget addition failed */
 240                 return ret;
 241         }
 242
 243         ret = snd_soc_dapm_add_routes(&card->dapm, dmic_map,
 244                                       ARRAY_SIZE(dmic_map));
 245
 246         if (ret)
 247                 dev_err(card->dev, "DMic map addition failed: %d\n", ret);
 248
 249         return ret;
 250 }
 251
 252 /* sof audio machine driver for cs42l42 codec */
 253 static struct snd_soc_card sof_audio_card_cs42l42 = {
 254         .name = "cs42l42", /* the sof- prefix is added by the core */
 255         .owner = THIS_MODULE,
 256         .controls = sof_controls,
 257         .num_controls = ARRAY_SIZE(sof_controls),
 258         .dapm_widgets = sof_widgets,
 259         .num_dapm_widgets = ARRAY_SIZE(sof_widgets),
 260         .dapm_routes = sof_map,
 261         .num_dapm_routes = ARRAY_SIZE(sof_map),
 262         .fully_routed = true,
 263         .late_probe = sof_card_late_probe,
 264 };
 265
 266 static struct snd_soc_dai_link_component cs42l42_component[] = {
 267         {
 268                 .name = "i2c-10134242:00",
 269                 .dai_name = "cs42l42",
 270         }
 271 };
 272
 273 static struct snd_soc_dai_link_component dmic_component[] = {
 274         {
 275                 .name = "dmic-codec",
 276                 .dai_name = "dmic-hifi",
 277         }
 278 };
 279
 280 static int create_spk_amp_dai_links(struct device *dev,
 281                                     struct snd_soc_dai_link *links,
 282                                     struct snd_soc_dai_link_component *cpus,
 283                                     int *id, int ssp_amp)
 284 {
 285         int ret = 0;
 286
 287         /* speaker amp */
 288         if (!(sof_cs42l42_quirk & SOF_SPEAKER_AMP_PRESENT))
 289                 return 0;
 290
 291         links[*id].name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec",
 292                                          ssp_amp);
 293         if (!links[*id].name) {
 294                 ret = -ENOMEM;
 295                 goto devm_err;
 296         }
 297
 298         links[*id].id = *id;
 299
 300         if (sof_cs42l42_quirk & SOF_MAX98357A_SPEAKER_AMP_PRESENT) {
 301                 max_98357a_dai_link(&links[*id]);
 302         } else if (sof_cs42l42_quirk & SOF_MAX98360A_SPEAKER_AMP_PRESENT) {
 303                 max_98360a_dai_link(&links[*id]);
 304         } else {
 305                 dev_err(dev, "no amp defined\n");
 306                 ret = -EINVAL;
 307                 goto devm_err;
 308         }
 309
 310         links[*id].platforms = platform_component;
 311         links[*id].num_platforms = ARRAY_SIZE(platform_component);
 312         links[*id].dpcm_playback = 1;
 313         links[*id].no_pcm = 1;
 314         links[*id].cpus = &cpus[*id];
 315         links[*id].num_cpus = 1;
 316
 317         links[*id].cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL,
 318                                                    "SSP%d Pin", ssp_amp);
 319         if (!links[*id].cpus->dai_name) {
 320                 ret = -ENOMEM;
 321                 goto devm_err;
 322         }
 323
 324         (*id)++;
 325
 326 devm_err:
 327         return ret;
 328 }
 329
 330 static int create_hp_codec_dai_links(struct device *dev,
 331                                      struct snd_soc_dai_link *links,
 332                                      struct snd_soc_dai_link_component *cpus,
 333                                      int *id, int ssp_codec)
 334 {
 335         /* codec SSP */
 336         links[*id].name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec",
 337                                          ssp_codec);
 338         if (!links[*id].name)
 339                 goto devm_err;
 340
 341         links[*id].id = *id;
 342         links[*id].codecs = cs42l42_component;
 343         links[*id].num_codecs = ARRAY_SIZE(cs42l42_component);
 344         links[*id].platforms = platform_component;
 345         links[*id].num_platforms = ARRAY_SIZE(platform_component);
 346         links[*id].init = sof_cs42l42_init;
 347         links[*id].exit = sof_cs42l42_exit;
 348         links[*id].ops = &sof_cs42l42_ops;
 349         links[*id].dpcm_playback = 1;
 350         links[*id].dpcm_capture = 1;
 351         links[*id].no_pcm = 1;
 352         links[*id].cpus = &cpus[*id];
 353         links[*id].num_cpus = 1;
 354
 355         links[*id].cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL,
 356                                                    "SSP%d Pin",
 357                                                    ssp_codec);
 358         if (!links[*id].cpus->dai_name)
 359                 goto devm_err;
 360
 361         (*id)++;
 362
 363         return 0;
 364
 365 devm_err:
 366         return -ENOMEM;
 367 }
 368
 369 static int create_dmic_dai_links(struct device *dev,
 370                                  struct snd_soc_dai_link *links,
 371                                  struct snd_soc_dai_link_component *cpus,
 372                                  int *id, int dmic_be_num)
 373 {
 374         int i;
 375
 376         /* dmic */
 377         if (dmic_be_num <= 0)
 378                 return 0;
 379
 380         /* at least we have dmic01 */
 381         links[*id].name = "dmic01";
 382         links[*id].cpus = &cpus[*id];
 383         links[*id].cpus->dai_name = "DMIC01 Pin";
 384         links[*id].init = dmic_init;
 385         if (dmic_be_num > 1) {
 386                 /* set up 2 BE links at most */
 387                 links[*id + 1].name = "dmic16k";
 388                 links[*id + 1].cpus = &cpus[*id + 1];
 389                 links[*id + 1].cpus->dai_name = "DMIC16k Pin";
 390                 dmic_be_num = 2;
 391         }
 392
 393         for (i = 0; i < dmic_be_num; i++) {
 394                 links[*id].id = *id;
 395                 links[*id].num_cpus = 1;
 396                 links[*id].codecs = dmic_component;
 397                 links[*id].num_codecs = ARRAY_SIZE(dmic_component);
 398                 links[*id].platforms = platform_component;
 399                 links[*id].num_platforms = ARRAY_SIZE(platform_component);
 400                 links[*id].ignore_suspend = 1;
 401                 links[*id].dpcm_capture = 1;
 402                 links[*id].no_pcm = 1;
 403
 404                 (*id)++;
 405         }
 406
 407         return 0;
 408 }
 409
 410 static int create_hdmi_dai_links(struct device *dev,
 411                                  struct snd_soc_dai_link *links,
 412                                  struct snd_soc_dai_link_component *cpus,
 413                                  int *id, int hdmi_num)
 414 {
 415         struct snd_soc_dai_link_component *idisp_components;
 416         int i;
 417
 418         /* HDMI */
 419         if (hdmi_num <= 0)
 420                 return 0;
 421
 422         idisp_components = devm_kzalloc(dev,
 423                                         sizeof(struct snd_soc_dai_link_component) *
 424                                         hdmi_num, GFP_KERNEL);
 425         if (!idisp_components)
 426                 goto devm_err;
 427
 428         for (i = 1; i <= hdmi_num; i++) {
 429                 links[*id].name = devm_kasprintf(dev, GFP_KERNEL,
 430                                                  "iDisp%d", i);
 431                 if (!links[*id].name)
 432                         goto devm_err;
 433
 434                 links[*id].id = *id;
 435                 links[*id].cpus = &cpus[*id];
 436                 links[*id].num_cpus = 1;
 437                 links[*id].cpus->dai_name = devm_kasprintf(dev,
 438                                                            GFP_KERNEL,
 439                                                            "iDisp%d Pin",
 440                                                            i);
 441                 if (!links[*id].cpus->dai_name)
 442                         goto devm_err;
 443
 444                 idisp_components[i - 1].name = "ehdaudio0D2";
 445                 idisp_components[i - 1].dai_name = devm_kasprintf(dev,
 446                                                                   GFP_KERNEL,
 447                                                                   "intel-hdmi-hifi%d",
 448                                                                   i);
 449                 if (!idisp_components[i - 1].dai_name)
 450                         goto devm_err;
 451
 452                 links[*id].codecs = &idisp_components[i - 1];
 453                 links[*id].num_codecs = 1;
 454                 links[*id].platforms = platform_component;
 455                 links[*id].num_platforms = ARRAY_SIZE(platform_component);
 456                 links[*id].init = sof_hdmi_init;
 457                 links[*id].dpcm_playback = 1;
 458                 links[*id].no_pcm = 1;
 459
 460                 (*id)++;
 461         }
 462
 463         return 0;
 464
 465 devm_err:
 466         return -ENOMEM;
 467 }
 468
 469 static struct snd_soc_dai_link *sof_card_dai_links_create(struct device *dev,
 470                                                           int ssp_codec,
 471                                                           int ssp_amp,
 472                                                           int dmic_be_num,
 473                                                           int hdmi_num)
 474 {
 475         struct snd_soc_dai_link_component *cpus;
 476         struct snd_soc_dai_link *links;
 477         int ret, id = 0, link_seq;
 478
 479         links = devm_kzalloc(dev, sizeof(struct snd_soc_dai_link) *
 480                              sof_audio_card_cs42l42.num_links, GFP_KERNEL);
 481         cpus = devm_kzalloc(dev, sizeof(struct snd_soc_dai_link_component) *
 482                              sof_audio_card_cs42l42.num_links, GFP_KERNEL);
 483         if (!links || !cpus)
 484                 goto devm_err;
 485
 486         link_seq = (sof_cs42l42_quirk & SOF_CS42L42_DAILINK_MASK) >> SOF_CS42L42_DAILINK_SHIFT;
 487
 488         while (link_seq) {
 489                 int link_type = link_seq & 0x07;
 490
 491                 switch (link_type) {
 492                 case LINK_HP:
 493                         ret = create_hp_codec_dai_links(dev, links, cpus, &id, ssp_codec);
 494                         if (ret < 0) {
 495                                 dev_err(dev, "fail to create hp codec dai links, ret %d\n",
 496                                         ret);
 497                                 goto devm_err;
 498                         }
 499                         break;
 500                 case LINK_SPK:
 501                         ret = create_spk_amp_dai_links(dev, links, cpus, &id, ssp_amp);
 502                         if (ret < 0) {
 503                                 dev_err(dev, "fail to create spk amp dai links, ret %d\n",
 504                                         ret);
 505                                 goto devm_err;
 506                         }
 507                         break;
 508                 case LINK_DMIC:
 509                         ret = create_dmic_dai_links(dev, links, cpus, &id, dmic_be_num);
 510                         if (ret < 0) {
 511                                 dev_err(dev, "fail to create dmic dai links, ret %d\n",
 512                                         ret);
 513                                 goto devm_err;
 514                         }
 515                         break;
 516                 case LINK_HDMI:
 517                         ret = create_hdmi_dai_links(dev, links, cpus, &id, hdmi_num);
 518                         if (ret < 0) {
 519                                 dev_err(dev, "fail to create hdmi dai links, ret %d\n",
 520                                         ret);
 521                                 goto devm_err;
 522                         }
 523                         break;
 524                 case LINK_NONE:
 525                         /* caught here if it's not used as terminator in macro */
 526                 default:
 527                         dev_err(dev, "invalid link type %d\n", link_type);
 528                         goto devm_err;
 529                 }
 530
 531                 link_seq >>= 3;
 532         }
 533
 534         return links;
 535 devm_err:
 536         return NULL;
 537 }
 538
 539 static int sof_audio_probe(struct platform_device *pdev)
 540 {
 541         struct snd_soc_dai_link *dai_links;
 542         struct snd_soc_acpi_mach *mach;
 543         struct sof_card_private *ctx;
 544         int dmic_be_num, hdmi_num;
 545         int ret, ssp_amp, ssp_codec;
 546
 547         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
 548         if (!ctx)
 549                 return -ENOMEM;
 550
 551         if (pdev->id_entry && pdev->id_entry->driver_data)
 552                 sof_cs42l42_quirk = (unsigned long)pdev->id_entry->driver_data;
 553
 554         mach = pdev->dev.platform_data;
 555
 556         if (soc_intel_is_glk()) {
 557                 dmic_be_num = 1;
 558                 hdmi_num = 3;
 559         } else {
 560                 dmic_be_num = 2;
 561                 hdmi_num = (sof_cs42l42_quirk & SOF_CS42L42_NUM_HDMIDEV_MASK) >>
 562                          SOF_CS42L42_NUM_HDMIDEV_SHIFT;
 563                 /* default number of HDMI DAI's */
 564                 if (!hdmi_num)
 565                         hdmi_num = 3;
 566         }
 567
 568         dev_dbg(&pdev->dev, "sof_cs42l42_quirk = %lx\n", sof_cs42l42_quirk);
 569
 570         ssp_amp = (sof_cs42l42_quirk & SOF_CS42L42_SSP_AMP_MASK) >>
 571                         SOF_CS42L42_SSP_AMP_SHIFT;
 572
 573         ssp_codec = sof_cs42l42_quirk & SOF_CS42L42_SSP_CODEC_MASK;
 574
 575         /* compute number of dai links */
 576         sof_audio_card_cs42l42.num_links = 1 + dmic_be_num + hdmi_num;
 577
 578         if (sof_cs42l42_quirk & SOF_SPEAKER_AMP_PRESENT)
 579                 sof_audio_card_cs42l42.num_links++;
 580
 581         dai_links = sof_card_dai_links_create(&pdev->dev, ssp_codec, ssp_amp,
 582                                               dmic_be_num, hdmi_num);
 583         if (!dai_links)
 584                 return -ENOMEM;
 585
 586         sof_audio_card_cs42l42.dai_link = dai_links;
 587
 588         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
 589
 590         sof_audio_card_cs42l42.dev = &pdev->dev;
 591
 592         /* set platform name for each dailink */
 593         ret = snd_soc_fixup_dai_links_platform_name(&sof_audio_card_cs42l42,
 594                                                     mach->mach_params.platform);
 595         if (ret)
 596                 return ret;
 597
 598         ctx->common_hdmi_codec_drv = mach->mach_params.common_hdmi_codec_drv;
 599
 600         snd_soc_card_set_drvdata(&sof_audio_card_cs42l42, ctx);
 601
 602         return devm_snd_soc_register_card(&pdev->dev,
 603                                           &sof_audio_card_cs42l42);
 604 }
 605
 606 static const struct platform_device_id board_ids[] = {
 607         {
 608                 .name = "glk_cs4242_mx98357a",
 609                 .driver_data = (kernel_ulong_t)(SOF_CS42L42_SSP_CODEC(2) |
 610                                         SOF_SPEAKER_AMP_PRESENT |
 611                                         SOF_MAX98357A_SPEAKER_AMP_PRESENT |
 612                                         SOF_CS42L42_SSP_AMP(1)) |
 613                                         SOF_CS42L42_DAILINK(LINK_SPK, LINK_HP, LINK_DMIC, LINK_HDMI, LINK_NONE),
 614         },
 615         {
 616                 .name = "jsl_cs4242_mx98360a",
 617                 .driver_data = (kernel_ulong_t)(SOF_CS42L42_SSP_CODEC(0) |
 618                                         SOF_SPEAKER_AMP_PRESENT |
 619                                         SOF_MAX98360A_SPEAKER_AMP_PRESENT |
 620                                         SOF_CS42L42_SSP_AMP(1)) |
 621                                         SOF_CS42L42_DAILINK(LINK_HP, LINK_DMIC, LINK_HDMI, LINK_SPK, LINK_NONE),
 622         },
 623         { }
 624 };
 625 MODULE_DEVICE_TABLE(platform, board_ids);
 626
 627 static struct platform_driver sof_audio = {
 628         .probe = sof_audio_probe,
 629         .driver = {
 630                 .name = "sof_cs42l42",
 631                 .pm = &snd_soc_pm_ops,
 632         },
 633         .id_table = board_ids,
 634 };
 635 module_platform_driver(sof_audio)
 636
 637 /* Module information */
 638 MODULE_DESCRIPTION("SOF Audio Machine driver for CS42L42");
 639 MODULE_AUTHOR("Brent Lu <brent.lu@intel.com>");
 640 MODULE_LICENSE("GPL");
 641 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON);
 642 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON);