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