sound/soc/intel/boards/sof_sdw.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (c) 2020 Intel Corporation
   3
   4 /*
   5  *  sof_sdw - ASOC Machine driver for Intel SoundWire platforms
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/dmi.h>
  10 #include <linux/module.h>
  11 #include <linux/soundwire/sdw.h>
  12 #include <linux/soundwire/sdw_type.h>
  13 #include <sound/soc.h>
  14 #include <sound/soc-acpi.h>
  15 #include "sof_sdw_common.h"
  16 #include "../../codecs/rt711.h"
  17
  18 unsigned long sof_sdw_quirk = RT711_JD1;
  19 static int quirk_override = -1;
  20 module_param_named(quirk, quirk_override, int, 0444);
  21 MODULE_PARM_DESC(quirk, "Board-specific quirk override");
  22
  23 #define INC_ID(BE, CPU, LINK)   do { (BE)++; (CPU)++; (LINK)++; } while (0)
  24
  25 static void log_quirks(struct device *dev)
  26 {
  27         if (SOF_RT711_JDSRC(sof_sdw_quirk))
  28                 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n",
  29                         SOF_RT711_JDSRC(sof_sdw_quirk));
  30         if (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
  31                 dev_dbg(dev, "quirk SOF_SDW_FOUR_SPK enabled\n");
  32         if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
  33                 dev_dbg(dev, "quirk SOF_SDW_TGL_HDMI enabled\n");
  34         if (sof_sdw_quirk & SOF_SDW_PCH_DMIC)
  35                 dev_dbg(dev, "quirk SOF_SDW_PCH_DMIC enabled\n");
  36         if (SOF_SSP_GET_PORT(sof_sdw_quirk))
  37                 dev_dbg(dev, "SSP port %ld\n",
  38                         SOF_SSP_GET_PORT(sof_sdw_quirk));
  39         if (sof_sdw_quirk & SOF_SDW_NO_AGGREGATION)
  40                 dev_dbg(dev, "quirk SOF_SDW_NO_AGGREGATION enabled\n");
  41 }
  42
  43 static int sof_sdw_quirk_cb(const struct dmi_system_id *id)
  44 {
  45         sof_sdw_quirk = (unsigned long)id->driver_data;
  46         return 1;
  47 }
  48
  49 static const struct dmi_system_id sof_sdw_quirk_table[] = {
  50         /* CometLake devices */
  51         {
  52                 .callback = sof_sdw_quirk_cb,
  53                 .matches = {
  54                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
  55                         DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"),
  56                 },
  57                 .driver_data = (void *)SOF_SDW_PCH_DMIC,
  58         },
  59         {
  60                 .callback = sof_sdw_quirk_cb,
  61                 .matches = {
  62                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  63                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
  64                 },
  65                 .driver_data = (void *)RT711_JD2,
  66         },
  67         {
  68                 /* early version of SKU 09C6 */
  69                 .callback = sof_sdw_quirk_cb,
  70                 .matches = {
  71                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  72                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
  73                 },
  74                 .driver_data = (void *)RT711_JD2,
  75         },
  76         {
  77                 .callback = sof_sdw_quirk_cb,
  78                 .matches = {
  79                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  80                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
  81                 },
  82                 .driver_data = (void *)(RT711_JD2 |
  83                                         SOF_SDW_FOUR_SPK),
  84         },
  85         {
  86                 .callback = sof_sdw_quirk_cb,
  87                 .matches = {
  88                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  89                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
  90                 },
  91                 .driver_data = (void *)(RT711_JD2 |
  92                                         SOF_SDW_FOUR_SPK),
  93         },
  94         /* IceLake devices */
  95         {
  96                 .callback = sof_sdw_quirk_cb,
  97                 .matches = {
  98                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
  99                         DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"),
 100                 },
 101                 .driver_data = (void *)SOF_SDW_PCH_DMIC,
 102         },
 103         /* TigerLake devices */
 104         {
 105                 .callback = sof_sdw_quirk_cb,
 106                 .matches = {
 107                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 108                         DMI_MATCH(DMI_PRODUCT_NAME,
 109                                   "Tiger Lake Client Platform"),
 110                 },
 111                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 112                                         RT711_JD1 |
 113                                         SOF_SDW_PCH_DMIC |
 114                                         SOF_SSP_PORT(SOF_I2S_SSP2)),
 115         },
 116         {
 117                 .callback = sof_sdw_quirk_cb,
 118                 .matches = {
 119                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 120                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E")
 121                 },
 122                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 123                                         RT711_JD2),
 124         },
 125         {
 126                 /* another SKU of Dell Latitude 9520 */
 127                 .callback = sof_sdw_quirk_cb,
 128                 .matches = {
 129                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 130                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3F")
 131                 },
 132                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 133                                         RT711_JD2),
 134         },
 135         {
 136                 /* Dell XPS 9710 */
 137                 .callback = sof_sdw_quirk_cb,
 138                 .matches = {
 139                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 140                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D")
 141                 },
 142                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 143                                         RT711_JD2 |
 144                                         SOF_SDW_FOUR_SPK),
 145         },
 146         {
 147                 .callback = sof_sdw_quirk_cb,
 148                 .matches = {
 149                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 150                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5E")
 151                 },
 152                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 153                                         RT711_JD2 |
 154                                         SOF_SDW_FOUR_SPK),
 155         },
 156         {
 157                 .callback = sof_sdw_quirk_cb,
 158                 .matches = {
 159                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 160                         DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"),
 161                 },
 162                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 163                                         SOF_SDW_PCH_DMIC |
 164                                         SOF_SDW_FOUR_SPK |
 165                                         SOF_BT_OFFLOAD_SSP(2) |
 166                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 167         },
 168         {
 169                 .callback = sof_sdw_quirk_cb,
 170                 .matches = {
 171                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 172                         DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"),
 173                 },
 174                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 175                                         SOF_SDW_PCH_DMIC |
 176                                         SOF_SDW_FOUR_SPK),
 177         },
 178         {
 179                 /*
 180                  * this entry covers multiple HP SKUs. The family name
 181                  * does not seem robust enough, so we use a partial
 182                  * match that ignores the product name suffix
 183                  * (e.g. 15-eb1xxx, 14t-ea000 or 13-aw2xxx)
 184                  */
 185                 .callback = sof_sdw_quirk_cb,
 186                 .matches = {
 187                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 188                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Conv"),
 189                 },
 190                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 191                                         SOF_SDW_PCH_DMIC |
 192                                         RT711_JD1),
 193         },
 194         {
 195                 /* NUC15 'Bishop County' LAPBC510 and LAPBC710 skews */
 196                 .callback = sof_sdw_quirk_cb,
 197                 .matches = {
 198                         DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
 199                         DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"),
 200                 },
 201                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 202                                         SOF_SDW_PCH_DMIC |
 203                                         RT711_JD1),
 204         },
 205         {
 206                 /* NUC15 LAPBC710 skews */
 207                 .callback = sof_sdw_quirk_cb,
 208                 .matches = {
 209                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 210                         DMI_MATCH(DMI_BOARD_NAME, "LAPBC710"),
 211                 },
 212                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 213                                         SOF_SDW_PCH_DMIC |
 214                                         RT711_JD1),
 215         },
 216         /* TigerLake-SDCA devices */
 217         {
 218                 .callback = sof_sdw_quirk_cb,
 219                 .matches = {
 220                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 221                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32")
 222                 },
 223                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 224                                         RT711_JD2 |
 225                                         SOF_SDW_FOUR_SPK),
 226         },
 227         {
 228                 .callback = sof_sdw_quirk_cb,
 229                 .matches = {
 230                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 231                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A45")
 232                 },
 233                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 234                                         RT711_JD2),
 235         },
 236         /* AlderLake devices */
 237         {
 238                 .callback = sof_sdw_quirk_cb,
 239                 .matches = {
 240                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 241                         DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"),
 242                 },
 243                 .driver_data = (void *)(RT711_JD2_100K |
 244                                         SOF_SDW_TGL_HDMI |
 245                                         SOF_BT_OFFLOAD_SSP(2) |
 246                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 247         },
 248         {
 249                 .callback = sof_sdw_quirk_cb,
 250                 .matches = {
 251                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 252                         DMI_MATCH(DMI_PRODUCT_NAME, "Brya"),
 253                 },
 254                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 255                                         SOF_SDW_PCH_DMIC |
 256                                         SOF_SDW_FOUR_SPK |
 257                                         SOF_BT_OFFLOAD_SSP(2) |
 258                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 259         },
 260         {
 261                 .callback = sof_sdw_quirk_cb,
 262                 .matches = {
 263                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 264                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF0")
 265                 },
 266                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 267                                         RT711_JD2 |
 268                                         SOF_SDW_FOUR_SPK),
 269         },
 270         {
 271                 .callback = sof_sdw_quirk_cb,
 272                 .matches = {
 273                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 274                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF3"),
 275                 },
 276                 /* No Jack */
 277                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 278                                         SOF_SDW_FOUR_SPK),
 279         },
 280         {
 281                 .callback = sof_sdw_quirk_cb,
 282                 .matches = {
 283                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 284                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFF")
 285                 },
 286                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 287                                         RT711_JD2 |
 288                                         SOF_SDW_FOUR_SPK),
 289         },
 290         {
 291                 .callback = sof_sdw_quirk_cb,
 292                 .matches = {
 293                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 294                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B00")
 295                 },
 296                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 297                                         RT711_JD2 |
 298                                         SOF_SDW_FOUR_SPK),
 299         },
 300         {
 301                 .callback = sof_sdw_quirk_cb,
 302                 .matches = {
 303                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 304                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B01")
 305                 },
 306                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 307                                         RT711_JD2 |
 308                                         SOF_SDW_FOUR_SPK),
 309         },
 310         {
 311                 .callback = sof_sdw_quirk_cb,
 312                 .matches = {
 313                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 314                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B11")
 315                 },
 316                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 317                                         RT711_JD2 |
 318                                         SOF_SDW_FOUR_SPK),
 319         },
 320         {
 321                 .callback = sof_sdw_quirk_cb,
 322                 .matches = {
 323                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 324                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B12")
 325                 },
 326                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 327                                         RT711_JD2 |
 328                                         SOF_SDW_FOUR_SPK),
 329         },
 330         {
 331                 .callback = sof_sdw_quirk_cb,
 332                 .matches = {
 333                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 334                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B13"),
 335                 },
 336                 /* No Jack */
 337                 .driver_data = (void *)SOF_SDW_TGL_HDMI,
 338         },
 339         {
 340                 .callback = sof_sdw_quirk_cb,
 341                 .matches = {
 342                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 343                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B29"),
 344                 },
 345                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 346                                         RT711_JD2 |
 347                                         SOF_SDW_FOUR_SPK),
 348         },
 349         {
 350                 .callback = sof_sdw_quirk_cb,
 351                 .matches = {
 352                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 353                         DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16-k0xxx"),
 354                 },
 355                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 356                                         RT711_JD2),
 357         },
 358         /* MeteorLake devices */
 359         {
 360                 .callback = sof_sdw_quirk_cb,
 361                 .matches = {
 362                         DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_mtlrvp"),
 363                 },
 364                 .driver_data = (void *)(RT711_JD1 | SOF_SDW_TGL_HDMI),
 365         },
 366         {}
 367 };
 368
 369 static struct snd_soc_dai_link_component dmic_component[] = {
 370         {
 371                 .name = "dmic-codec",
 372                 .dai_name = "dmic-hifi",
 373         }
 374 };
 375
 376 static struct snd_soc_dai_link_component platform_component[] = {
 377         {
 378                 /* name might be overridden during probe */
 379                 .name = "0000:00:1f.3"
 380         }
 381 };
 382
 383 /* these wrappers are only needed to avoid typecast compilation errors */
 384 int sdw_startup(struct snd_pcm_substream *substream)
 385 {
 386         return sdw_startup_stream(substream);
 387 }
 388
 389 int sdw_prepare(struct snd_pcm_substream *substream)
 390 {
 391         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 392         struct sdw_stream_runtime *sdw_stream;
 393         struct snd_soc_dai *dai;
 394
 395         /* Find stream from first CPU DAI */
 396         dai = asoc_rtd_to_cpu(rtd, 0);
 397
 398         sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
 399
 400         if (IS_ERR(sdw_stream)) {
 401                 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
 402                 return PTR_ERR(sdw_stream);
 403         }
 404
 405         return sdw_prepare_stream(sdw_stream);
 406 }
 407
 408 int sdw_trigger(struct snd_pcm_substream *substream, int cmd)
 409 {
 410         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 411         struct sdw_stream_runtime *sdw_stream;
 412         struct snd_soc_dai *dai;
 413         int ret;
 414
 415         /* Find stream from first CPU DAI */
 416         dai = asoc_rtd_to_cpu(rtd, 0);
 417
 418         sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
 419
 420         if (IS_ERR(sdw_stream)) {
 421                 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
 422                 return PTR_ERR(sdw_stream);
 423         }
 424
 425         switch (cmd) {
 426         case SNDRV_PCM_TRIGGER_START:
 427         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 428         case SNDRV_PCM_TRIGGER_RESUME:
 429                 ret = sdw_enable_stream(sdw_stream);
 430                 break;
 431
 432         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 433         case SNDRV_PCM_TRIGGER_SUSPEND:
 434         case SNDRV_PCM_TRIGGER_STOP:
 435                 ret = sdw_disable_stream(sdw_stream);
 436                 break;
 437         default:
 438                 ret = -EINVAL;
 439                 break;
 440         }
 441
 442         if (ret)
 443                 dev_err(rtd->dev, "%s trigger %d failed: %d", __func__, cmd, ret);
 444
 445         return ret;
 446 }
 447
 448 int sdw_hw_free(struct snd_pcm_substream *substream)
 449 {
 450         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 451         struct sdw_stream_runtime *sdw_stream;
 452         struct snd_soc_dai *dai;
 453
 454         /* Find stream from first CPU DAI */
 455         dai = asoc_rtd_to_cpu(rtd, 0);
 456
 457         sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
 458
 459         if (IS_ERR(sdw_stream)) {
 460                 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
 461                 return PTR_ERR(sdw_stream);
 462         }
 463
 464         return sdw_deprepare_stream(sdw_stream);
 465 }
 466
 467 void sdw_shutdown(struct snd_pcm_substream *substream)
 468 {
 469         sdw_shutdown_stream(substream);
 470 }
 471
 472 static const struct snd_soc_ops sdw_ops = {
 473         .startup = sdw_startup,
 474         .prepare = sdw_prepare,
 475         .trigger = sdw_trigger,
 476         .hw_free = sdw_hw_free,
 477         .shutdown = sdw_shutdown,
 478 };
 479
 480 static struct sof_sdw_codec_info codec_info_list[] = {
 481         {
 482                 .part_id = 0x700,
 483                 .direction = {true, true},
 484                 .dai_name = "rt700-aif1",
 485                 .init = sof_sdw_rt700_init,
 486                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 487         },
 488         {
 489                 .part_id = 0x711,
 490                 .version_id = 3,
 491                 .direction = {true, true},
 492                 .dai_name = "rt711-sdca-aif1",
 493                 .init = sof_sdw_rt711_sdca_init,
 494                 .exit = sof_sdw_rt711_sdca_exit,
 495                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 496         },
 497         {
 498                 .part_id = 0x711,
 499                 .version_id = 2,
 500                 .direction = {true, true},
 501                 .dai_name = "rt711-aif1",
 502                 .init = sof_sdw_rt711_init,
 503                 .exit = sof_sdw_rt711_exit,
 504                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 505         },
 506         {
 507                 .part_id = 0x1308,
 508                 .acpi_id = "10EC1308",
 509                 .direction = {true, false},
 510                 .dai_name = "rt1308-aif",
 511                 .ops = &sof_sdw_rt1308_i2s_ops,
 512                 .init = sof_sdw_rt1308_init,
 513                 .codec_type = SOF_SDW_CODEC_TYPE_AMP,
 514         },
 515         {
 516                 .part_id = 0x1316,
 517                 .direction = {true, true},
 518                 .dai_name = "rt1316-aif",
 519                 .init = sof_sdw_rt1316_init,
 520                 .codec_type = SOF_SDW_CODEC_TYPE_AMP,
 521         },
 522         {
 523                 .part_id = 0x714,
 524                 .version_id = 3,
 525                 .direction = {false, true},
 526                 .ignore_pch_dmic = true,
 527                 .dai_name = "rt715-aif2",
 528                 .init = sof_sdw_rt715_sdca_init,
 529                 .codec_type = SOF_SDW_CODEC_TYPE_MIC,
 530         },
 531         {
 532                 .part_id = 0x715,
 533                 .version_id = 3,
 534                 .direction = {false, true},
 535                 .ignore_pch_dmic = true,
 536                 .dai_name = "rt715-aif2",
 537                 .init = sof_sdw_rt715_sdca_init,
 538                 .codec_type = SOF_SDW_CODEC_TYPE_MIC,
 539         },
 540         {
 541                 .part_id = 0x714,
 542                 .version_id = 2,
 543                 .direction = {false, true},
 544                 .ignore_pch_dmic = true,
 545                 .dai_name = "rt715-aif2",
 546                 .init = sof_sdw_rt715_init,
 547                 .codec_type = SOF_SDW_CODEC_TYPE_MIC,
 548         },
 549         {
 550                 .part_id = 0x715,
 551                 .version_id = 2,
 552                 .direction = {false, true},
 553                 .ignore_pch_dmic = true,
 554                 .dai_name = "rt715-aif2",
 555                 .init = sof_sdw_rt715_init,
 556                 .codec_type = SOF_SDW_CODEC_TYPE_MIC,
 557         },
 558         {
 559                 .part_id = 0x8373,
 560                 .direction = {true, true},
 561                 .dai_name = "max98373-aif1",
 562                 .init = sof_sdw_mx8373_init,
 563                 .codec_card_late_probe = sof_sdw_mx8373_late_probe,
 564                 .codec_type = SOF_SDW_CODEC_TYPE_AMP,
 565         },
 566         {
 567                 .part_id = 0x5682,
 568                 .direction = {true, true},
 569                 .dai_name = "rt5682-sdw",
 570                 .init = sof_sdw_rt5682_init,
 571                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 572         },
 573         {
 574                 .part_id = 0xaaaa, /* generic codec mockup */
 575                 .version_id = 0,
 576                 .direction = {true, true},
 577                 .dai_name = "sdw-mockup-aif1",
 578                 .init = NULL,
 579                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 580         },
 581         {
 582                 .part_id = 0xaa55, /* headset codec mockup */
 583                 .version_id = 0,
 584                 .direction = {true, true},
 585                 .dai_name = "sdw-mockup-aif1",
 586                 .init = NULL,
 587                 .codec_type = SOF_SDW_CODEC_TYPE_JACK,
 588         },
 589         {
 590                 .part_id = 0x55aa, /* amplifier mockup */
 591                 .version_id = 0,
 592                 .direction = {true, false},
 593                 .dai_name = "sdw-mockup-aif1",
 594                 .init = NULL,
 595                 .codec_type = SOF_SDW_CODEC_TYPE_AMP,
 596         },
 597         {
 598                 .part_id = 0x5555,
 599                 .version_id = 0,
 600                 .direction = {false, true},
 601                 .dai_name = "sdw-mockup-aif1",
 602                 .codec_type = SOF_SDW_CODEC_TYPE_MIC,
 603         },
 604 };
 605
 606 static inline int find_codec_info_part(u64 adr)
 607 {
 608         unsigned int part_id, sdw_version;
 609         int i;
 610
 611         part_id = SDW_PART_ID(adr);
 612         sdw_version = SDW_VERSION(adr);
 613         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
 614                 /*
 615                  * A codec info is for all sdw version with the part id if
 616                  * version_id is not specified in the codec info.
 617                  */
 618                 if (part_id == codec_info_list[i].part_id &&
 619                     (!codec_info_list[i].version_id ||
 620                      sdw_version == codec_info_list[i].version_id))
 621                         return i;
 622
 623         return -EINVAL;
 624
 625 }
 626
 627 static inline int find_codec_info_acpi(const u8 *acpi_id)
 628 {
 629         int i;
 630
 631         if (!acpi_id[0])
 632                 return -EINVAL;
 633
 634         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
 635                 if (!memcmp(codec_info_list[i].acpi_id, acpi_id,
 636                             ACPI_ID_LEN))
 637                         break;
 638
 639         if (i == ARRAY_SIZE(codec_info_list))
 640                 return -EINVAL;
 641
 642         return i;
 643 }
 644
 645 /*
 646  * get BE dailink number and CPU DAI number based on sdw link adr.
 647  * Since some sdw slaves may be aggregated, the CPU DAI number
 648  * may be larger than the number of BE dailinks.
 649  */
 650 static int get_sdw_dailink_info(struct device *dev, const struct snd_soc_acpi_link_adr *links,
 651                                 int *sdw_be_num, int *sdw_cpu_dai_num)
 652 {
 653         const struct snd_soc_acpi_link_adr *link;
 654         int _codec_type = SOF_SDW_CODEC_TYPE_JACK;
 655         bool group_visited[SDW_MAX_GROUPS];
 656         bool no_aggregation;
 657         int i;
 658
 659         no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
 660         *sdw_cpu_dai_num = 0;
 661         *sdw_be_num  = 0;
 662
 663         if (!links)
 664                 return -EINVAL;
 665
 666         for (i = 0; i < SDW_MAX_GROUPS; i++)
 667                 group_visited[i] = false;
 668
 669         for (link = links; link->num_adr; link++) {
 670                 const struct snd_soc_acpi_endpoint *endpoint;
 671                 int codec_index;
 672                 int stream;
 673                 u64 adr;
 674
 675                 adr = link->adr_d->adr;
 676                 codec_index = find_codec_info_part(adr);
 677                 if (codec_index < 0)
 678                         return codec_index;
 679
 680                 if (codec_info_list[codec_index].codec_type < _codec_type)
 681                         dev_warn(dev,
 682                                  "Unexpected address table ordering. Expected order: jack -> amp -> mic\n");
 683
 684                 _codec_type = codec_info_list[codec_index].codec_type;
 685
 686                 endpoint = link->adr_d->endpoints;
 687
 688                 /* count DAI number for playback and capture */
 689                 for_each_pcm_streams(stream) {
 690                         if (!codec_info_list[codec_index].direction[stream])
 691                                 continue;
 692
 693                         (*sdw_cpu_dai_num)++;
 694
 695                         /* count BE for each non-aggregated slave or group */
 696                         if (!endpoint->aggregated || no_aggregation ||
 697                             !group_visited[endpoint->group_id])
 698                                 (*sdw_be_num)++;
 699                 }
 700
 701                 if (endpoint->aggregated)
 702                         group_visited[endpoint->group_id] = true;
 703         }
 704
 705         return 0;
 706 }
 707
 708 static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links,
 709                           int be_id, char *name, int playback, int capture,
 710                           struct snd_soc_dai_link_component *cpus, int cpus_num,
 711                           struct snd_soc_dai_link_component *codecs, int codecs_num,
 712                           int (*init)(struct snd_soc_pcm_runtime *rtd),
 713                           const struct snd_soc_ops *ops)
 714 {
 715         dev_dbg(dev, "create dai link %s, id %d\n", name, be_id);
 716         dai_links->id = be_id;
 717         dai_links->name = name;
 718         dai_links->platforms = platform_component;
 719         dai_links->num_platforms = ARRAY_SIZE(platform_component);
 720         dai_links->no_pcm = 1;
 721         dai_links->cpus = cpus;
 722         dai_links->num_cpus = cpus_num;
 723         dai_links->codecs = codecs;
 724         dai_links->num_codecs = codecs_num;
 725         dai_links->dpcm_playback = playback;
 726         dai_links->dpcm_capture = capture;
 727         dai_links->init = init;
 728         dai_links->ops = ops;
 729 }
 730
 731 static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
 732                              unsigned int sdw_version,
 733                              unsigned int mfg_id,
 734                              unsigned int part_id,
 735                              unsigned int class_id,
 736                              int index_in_link
 737                             )
 738 {
 739         int i;
 740
 741         for (i = 0; i < link->num_adr; i++) {
 742                 unsigned int sdw1_version, mfg1_id, part1_id, class1_id;
 743                 u64 adr;
 744
 745                 /* skip itself */
 746                 if (i == index_in_link)
 747                         continue;
 748
 749                 adr = link->adr_d[i].adr;
 750
 751                 sdw1_version = SDW_VERSION(adr);
 752                 mfg1_id = SDW_MFG_ID(adr);
 753                 part1_id = SDW_PART_ID(adr);
 754                 class1_id = SDW_CLASS_ID(adr);
 755
 756                 if (sdw_version == sdw1_version &&
 757                     mfg_id == mfg1_id &&
 758                     part_id == part1_id &&
 759                     class_id == class1_id)
 760                         return false;
 761         }
 762
 763         return true;
 764 }
 765
 766 static int create_codec_dai_name(struct device *dev,
 767                                  const struct snd_soc_acpi_link_adr *link,
 768                                  struct snd_soc_dai_link_component *codec,
 769                                  int offset,
 770                                  struct snd_soc_codec_conf *codec_conf,
 771                                  int codec_count,
 772                                  int *codec_conf_index)
 773 {
 774         int i;
 775
 776         /* sanity check */
 777         if (*codec_conf_index + link->num_adr > codec_count) {
 778                 dev_err(dev, "codec_conf: out-of-bounds access requested\n");
 779                 return -EINVAL;
 780         }
 781
 782         for (i = 0; i < link->num_adr; i++) {
 783                 unsigned int sdw_version, unique_id, mfg_id;
 784                 unsigned int link_id, part_id, class_id;
 785                 int codec_index, comp_index;
 786                 char *codec_str;
 787                 u64 adr;
 788
 789                 adr = link->adr_d[i].adr;
 790
 791                 sdw_version = SDW_VERSION(adr);
 792                 link_id = SDW_DISCO_LINK_ID(adr);
 793                 unique_id = SDW_UNIQUE_ID(adr);
 794                 mfg_id = SDW_MFG_ID(adr);
 795                 part_id = SDW_PART_ID(adr);
 796                 class_id = SDW_CLASS_ID(adr);
 797
 798                 comp_index = i + offset;
 799                 if (is_unique_device(link, sdw_version, mfg_id, part_id,
 800                                      class_id, i)) {
 801                         codec_str = "sdw:%01x:%04x:%04x:%02x";
 802                         codec[comp_index].name =
 803                                 devm_kasprintf(dev, GFP_KERNEL, codec_str,
 804                                                link_id, mfg_id, part_id,
 805                                                class_id);
 806                 } else {
 807                         codec_str = "sdw:%01x:%04x:%04x:%02x:%01x";
 808                         codec[comp_index].name =
 809                                 devm_kasprintf(dev, GFP_KERNEL, codec_str,
 810                                                link_id, mfg_id, part_id,
 811                                                class_id, unique_id);
 812                 }
 813
 814                 if (!codec[comp_index].name)
 815                         return -ENOMEM;
 816
 817                 codec_index = find_codec_info_part(adr);
 818                 if (codec_index < 0)
 819                         return codec_index;
 820
 821                 codec[comp_index].dai_name =
 822                         codec_info_list[codec_index].dai_name;
 823
 824                 codec_conf[*codec_conf_index].dlc = codec[comp_index];
 825                 codec_conf[*codec_conf_index].name_prefix = link->adr_d[i].name_prefix;
 826
 827                 ++*codec_conf_index;
 828         }
 829
 830         return 0;
 831 }
 832
 833 static int set_codec_init_func(struct snd_soc_card *card,
 834                                const struct snd_soc_acpi_link_adr *link,
 835                                struct snd_soc_dai_link *dai_links,
 836                                bool playback, int group_id)
 837 {
 838         int i;
 839
 840         do {
 841                 /*
 842                  * Initialize the codec. If codec is part of an aggregated
 843                  * group (group_id>0), initialize all codecs belonging to
 844                  * same group.
 845                  */
 846                 for (i = 0; i < link->num_adr; i++) {
 847                         int codec_index;
 848
 849                         codec_index = find_codec_info_part(link->adr_d[i].adr);
 850
 851                         if (codec_index < 0)
 852                                 return codec_index;
 853                         /* The group_id is > 0 iff the codec is aggregated */
 854                         if (link->adr_d[i].endpoints->group_id != group_id)
 855                                 continue;
 856                         if (codec_info_list[codec_index].init)
 857                                 codec_info_list[codec_index].init(card,
 858                                                 link,
 859                                                 dai_links,
 860                                                 &codec_info_list[codec_index],
 861                                                 playback);
 862                 }
 863                 link++;
 864         } while (link->mask && group_id);
 865
 866         return 0;
 867 }
 868
 869 /*
 870  * check endpoint status in slaves and gather link ID for all slaves in
 871  * the same group to generate different CPU DAI. Now only support
 872  * one sdw link with all slaves set with only single group id.
 873  *
 874  * one slave on one sdw link with aggregated = 0
 875  * one sdw BE DAI <---> one-cpu DAI <---> one-codec DAI
 876  *
 877  * two or more slaves on one sdw link with aggregated = 0
 878  * one sdw BE DAI  <---> one-cpu DAI <---> multi-codec DAIs
 879  *
 880  * multiple links with multiple slaves with aggregated = 1
 881  * one sdw BE DAI  <---> 1 .. N CPU DAIs <----> 1 .. N codec DAIs
 882  */
 883 static int get_slave_info(const struct snd_soc_acpi_link_adr *adr_link,
 884                           struct device *dev, int *cpu_dai_id, int *cpu_dai_num,
 885                           int *codec_num, unsigned int *group_id,
 886                           bool *group_generated)
 887 {
 888         const struct snd_soc_acpi_adr_device *adr_d;
 889         const struct snd_soc_acpi_link_adr *adr_next;
 890         bool no_aggregation;
 891         int index = 0;
 892
 893         no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
 894         *codec_num = adr_link->num_adr;
 895         adr_d = adr_link->adr_d;
 896
 897         /* make sure the link mask has a single bit set */
 898         if (!is_power_of_2(adr_link->mask))
 899                 return -EINVAL;
 900
 901         cpu_dai_id[index++] = ffs(adr_link->mask) - 1;
 902         if (!adr_d->endpoints->aggregated || no_aggregation) {
 903                 *cpu_dai_num = 1;
 904                 *group_id = 0;
 905                 return 0;
 906         }
 907
 908         *group_id = adr_d->endpoints->group_id;
 909
 910         /* gather other link ID of slaves in the same group */
 911         for (adr_next = adr_link + 1; adr_next && adr_next->num_adr;
 912                 adr_next++) {
 913                 const struct snd_soc_acpi_endpoint *endpoint;
 914
 915                 endpoint = adr_next->adr_d->endpoints;
 916                 if (!endpoint->aggregated ||
 917                     endpoint->group_id != *group_id)
 918                         continue;
 919
 920                 /* make sure the link mask has a single bit set */
 921                 if (!is_power_of_2(adr_next->mask))
 922                         return -EINVAL;
 923
 924                 if (index >= SDW_MAX_CPU_DAIS) {
 925                         dev_err(dev, " cpu_dai_id array overflows");
 926                         return -EINVAL;
 927                 }
 928
 929                 cpu_dai_id[index++] = ffs(adr_next->mask) - 1;
 930                 *codec_num += adr_next->num_adr;
 931         }
 932
 933         /*
 934          * indicate CPU DAIs for this group have been generated
 935          * to avoid generating CPU DAIs for this group again.
 936          */
 937         group_generated[*group_id] = true;
 938         *cpu_dai_num = index;
 939
 940         return 0;
 941 }
 942
 943 static int create_sdw_dailink(struct snd_soc_card *card,
 944                               struct device *dev, int *link_index,
 945                               struct snd_soc_dai_link *dai_links,
 946                               int sdw_be_num, int sdw_cpu_dai_num,
 947                               struct snd_soc_dai_link_component *cpus,
 948                               const struct snd_soc_acpi_link_adr *link,
 949                               int *cpu_id, bool *group_generated,
 950                               struct snd_soc_codec_conf *codec_conf,
 951                               int codec_count, int *link_id,
 952                               int *codec_conf_index,
 953                               bool *ignore_pch_dmic)
 954 {
 955         const struct snd_soc_acpi_link_adr *link_next;
 956         struct snd_soc_dai_link_component *codecs;
 957         int cpu_dai_id[SDW_MAX_CPU_DAIS];
 958         int cpu_dai_num, cpu_dai_index;
 959         unsigned int group_id;
 960         int codec_idx = 0;
 961         int i = 0, j = 0;
 962         int codec_index;
 963         int codec_num;
 964         int stream;
 965         int ret;
 966         int k;
 967
 968         ret = get_slave_info(link, dev, cpu_dai_id, &cpu_dai_num, &codec_num,
 969                              &group_id, group_generated);
 970         if (ret)
 971                 return ret;
 972
 973         codecs = devm_kcalloc(dev, codec_num, sizeof(*codecs), GFP_KERNEL);
 974         if (!codecs)
 975                 return -ENOMEM;
 976
 977         /* generate codec name on different links in the same group */
 978         for (link_next = link; link_next && link_next->num_adr &&
 979              i < cpu_dai_num; link_next++) {
 980                 const struct snd_soc_acpi_endpoint *endpoints;
 981
 982                 endpoints = link_next->adr_d->endpoints;
 983                 if (group_id && (!endpoints->aggregated ||
 984                                  endpoints->group_id != group_id))
 985                         continue;
 986
 987                 /* skip the link excluded by this processed group */
 988                 if (cpu_dai_id[i] != ffs(link_next->mask) - 1)
 989                         continue;
 990
 991                 ret = create_codec_dai_name(dev, link_next, codecs, codec_idx,
 992                                             codec_conf, codec_count, codec_conf_index);
 993                 if (ret < 0)
 994                         return ret;
 995
 996                 /* check next link to create codec dai in the processed group */
 997                 i++;
 998                 codec_idx += link_next->num_adr;
 999         }
1000
1001         /* find codec info to create BE DAI */
1002         codec_index = find_codec_info_part(link->adr_d[0].adr);
1003         if (codec_index < 0)
1004                 return codec_index;
1005
1006         if (codec_info_list[codec_index].ignore_pch_dmic)
1007                 *ignore_pch_dmic = true;
1008
1009         /* Shift the first amplifier's *link_id to SDW_AMP_DAI_ID */
1010         if (codec_info_list[codec_index].codec_type == SOF_SDW_CODEC_TYPE_AMP &&
1011             *link_id < SDW_AMP_DAI_ID)
1012                 *link_id = SDW_AMP_DAI_ID;
1013
1014         /*
1015          * DAI ID is fixed at SDW_DMIC_DAI_ID for MICs to
1016          * keep sdw DMIC and HDMI setting static in UCM
1017          */
1018         if (codec_info_list[codec_index].codec_type == SOF_SDW_CODEC_TYPE_MIC &&
1019             *link_id < SDW_DMIC_DAI_ID)
1020                 *link_id = SDW_DMIC_DAI_ID;
1021
1022         cpu_dai_index = *cpu_id;
1023         for_each_pcm_streams(stream) {
1024                 char *name, *cpu_name;
1025                 int playback, capture;
1026                 static const char * const sdw_stream_name[] = {
1027                         "SDW%d-Playback",
1028                         "SDW%d-Capture",
1029                 };
1030
1031                 if (!codec_info_list[codec_index].direction[stream])
1032                         continue;
1033
1034                 /* create stream name according to first link id */
1035                 name = devm_kasprintf(dev, GFP_KERNEL,
1036                                       sdw_stream_name[stream], cpu_dai_id[0]);
1037                 if (!name)
1038                         return -ENOMEM;
1039
1040                 /*
1041                  * generate CPU DAI name base on the sdw link ID and
1042                  * PIN ID with offset of 2 according to sdw dai driver.
1043                  */
1044                 for (k = 0; k < cpu_dai_num; k++) {
1045                         cpu_name = devm_kasprintf(dev, GFP_KERNEL,
1046                                                   "SDW%d Pin%d", cpu_dai_id[k],
1047                                                   j + SDW_INTEL_BIDIR_PDI_BASE);
1048                         if (!cpu_name)
1049                                 return -ENOMEM;
1050
1051                         if (cpu_dai_index >= sdw_cpu_dai_num) {
1052                                 dev_err(dev, "invalid cpu dai index %d",
1053                                         cpu_dai_index);
1054                                 return -EINVAL;
1055                         }
1056
1057                         cpus[cpu_dai_index++].dai_name = cpu_name;
1058                 }
1059
1060                 /*
1061                  * We create sdw dai links at first stage, so link index should
1062                  * not be larger than sdw_be_num
1063                  */
1064                 if (*link_index >= sdw_be_num) {
1065                         dev_err(dev, "invalid dai link index %d", *link_index);
1066                         return -EINVAL;
1067                 }
1068
1069                 if (*cpu_id >= sdw_cpu_dai_num) {
1070                         dev_err(dev, " invalid cpu dai index %d", *cpu_id);
1071                         return -EINVAL;
1072                 }
1073
1074                 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK);
1075                 capture = (stream == SNDRV_PCM_STREAM_CAPTURE);
1076                 init_dai_link(dev, dai_links + *link_index, (*link_id)++, name,
1077                               playback, capture,
1078                               cpus + *cpu_id, cpu_dai_num,
1079                               codecs, codec_num,
1080                               NULL, &sdw_ops);
1081
1082                 /*
1083                  * SoundWire DAILINKs use 'stream' functions and Bank Switch operations
1084                  * based on wait_for_completion(), tag them as 'nonatomic'.
1085                  */
1086                 dai_links[*link_index].nonatomic = true;
1087
1088                 ret = set_codec_init_func(card, link, dai_links + (*link_index)++,
1089                                           playback, group_id);
1090                 if (ret < 0) {
1091                         dev_err(dev, "failed to init codec %d", codec_index);
1092                         return ret;
1093                 }
1094
1095                 *cpu_id += cpu_dai_num;
1096                 j++;
1097         }
1098
1099         return 0;
1100 }
1101
1102 #define IDISP_CODEC_MASK        0x4
1103
1104 static int sof_card_codec_conf_alloc(struct device *dev,
1105                                      struct snd_soc_acpi_mach_params *mach_params,
1106                                      struct snd_soc_codec_conf **codec_conf,
1107                                      int *codec_conf_count)
1108 {
1109         const struct snd_soc_acpi_link_adr *adr_link;
1110         struct snd_soc_codec_conf *c_conf;
1111         int num_codecs = 0;
1112         int i;
1113
1114         adr_link = mach_params->links;
1115         if (!adr_link)
1116                 return -EINVAL;
1117
1118         /* generate DAI links by each sdw link */
1119         for (; adr_link->num_adr; adr_link++) {
1120                 for (i = 0; i < adr_link->num_adr; i++) {
1121                         if (!adr_link->adr_d[i].name_prefix) {
1122                                 dev_err(dev, "codec 0x%llx does not have a name prefix\n",
1123                                         adr_link->adr_d[i].adr);
1124                                 return -EINVAL;
1125                         }
1126                 }
1127                 num_codecs += adr_link->num_adr;
1128         }
1129
1130         c_conf = devm_kzalloc(dev, num_codecs * sizeof(*c_conf), GFP_KERNEL);
1131         if (!c_conf)
1132                 return -ENOMEM;
1133
1134         *codec_conf = c_conf;
1135         *codec_conf_count = num_codecs;
1136
1137         return 0;
1138 }
1139
1140 static int sof_card_dai_links_create(struct device *dev,
1141                                      struct snd_soc_acpi_mach *mach,
1142                                      struct snd_soc_card *card)
1143 {
1144         int ssp_num, sdw_be_num = 0, hdmi_num = 0, dmic_num;
1145         struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1146         struct snd_soc_dai_link_component *idisp_components;
1147         struct snd_soc_dai_link_component *ssp_components;
1148         struct snd_soc_acpi_mach_params *mach_params;
1149         const struct snd_soc_acpi_link_adr *adr_link;
1150         struct snd_soc_dai_link_component *cpus;
1151         struct snd_soc_codec_conf *codec_conf;
1152         bool ignore_pch_dmic = false;
1153         int codec_conf_count;
1154         int codec_conf_index = 0;
1155         bool group_generated[SDW_MAX_GROUPS];
1156         int ssp_codec_index, ssp_mask;
1157         struct snd_soc_dai_link *links;
1158         int num_links, link_index = 0;
1159         char *name, *cpu_name;
1160         int total_cpu_dai_num;
1161         int sdw_cpu_dai_num;
1162         int i, j, be_id = 0;
1163         int cpu_id = 0;
1164         int comp_num;
1165         int ret;
1166
1167         mach_params = &mach->mach_params;
1168
1169         /* allocate codec conf, will be populated when dailinks are created */
1170         ret = sof_card_codec_conf_alloc(dev, mach_params, &codec_conf, &codec_conf_count);
1171         if (ret < 0)
1172                 return ret;
1173
1174         /* reset amp_num to ensure amp_num++ starts from 0 in each probe */
1175         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1176                 codec_info_list[i].amp_num = 0;
1177
1178         if (mach_params->codec_mask & IDISP_CODEC_MASK) {
1179                 ctx->idisp_codec = true;
1180
1181                 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
1182                         hdmi_num = SOF_TGL_HDMI_COUNT;
1183                 else
1184                         hdmi_num = SOF_PRE_TGL_HDMI_COUNT;
1185         }
1186
1187         ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk);
1188         /*
1189          * on generic tgl platform, I2S or sdw mode is supported
1190          * based on board rework. A ACPI device is registered in
1191          * system only when I2S mode is supported, not sdw mode.
1192          * Here check ACPI ID to confirm I2S is supported.
1193          */
1194         ssp_codec_index = find_codec_info_acpi(mach->id);
1195         ssp_num = ssp_codec_index >= 0 ? hweight_long(ssp_mask) : 0;
1196         comp_num = hdmi_num + ssp_num;
1197
1198         ret = get_sdw_dailink_info(dev, mach_params->links,
1199                                    &sdw_be_num, &sdw_cpu_dai_num);
1200         if (ret < 0) {
1201                 dev_err(dev, "failed to get sdw link info %d", ret);
1202                 return ret;
1203         }
1204
1205         /* enable dmic01 & dmic16k */
1206         dmic_num = (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num) ? 2 : 0;
1207         comp_num += dmic_num;
1208
1209         if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT)
1210                 comp_num++;
1211
1212         dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d", sdw_be_num, ssp_num,
1213                 dmic_num, ctx->idisp_codec ? hdmi_num : 0);
1214
1215         /* allocate BE dailinks */
1216         num_links = comp_num + sdw_be_num;
1217         links = devm_kcalloc(dev, num_links, sizeof(*links), GFP_KERNEL);
1218
1219         /* allocated CPU DAIs */
1220         total_cpu_dai_num = comp_num + sdw_cpu_dai_num;
1221         cpus = devm_kcalloc(dev, total_cpu_dai_num, sizeof(*cpus),
1222                             GFP_KERNEL);
1223
1224         if (!links || !cpus)
1225                 return -ENOMEM;
1226
1227         /* SDW */
1228         if (!sdw_be_num)
1229                 goto SSP;
1230
1231         adr_link = mach_params->links;
1232         if (!adr_link)
1233                 return -EINVAL;
1234
1235         /*
1236          * SoundWire Slaves aggregated in the same group may be
1237          * located on different hardware links. Clear array to indicate
1238          * CPU DAIs for this group have not been generated.
1239          */
1240         for (i = 0; i < SDW_MAX_GROUPS; i++)
1241                 group_generated[i] = false;
1242
1243         /* generate DAI links by each sdw link */
1244         for (; adr_link->num_adr; adr_link++) {
1245                 const struct snd_soc_acpi_endpoint *endpoint;
1246
1247                 endpoint = adr_link->adr_d->endpoints;
1248                 if (endpoint->aggregated && !endpoint->group_id) {
1249                         dev_err(dev, "invalid group id on link %x",
1250                                 adr_link->mask);
1251                         continue;
1252                 }
1253
1254                 /* this group has been generated */
1255                 if (endpoint->aggregated &&
1256                     group_generated[endpoint->group_id])
1257                         continue;
1258
1259                 ret = create_sdw_dailink(card, dev, &link_index, links, sdw_be_num,
1260                                          sdw_cpu_dai_num, cpus, adr_link,
1261                                          &cpu_id, group_generated,
1262                                          codec_conf, codec_conf_count,
1263                                          &be_id, &codec_conf_index,
1264                                          &ignore_pch_dmic);
1265                 if (ret < 0) {
1266                         dev_err(dev, "failed to create dai link %d", link_index);
1267                         return ret;
1268                 }
1269         }
1270
1271 SSP:
1272         /* SSP */
1273         if (!ssp_num)
1274                 goto DMIC;
1275
1276         for (i = 0, j = 0; ssp_mask; i++, ssp_mask >>= 1) {
1277                 struct sof_sdw_codec_info *info;
1278                 int playback, capture;
1279                 char *codec_name;
1280
1281                 if (!(ssp_mask & 0x1))
1282                         continue;
1283
1284                 name = devm_kasprintf(dev, GFP_KERNEL,
1285                                       "SSP%d-Codec", i);
1286                 if (!name)
1287                         return -ENOMEM;
1288
1289                 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i);
1290                 if (!cpu_name)
1291                         return -ENOMEM;
1292
1293                 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components),
1294                                               GFP_KERNEL);
1295                 if (!ssp_components)
1296                         return -ENOMEM;
1297
1298                 info = &codec_info_list[ssp_codec_index];
1299                 codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d",
1300                                             info->acpi_id, j++);
1301                 if (!codec_name)
1302                         return -ENOMEM;
1303
1304                 ssp_components->name = codec_name;
1305                 ssp_components->dai_name = info->dai_name;
1306                 cpus[cpu_id].dai_name = cpu_name;
1307
1308                 playback = info->direction[SNDRV_PCM_STREAM_PLAYBACK];
1309                 capture = info->direction[SNDRV_PCM_STREAM_CAPTURE];
1310                 init_dai_link(dev, links + link_index, be_id, name,
1311                               playback, capture,
1312                               cpus + cpu_id, 1,
1313                               ssp_components, 1,
1314                               NULL, info->ops);
1315
1316                 ret = info->init(card, NULL, links + link_index, info, 0);
1317                 if (ret < 0)
1318                         return ret;
1319
1320                 INC_ID(be_id, cpu_id, link_index);
1321         }
1322
1323 DMIC:
1324         /* dmic */
1325         if (dmic_num > 0) {
1326                 if (ignore_pch_dmic) {
1327                         dev_warn(dev, "Ignoring PCH DMIC\n");
1328                         goto HDMI;
1329                 }
1330                 cpus[cpu_id].dai_name = "DMIC01 Pin";
1331                 init_dai_link(dev, links + link_index, be_id, "dmic01",
1332                               0, 1, // DMIC only supports capture
1333                               cpus + cpu_id, 1,
1334                               dmic_component, 1,
1335                               sof_sdw_dmic_init, NULL);
1336                 INC_ID(be_id, cpu_id, link_index);
1337
1338                 cpus[cpu_id].dai_name = "DMIC16k Pin";
1339                 init_dai_link(dev, links + link_index, be_id, "dmic16k",
1340                               0, 1, // DMIC only supports capture
1341                               cpus + cpu_id, 1,
1342                               dmic_component, 1,
1343                               /* don't call sof_sdw_dmic_init() twice */
1344                               NULL, NULL);
1345                 INC_ID(be_id, cpu_id, link_index);
1346         }
1347
1348 HDMI:
1349         /* HDMI */
1350         if (hdmi_num > 0) {
1351                 idisp_components = devm_kcalloc(dev, hdmi_num,
1352                                                 sizeof(*idisp_components),
1353                                                 GFP_KERNEL);
1354                 if (!idisp_components)
1355                         return -ENOMEM;
1356         }
1357
1358         for (i = 0; i < hdmi_num; i++) {
1359                 name = devm_kasprintf(dev, GFP_KERNEL,
1360                                       "iDisp%d", i + 1);
1361                 if (!name)
1362                         return -ENOMEM;
1363
1364                 if (ctx->idisp_codec) {
1365                         idisp_components[i].name = "ehdaudio0D2";
1366                         idisp_components[i].dai_name = devm_kasprintf(dev,
1367                                                                       GFP_KERNEL,
1368                                                                       "intel-hdmi-hifi%d",
1369                                                                       i + 1);
1370                         if (!idisp_components[i].dai_name)
1371                                 return -ENOMEM;
1372                 } else {
1373                         idisp_components[i].name = "snd-soc-dummy";
1374                         idisp_components[i].dai_name = "snd-soc-dummy-dai";
1375                 }
1376
1377                 cpu_name = devm_kasprintf(dev, GFP_KERNEL,
1378                                           "iDisp%d Pin", i + 1);
1379                 if (!cpu_name)
1380                         return -ENOMEM;
1381
1382                 cpus[cpu_id].dai_name = cpu_name;
1383                 init_dai_link(dev, links + link_index, be_id, name,
1384                               1, 0, // HDMI only supports playback
1385                               cpus + cpu_id, 1,
1386                               idisp_components + i, 1,
1387                               sof_sdw_hdmi_init, NULL);
1388                 INC_ID(be_id, cpu_id, link_index);
1389         }
1390
1391         if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) {
1392                 int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >>
1393                                 SOF_BT_OFFLOAD_SSP_SHIFT;
1394
1395                 name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port);
1396                 if (!name)
1397                         return -ENOMEM;
1398
1399                 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components),
1400                                                 GFP_KERNEL);
1401                 if (!ssp_components)
1402                         return -ENOMEM;
1403
1404                 ssp_components->name = "snd-soc-dummy";
1405                 ssp_components->dai_name = "snd-soc-dummy-dai";
1406
1407                 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port);
1408                 if (!cpu_name)
1409                         return -ENOMEM;
1410
1411                 cpus[cpu_id].dai_name = cpu_name;
1412                 init_dai_link(dev, links + link_index, be_id, name, 1, 1,
1413                                 cpus + cpu_id, 1, ssp_components, 1, NULL, NULL);
1414         }
1415
1416         card->dai_link = links;
1417         card->num_links = num_links;
1418
1419         card->codec_conf = codec_conf;
1420         card->num_configs = codec_conf_count;
1421
1422         return 0;
1423 }
1424
1425 static int sof_sdw_card_late_probe(struct snd_soc_card *card)
1426 {
1427         struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1428         int ret = 0;
1429         int i;
1430
1431         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1432                 if (!codec_info_list[i].late_probe)
1433                         continue;
1434
1435                 ret = codec_info_list[i].codec_card_late_probe(card);
1436                 if (ret < 0)
1437                         return ret;
1438         }
1439
1440         if (ctx->idisp_codec)
1441                 ret = sof_sdw_hdmi_card_late_probe(card);
1442
1443         return ret;
1444 }
1445
1446 /* SoC card */
1447 static const char sdw_card_long_name[] = "Intel Soundwire SOF";
1448
1449 static struct snd_soc_card card_sof_sdw = {
1450         .name = "soundwire",
1451         .owner = THIS_MODULE,
1452         .late_probe = sof_sdw_card_late_probe,
1453 };
1454
1455 static void mc_dailink_exit_loop(struct snd_soc_card *card)
1456 {
1457         struct snd_soc_dai_link *link;
1458         int ret;
1459         int i, j;
1460
1461         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1462                 if (!codec_info_list[i].exit)
1463                         continue;
1464                 /*
1465                  * We don't need to call .exit function if there is no matched
1466                  * dai link found.
1467                  */
1468                 for_each_card_prelinks(card, j, link) {
1469                         if (!strcmp(link->codecs[0].dai_name,
1470                                     codec_info_list[i].dai_name)) {
1471                                 ret = codec_info_list[i].exit(card, link);
1472                                 if (ret)
1473                                         dev_warn(card->dev,
1474                                                  "codec exit failed %d\n",
1475                                                  ret);
1476                                 break;
1477                         }
1478                 }
1479         }
1480 }
1481
1482 static int mc_probe(struct platform_device *pdev)
1483 {
1484         struct snd_soc_card *card = &card_sof_sdw;
1485         struct snd_soc_acpi_mach *mach;
1486         struct mc_private *ctx;
1487         int amp_num = 0, i;
1488         int ret;
1489
1490         dev_dbg(&pdev->dev, "Entry\n");
1491
1492         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
1493         if (!ctx)
1494                 return -ENOMEM;
1495
1496         dmi_check_system(sof_sdw_quirk_table);
1497
1498         if (quirk_override != -1) {
1499                 dev_info(&pdev->dev, "Overriding quirk 0x%lx => 0x%x\n",
1500                          sof_sdw_quirk, quirk_override);
1501                 sof_sdw_quirk = quirk_override;
1502         }
1503         log_quirks(&pdev->dev);
1504
1505         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
1506
1507         card->dev = &pdev->dev;
1508         snd_soc_card_set_drvdata(card, ctx);
1509
1510         mach = pdev->dev.platform_data;
1511         ret = sof_card_dai_links_create(&pdev->dev, mach,
1512                                         card);
1513         if (ret < 0)
1514                 return ret;
1515
1516         /*
1517          * the default amp_num is zero for each codec and
1518          * amp_num will only be increased for active amp
1519          * codecs on used platform
1520          */
1521         for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1522                 amp_num += codec_info_list[i].amp_num;
1523
1524         card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1525                                           "cfg-spk:%d cfg-amp:%d",
1526                                           (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
1527                                           ? 4 : 2, amp_num);
1528         if (!card->components)
1529                 return -ENOMEM;
1530
1531         if (mach->mach_params.dmic_num) {
1532                 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1533                                                   "%s mic:dmic cfg-mics:%d",
1534                                                   card->components,
1535                                                   mach->mach_params.dmic_num);
1536                 if (!card->components)
1537                         return -ENOMEM;
1538         }
1539
1540         card->long_name = sdw_card_long_name;
1541
1542         /* Register the card */
1543         ret = devm_snd_soc_register_card(&pdev->dev, card);
1544         if (ret) {
1545                 dev_err(card->dev, "snd_soc_register_card failed %d\n", ret);
1546                 mc_dailink_exit_loop(card);
1547                 return ret;
1548         }
1549
1550         platform_set_drvdata(pdev, card);
1551
1552         return ret;
1553 }
1554
1555 static int mc_remove(struct platform_device *pdev)
1556 {
1557         struct snd_soc_card *card = platform_get_drvdata(pdev);
1558
1559         mc_dailink_exit_loop(card);
1560
1561         return 0;
1562 }
1563
1564 static struct platform_driver sof_sdw_driver = {
1565         .driver = {
1566                 .name = "sof_sdw",
1567                 .pm = &snd_soc_pm_ops,
1568         },
1569         .probe = mc_probe,
1570         .remove = mc_remove,
1571 };
1572
1573 module_platform_driver(sof_sdw_driver);
1574
1575 MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver");
1576 MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>");
1577 MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>");
1578 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>");
1579 MODULE_LICENSE("GPL v2");
1580 MODULE_ALIAS("platform:sof_sdw");
1581 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON);
1582 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON);