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/acpi.h>
   9 #include <linux/bitmap.h>
  10 #include <linux/device.h>
  11 #include <linux/dmi.h>
  12 #include <linux/module.h>
  13 #include <linux/soundwire/sdw.h>
  14 #include <linux/soundwire/sdw_type.h>
  15 #include <linux/soundwire/sdw_intel.h>
  16 #include <sound/soc-acpi.h>
  17 #include "sof_sdw_common.h"
  18 #include "../../codecs/rt711.h"
  19
  20 static unsigned long sof_sdw_quirk = RT711_JD1;
  21 static int quirk_override = -1;
  22 module_param_named(quirk, quirk_override, int, 0444);
  23 MODULE_PARM_DESC(quirk, "Board-specific quirk override");
  24
  25 static void log_quirks(struct device *dev)
  26 {
  27         if (SOC_SDW_JACK_JDSRC(sof_sdw_quirk))
  28                 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n",
  29                         SOC_SDW_JACK_JDSRC(sof_sdw_quirk));
  30         if (sof_sdw_quirk & SOC_SDW_FOUR_SPK)
  31                 dev_err(dev, "quirk SOC_SDW_FOUR_SPK enabled but no longer supported\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 & SOC_SDW_PCH_DMIC)
  35                 dev_dbg(dev, "quirk SOC_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 & SOC_SDW_NO_AGGREGATION)
  40                 dev_err(dev, "quirk SOC_SDW_NO_AGGREGATION enabled but no longer supported\n");
  41         if (sof_sdw_quirk & SOC_SDW_CODEC_SPKR)
  42                 dev_dbg(dev, "quirk SOC_SDW_CODEC_SPKR enabled\n");
  43         if (sof_sdw_quirk & SOC_SDW_SIDECAR_AMPS)
  44                 dev_dbg(dev, "quirk SOC_SDW_SIDECAR_AMPS enabled\n");
  45 }
  46
  47 static int sof_sdw_quirk_cb(const struct dmi_system_id *id)
  48 {
  49         sof_sdw_quirk = (unsigned long)id->driver_data;
  50         return 1;
  51 }
  52
  53 static const struct dmi_system_id sof_sdw_quirk_table[] = {
  54         /* CometLake devices */
  55         {
  56                 .callback = sof_sdw_quirk_cb,
  57                 .matches = {
  58                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
  59                         DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"),
  60                 },
  61                 .driver_data = (void *)SOC_SDW_PCH_DMIC,
  62         },
  63         {
  64                 .callback = sof_sdw_quirk_cb,
  65                 .matches = {
  66                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  67                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
  68                 },
  69                 .driver_data = (void *)RT711_JD2,
  70         },
  71         {
  72                 /* early version of SKU 09C6 */
  73                 .callback = sof_sdw_quirk_cb,
  74                 .matches = {
  75                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  76                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
  77                 },
  78                 .driver_data = (void *)RT711_JD2,
  79         },
  80         {
  81                 .callback = sof_sdw_quirk_cb,
  82                 .matches = {
  83                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  84                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
  85                 },
  86                 .driver_data = (void *)(RT711_JD2),
  87         },
  88         {
  89                 .callback = sof_sdw_quirk_cb,
  90                 .matches = {
  91                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
  92                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
  93                 },
  94                 .driver_data = (void *)(RT711_JD2),
  95         },
  96         /* IceLake devices */
  97         {
  98                 .callback = sof_sdw_quirk_cb,
  99                 .matches = {
 100                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 101                         DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"),
 102                 },
 103                 .driver_data = (void *)SOC_SDW_PCH_DMIC,
 104         },
 105         /* TigerLake devices */
 106         {
 107                 .callback = sof_sdw_quirk_cb,
 108                 .matches = {
 109                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 110                         DMI_MATCH(DMI_PRODUCT_NAME,
 111                                   "Tiger Lake Client Platform"),
 112                 },
 113                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 114                                         RT711_JD1 |
 115                                         SOC_SDW_PCH_DMIC |
 116                                         SOF_SSP_PORT(SOF_I2S_SSP2)),
 117         },
 118         {
 119                 .callback = sof_sdw_quirk_cb,
 120                 .matches = {
 121                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 122                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E")
 123                 },
 124                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 125                                         RT711_JD2),
 126         },
 127         {
 128                 /* another SKU of Dell Latitude 9520 */
 129                 .callback = sof_sdw_quirk_cb,
 130                 .matches = {
 131                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 132                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3F")
 133                 },
 134                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 135                                         RT711_JD2),
 136         },
 137         {
 138                 /* Dell XPS 9710 */
 139                 .callback = sof_sdw_quirk_cb,
 140                 .matches = {
 141                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 142                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D")
 143                 },
 144                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 145                                         RT711_JD2),
 146         },
 147         {
 148                 .callback = sof_sdw_quirk_cb,
 149                 .matches = {
 150                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 151                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5E")
 152                 },
 153                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 154                                         RT711_JD2),
 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                                         SOC_SDW_PCH_DMIC |
 164                                         SOF_BT_OFFLOAD_SSP(2) |
 165                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 166         },
 167         {
 168                 .callback = sof_sdw_quirk_cb,
 169                 .matches = {
 170                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 171                         DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"),
 172                 },
 173                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 174                                         SOC_SDW_PCH_DMIC),
 175         },
 176         {
 177                 /*
 178                  * this entry covers multiple HP SKUs. The family name
 179                  * does not seem robust enough, so we use a partial
 180                  * match that ignores the product name suffix
 181                  * (e.g. 15-eb1xxx, 14t-ea000 or 13-aw2xxx)
 182                  */
 183                 .callback = sof_sdw_quirk_cb,
 184                 .matches = {
 185                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 186                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Conv"),
 187                 },
 188                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 189                                         SOC_SDW_PCH_DMIC |
 190                                         RT711_JD1),
 191         },
 192         {
 193                 /*
 194                  * this entry covers HP Spectre x360 where the DMI information
 195                  * changed somehow
 196                  */
 197                 .callback = sof_sdw_quirk_cb,
 198                 .matches = {
 199                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 200                         DMI_MATCH(DMI_BOARD_NAME, "8709"),
 201                 },
 202                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 203                                         SOC_SDW_PCH_DMIC |
 204                                         RT711_JD1),
 205         },
 206         {
 207                 /* NUC15 'Bishop County' LAPBC510 and LAPBC710 skews */
 208                 .callback = sof_sdw_quirk_cb,
 209                 .matches = {
 210                         DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
 211                         DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"),
 212                 },
 213                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 214                                         SOC_SDW_PCH_DMIC |
 215                                         RT711_JD1),
 216         },
 217         {
 218                 /* NUC15 LAPBC710 skews */
 219                 .callback = sof_sdw_quirk_cb,
 220                 .matches = {
 221                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 222                         DMI_MATCH(DMI_BOARD_NAME, "LAPBC710"),
 223                 },
 224                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 225                                         SOC_SDW_PCH_DMIC |
 226                                         RT711_JD1),
 227         },
 228         {
 229                 /* NUC15 'Rooks County' LAPRC510 and LAPRC710 skews */
 230                 .callback = sof_sdw_quirk_cb,
 231                 .matches = {
 232                         DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
 233                         DMI_MATCH(DMI_PRODUCT_NAME, "LAPRC"),
 234                 },
 235                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 236                                         SOC_SDW_PCH_DMIC |
 237                                         RT711_JD2_100K),
 238         },
 239         {
 240                 /* NUC15 LAPRC710 skews */
 241                 .callback = sof_sdw_quirk_cb,
 242                 .matches = {
 243                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 244                         DMI_MATCH(DMI_BOARD_NAME, "LAPRC710"),
 245                 },
 246                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 247                                         SOC_SDW_PCH_DMIC |
 248                                         RT711_JD2_100K),
 249         },
 250         /* TigerLake-SDCA devices */
 251         {
 252                 .callback = sof_sdw_quirk_cb,
 253                 .matches = {
 254                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 255                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32")
 256                 },
 257                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 258                                         RT711_JD2),
 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, "0A45")
 265                 },
 266                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 267                                         RT711_JD2),
 268         },
 269         /* AlderLake devices */
 270         {
 271                 .callback = sof_sdw_quirk_cb,
 272                 .matches = {
 273                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 274                         DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"),
 275                 },
 276                 .driver_data = (void *)(RT711_JD2_100K |
 277                                         SOF_SDW_TGL_HDMI |
 278                                         SOF_BT_OFFLOAD_SSP(2) |
 279                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 280         },
 281         {
 282                 .callback = sof_sdw_quirk_cb,
 283                 .matches = {
 284                         DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
 285                         DMI_MATCH(DMI_PRODUCT_SKU, "0000000000070000"),
 286                 },
 287                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 288                                         RT711_JD2_100K),
 289         },
 290         {
 291                 .callback = sof_sdw_quirk_cb,
 292                 .matches = {
 293                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 294                         DMI_MATCH(DMI_PRODUCT_NAME, "Brya"),
 295                 },
 296                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 297                                         SOC_SDW_PCH_DMIC |
 298                                         SOF_BT_OFFLOAD_SSP(2) |
 299                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 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, "0AF0")
 306                 },
 307                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 308                                         RT711_JD2),
 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, "0AF3"),
 315                 },
 316                 /* No Jack */
 317                 .driver_data = (void *)(SOF_SDW_TGL_HDMI),
 318         },
 319         {
 320                 .callback = sof_sdw_quirk_cb,
 321                 .matches = {
 322                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 323                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFE")
 324                 },
 325                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 326                                         RT711_JD2),
 327         },
 328         {
 329                 .callback = sof_sdw_quirk_cb,
 330                 .matches = {
 331                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 332                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFF")
 333                 },
 334                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 335                                         RT711_JD2),
 336         },
 337         {
 338                 .callback = sof_sdw_quirk_cb,
 339                 .matches = {
 340                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 341                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B00")
 342                 },
 343                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 344                                         RT711_JD2),
 345         },
 346         {
 347                 .callback = sof_sdw_quirk_cb,
 348                 .matches = {
 349                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 350                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B01")
 351                 },
 352                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 353                                         RT711_JD2),
 354         },
 355         {
 356                 .callback = sof_sdw_quirk_cb,
 357                 .matches = {
 358                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 359                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B11")
 360                 },
 361                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 362                                         RT711_JD2),
 363         },
 364         {
 365                 .callback = sof_sdw_quirk_cb,
 366                 .matches = {
 367                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 368                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B12")
 369                 },
 370                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 371                                         RT711_JD2),
 372         },
 373         {
 374                 .callback = sof_sdw_quirk_cb,
 375                 .matches = {
 376                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 377                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B13"),
 378                 },
 379                 /* No Jack */
 380                 .driver_data = (void *)SOF_SDW_TGL_HDMI,
 381         },
 382         {
 383                 .callback = sof_sdw_quirk_cb,
 384                 .matches = {
 385                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 386                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B14"),
 387                 },
 388                 /* No Jack */
 389                 .driver_data = (void *)SOF_SDW_TGL_HDMI,
 390         },
 391
 392         {
 393                 .callback = sof_sdw_quirk_cb,
 394                 .matches = {
 395                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 396                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B29"),
 397                 },
 398                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 399                                         RT711_JD2),
 400         },
 401         {
 402                 .callback = sof_sdw_quirk_cb,
 403                 .matches = {
 404                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 405                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B34"),
 406                 },
 407                 /* No Jack */
 408                 .driver_data = (void *)SOF_SDW_TGL_HDMI,
 409         },
 410         {
 411                 .callback = sof_sdw_quirk_cb,
 412                 .matches = {
 413                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 414                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B8C"),
 415                 },
 416                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 417                                         RT711_JD2),
 418         },
 419         {
 420                 .callback = sof_sdw_quirk_cb,
 421                 .matches = {
 422                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 423                         DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16"),
 424                 },
 425                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 426                                         RT711_JD2),
 427         },
 428         /* RaptorLake devices */
 429         {
 430                 .callback = sof_sdw_quirk_cb,
 431                 .matches = {
 432                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 433                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0BDA")
 434                 },
 435                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 436                                         RT711_JD2),
 437         },
 438         {
 439                 .callback = sof_sdw_quirk_cb,
 440                 .matches = {
 441                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 442                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C0F")
 443                 },
 444                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 445                                         RT711_JD2),
 446         },
 447         {
 448                 .callback = sof_sdw_quirk_cb,
 449                 .matches = {
 450                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 451                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C10"),
 452                 },
 453                 /* No Jack */
 454                 .driver_data = (void *)(SOF_SDW_TGL_HDMI),
 455         },
 456         {
 457                 .callback = sof_sdw_quirk_cb,
 458                 .matches = {
 459                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 460                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C11")
 461                 },
 462                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 463                                         RT711_JD2),
 464         },
 465         {
 466                 .callback = sof_sdw_quirk_cb,
 467                 .matches = {
 468                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 469                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C40")
 470                 },
 471                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 472                                         RT711_JD2),
 473         },
 474         {
 475                 .callback = sof_sdw_quirk_cb,
 476                 .matches = {
 477                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 478                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C4F")
 479                 },
 480                 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
 481                                         RT711_JD2),
 482         },
 483         {
 484                 .callback = sof_sdw_quirk_cb,
 485                 .matches = {
 486                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 487                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF6")
 488                 },
 489                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 490         },
 491         {
 492                 .callback = sof_sdw_quirk_cb,
 493                 .matches = {
 494                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 495                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF9")
 496                 },
 497                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 498         },
 499         {
 500                 .callback = sof_sdw_quirk_cb,
 501                 .matches = {
 502                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 503                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CFA")
 504                 },
 505                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 506         },
 507         /* MeteorLake devices */
 508         {
 509                 .callback = sof_sdw_quirk_cb,
 510                 .matches = {
 511                         DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_mtlrvp"),
 512                 },
 513                 .driver_data = (void *)(RT711_JD1),
 514         },
 515         {
 516                 .callback = sof_sdw_quirk_cb,
 517                 .matches = {
 518                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 519                         DMI_MATCH(DMI_PRODUCT_NAME, "Meteor Lake Client Platform"),
 520                 },
 521                 .driver_data = (void *)(RT711_JD2_100K),
 522         },
 523         {
 524                 .callback = sof_sdw_quirk_cb,
 525                 .matches = {
 526                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
 527                         DMI_MATCH(DMI_PRODUCT_NAME, "Rex"),
 528                 },
 529                 .driver_data = (void *)(SOC_SDW_PCH_DMIC |
 530                                         SOF_BT_OFFLOAD_SSP(1) |
 531                                         SOF_SSP_BT_OFFLOAD_PRESENT),
 532         },
 533         {
 534                 .callback = sof_sdw_quirk_cb,
 535                 .matches = {
 536                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 537                         DMI_MATCH(DMI_PRODUCT_NAME, "OMEN Transcend Gaming Laptop"),
 538                 },
 539                 .driver_data = (void *)(RT711_JD2),
 540         },
 541
 542         /* LunarLake devices */
 543         {
 544                 .callback = sof_sdw_quirk_cb,
 545                 .matches = {
 546                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
 547                         DMI_MATCH(DMI_PRODUCT_NAME, "Lunar Lake Client Platform"),
 548                 },
 549                 .driver_data = (void *)(RT711_JD2),
 550         },
 551         {
 552                 .callback = sof_sdw_quirk_cb,
 553                 .matches = {
 554                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 555                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CE3")
 556                 },
 557                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 558         },
 559         {
 560                 .callback = sof_sdw_quirk_cb,
 561                 .matches = {
 562                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 563                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CE4")
 564                 },
 565                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 566         },
 567         {
 568                 .callback = sof_sdw_quirk_cb,
 569                 .matches = {
 570                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 571                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CDB")
 572                 },
 573                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 574         },
 575         {
 576                 .callback = sof_sdw_quirk_cb,
 577                 .matches = {
 578                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 579                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CDC")
 580                 },
 581                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 582         },
 583         {
 584                 .callback = sof_sdw_quirk_cb,
 585                 .matches = {
 586                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 587                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CDD")
 588                 },
 589                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 590         },
 591         {
 592                 .callback = sof_sdw_quirk_cb,
 593                 .matches = {
 594                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 595                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0D36")
 596                 },
 597                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 598         },
 599         {
 600                 .callback = sof_sdw_quirk_cb,
 601                 .matches = {
 602                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 603                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF8")
 604                 },
 605                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 606         },
 607         {
 608                 .callback = sof_sdw_quirk_cb,
 609                 .matches = {
 610                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 611                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "3838")
 612                 },
 613                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 614         },
 615         {
 616                 .callback = sof_sdw_quirk_cb,
 617                 .matches = {
 618                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 619                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "3832")
 620                 },
 621                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 622         },
 623         {
 624                 .callback = sof_sdw_quirk_cb,
 625                 .matches = {
 626                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 627                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "380E")
 628                 },
 629                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 630         },
 631         {
 632                 .callback = sof_sdw_quirk_cb,
 633                 .matches = {
 634                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 635                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "233C")
 636                 },
 637                 /* Note this quirk excludes the CODEC mic */
 638                 .driver_data = (void *)(SOC_SDW_CODEC_MIC),
 639         },
 640         {
 641                 .callback = sof_sdw_quirk_cb,
 642                 .matches = {
 643                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 644                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "233B")
 645                 },
 646                 .driver_data = (void *)(SOC_SDW_SIDECAR_AMPS),
 647         },
 648
 649         /* ArrowLake devices */
 650         {
 651                 .callback = sof_sdw_quirk_cb,
 652                 .matches = {
 653                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 654                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CE8")
 655                 },
 656                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 657         },
 658         {
 659                 .callback = sof_sdw_quirk_cb,
 660                 .matches = {
 661                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 662                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF1")
 663                 },
 664                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 665         },
 666         {
 667                 .callback = sof_sdw_quirk_cb,
 668                 .matches = {
 669                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 670                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF7")
 671                 },
 672                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 673         },
 674         {
 675                 .callback = sof_sdw_quirk_cb,
 676                 .matches = {
 677                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 678                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF0")
 679                 },
 680                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 681         },
 682         {
 683                 .callback = sof_sdw_quirk_cb,
 684                 .matches = {
 685                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 686                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF3")
 687                 },
 688                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 689         },
 690         {
 691                 .callback = sof_sdw_quirk_cb,
 692                 .matches = {
 693                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 694                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF4")
 695                 },
 696                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 697         },
 698         {
 699                 .callback = sof_sdw_quirk_cb,
 700                 .matches = {
 701                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 702                         DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CF5")
 703                 },
 704                 .driver_data = (void *)(SOC_SDW_CODEC_SPKR),
 705         },
 706         /* Pantherlake devices*/
 707         {
 708                 .callback = sof_sdw_quirk_cb,
 709                 .matches = {
 710                         DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_ptlrvp"),
 711                 },
 712                 .driver_data = (void *)(SOC_SDW_PCH_DMIC),
 713         },
 714         {}
 715 };
 716
 717 static struct snd_soc_dai_link_component platform_component[] = {
 718         {
 719                 /* name might be overridden during probe */
 720                 .name = "0000:00:1f.3"
 721         }
 722 };
 723
 724 static const struct snd_soc_ops sdw_ops = {
 725         .startup = asoc_sdw_startup,
 726         .prepare = asoc_sdw_prepare,
 727         .trigger = asoc_sdw_trigger,
 728         .hw_params = asoc_sdw_hw_params,
 729         .hw_free = asoc_sdw_hw_free,
 730         .shutdown = asoc_sdw_shutdown,
 731 };
 732
 733 static const char * const type_strings[] = {"SimpleJack", "SmartAmp", "SmartMic"};
 734
 735 static int create_sdw_dailink(struct snd_soc_card *card,
 736                               struct asoc_sdw_dailink *sof_dai,
 737                               struct snd_soc_dai_link **dai_links,
 738                               int *be_id, struct snd_soc_codec_conf **codec_conf)
 739 {
 740         struct device *dev = card->dev;
 741         struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
 742         struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private;
 743         struct asoc_sdw_endpoint *sof_end;
 744         int stream;
 745         int ret;
 746
 747         list_for_each_entry(sof_end, &sof_dai->endpoints, list) {
 748                 if (sof_end->name_prefix) {
 749                         (*codec_conf)->dlc.name = sof_end->codec_name;
 750                         (*codec_conf)->name_prefix = sof_end->name_prefix;
 751                         (*codec_conf)++;
 752                 }
 753
 754                 if (sof_end->include_sidecar) {
 755                         ret = sof_end->codec_info->add_sidecar(card, dai_links, codec_conf);
 756                         if (ret)
 757                                 return ret;
 758                 }
 759         }
 760
 761         for_each_pcm_streams(stream) {
 762                 static const char * const sdw_stream_name[] = {
 763                         "SDW%d-Playback",
 764                         "SDW%d-Capture",
 765                         "SDW%d-Playback-%s",
 766                         "SDW%d-Capture-%s",
 767                 };
 768                 struct snd_soc_dai_link_ch_map *codec_maps;
 769                 struct snd_soc_dai_link_component *codecs;
 770                 struct snd_soc_dai_link_component *cpus;
 771                 int num_cpus = hweight32(sof_dai->link_mask[stream]);
 772                 int num_codecs = sof_dai->num_devs[stream];
 773                 int playback, capture;
 774                 int cur_link = 0;
 775                 int i = 0, j = 0;
 776                 char *name;
 777
 778                 if (!sof_dai->num_devs[stream])
 779                         continue;
 780
 781                 sof_end = list_first_entry(&sof_dai->endpoints,
 782                                            struct asoc_sdw_endpoint, list);
 783
 784                 *be_id = sof_end->dai_info->dailink[stream];
 785                 if (*be_id < 0) {
 786                         dev_err(dev, "Invalid dailink id %d\n", *be_id);
 787                         return -EINVAL;
 788                 }
 789
 790                 /* create stream name according to first link id */
 791                 if (ctx->append_dai_type)
 792                         name = devm_kasprintf(dev, GFP_KERNEL,
 793                                               sdw_stream_name[stream + 2],
 794                                               ffs(sof_end->link_mask) - 1,
 795                                               type_strings[sof_end->dai_info->dai_type]);
 796                 else
 797                         name = devm_kasprintf(dev, GFP_KERNEL,
 798                                               sdw_stream_name[stream],
 799                                               ffs(sof_end->link_mask) - 1);
 800                 if (!name)
 801                         return -ENOMEM;
 802
 803                 cpus = devm_kcalloc(dev, num_cpus, sizeof(*cpus), GFP_KERNEL);
 804                 if (!cpus)
 805                         return -ENOMEM;
 806
 807                 codecs = devm_kcalloc(dev, num_codecs, sizeof(*codecs), GFP_KERNEL);
 808                 if (!codecs)
 809                         return -ENOMEM;
 810
 811                 codec_maps = devm_kcalloc(dev, num_codecs, sizeof(*codec_maps), GFP_KERNEL);
 812                 if (!codec_maps)
 813                         return -ENOMEM;
 814
 815                 list_for_each_entry(sof_end, &sof_dai->endpoints, list) {
 816                         if (!sof_end->dai_info->direction[stream])
 817                                 continue;
 818
 819                         if (cur_link != sof_end->link_mask) {
 820                                 int link_num = ffs(sof_end->link_mask) - 1;
 821                                 int pin_num = intel_ctx->sdw_pin_index[link_num]++;
 822
 823                                 cur_link = sof_end->link_mask;
 824
 825                                 cpus[i].dai_name = devm_kasprintf(dev, GFP_KERNEL,
 826                                                                   "SDW%d Pin%d",
 827                                                                   link_num, pin_num);
 828                                 if (!cpus[i].dai_name)
 829                                         return -ENOMEM;
 830                                 i++;
 831                         }
 832
 833                         codec_maps[j].cpu = i - 1;
 834                         codec_maps[j].codec = j;
 835
 836                         codecs[j].name = sof_end->codec_name;
 837                         codecs[j].dai_name = sof_end->dai_info->dai_name;
 838                         j++;
 839                 }
 840
 841                 WARN_ON(i != num_cpus || j != num_codecs);
 842
 843                 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK);
 844                 capture = (stream == SNDRV_PCM_STREAM_CAPTURE);
 845
 846                 asoc_sdw_init_dai_link(dev, *dai_links, be_id, name, playback, capture,
 847                                        cpus, num_cpus, platform_component,
 848                                        ARRAY_SIZE(platform_component), codecs, num_codecs,
 849                                        1, asoc_sdw_rtd_init, &sdw_ops);
 850
 851                 /*
 852                  * SoundWire DAILINKs use 'stream' functions and Bank Switch operations
 853                  * based on wait_for_completion(), tag them as 'nonatomic'.
 854                  */
 855                 (*dai_links)->nonatomic = true;
 856                 (*dai_links)->ch_maps = codec_maps;
 857
 858                 list_for_each_entry(sof_end, &sof_dai->endpoints, list) {
 859                         if (sof_end->dai_info->init)
 860                                 sof_end->dai_info->init(card, *dai_links,
 861                                                         sof_end->codec_info,
 862                                                         playback);
 863                 }
 864
 865                 (*dai_links)++;
 866         }
 867
 868         return 0;
 869 }
 870
 871 static int create_sdw_dailinks(struct snd_soc_card *card,
 872                                struct snd_soc_dai_link **dai_links, int *be_id,
 873                                struct asoc_sdw_dailink *sof_dais,
 874                                struct snd_soc_codec_conf **codec_conf)
 875 {
 876         struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
 877         struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private;
 878         int ret, i;
 879
 880         for (i = 0; i < SDW_INTEL_MAX_LINKS; i++)
 881                 intel_ctx->sdw_pin_index[i] = SOC_SDW_INTEL_BIDIR_PDI_BASE;
 882
 883         /* generate DAI links by each sdw link */
 884         while (sof_dais->initialised) {
 885                 int current_be_id;
 886
 887                 ret = create_sdw_dailink(card, sof_dais, dai_links,
 888                                          &current_be_id, codec_conf);
 889                 if (ret)
 890                         return ret;
 891
 892                 /* Update the be_id to match the highest ID used for SDW link */
 893                 if (*be_id < current_be_id)
 894                         *be_id = current_be_id;
 895
 896                 sof_dais++;
 897         }
 898
 899         return 0;
 900 }
 901
 902 static int create_ssp_dailinks(struct snd_soc_card *card,
 903                                struct snd_soc_dai_link **dai_links, int *be_id,
 904                                struct asoc_sdw_codec_info *ssp_info,
 905                                unsigned long ssp_mask)
 906 {
 907         struct device *dev = card->dev;
 908         int i, j = 0;
 909         int ret;
 910
 911         for_each_set_bit(i, &ssp_mask, BITS_PER_TYPE(ssp_mask)) {
 912                 char *name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", i);
 913                 char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i);
 914                 char *codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d",
 915                                                   ssp_info->acpi_id, j++);
 916                 if (!name || !cpu_dai_name || !codec_name)
 917                         return -ENOMEM;
 918
 919                 int playback = ssp_info->dais[0].direction[SNDRV_PCM_STREAM_PLAYBACK];
 920                 int capture = ssp_info->dais[0].direction[SNDRV_PCM_STREAM_CAPTURE];
 921
 922                 ret = asoc_sdw_init_simple_dai_link(dev, *dai_links, be_id, name,
 923                                                     playback, capture, cpu_dai_name,
 924                                                     platform_component->name,
 925                                                     ARRAY_SIZE(platform_component), codec_name,
 926                                                     ssp_info->dais[0].dai_name, 1, NULL,
 927                                                     ssp_info->ops);
 928                 if (ret)
 929                         return ret;
 930
 931                 ret = ssp_info->dais[0].init(card, *dai_links, ssp_info, 0);
 932                 if (ret < 0)
 933                         return ret;
 934
 935                 (*dai_links)++;
 936         }
 937
 938         return 0;
 939 }
 940
 941 static int create_dmic_dailinks(struct snd_soc_card *card,
 942                                 struct snd_soc_dai_link **dai_links, int *be_id)
 943 {
 944         struct device *dev = card->dev;
 945         int ret;
 946
 947         ret = asoc_sdw_init_simple_dai_link(dev, *dai_links, be_id, "dmic01",
 948                                             0, 1, // DMIC only supports capture
 949                                             "DMIC01 Pin", platform_component->name,
 950                                             ARRAY_SIZE(platform_component),
 951                                             "dmic-codec", "dmic-hifi", 1,
 952                                             asoc_sdw_dmic_init, NULL);
 953         if (ret)
 954                 return ret;
 955
 956         (*dai_links)++;
 957
 958         ret = asoc_sdw_init_simple_dai_link(dev, *dai_links, be_id, "dmic16k",
 959                                             0, 1, // DMIC only supports capture
 960                                             "DMIC16k Pin", platform_component->name,
 961                                             ARRAY_SIZE(platform_component),
 962                                             "dmic-codec", "dmic-hifi", 1,
 963                                             /* don't call asoc_sdw_dmic_init() twice */
 964                                             NULL, NULL);
 965         if (ret)
 966                 return ret;
 967
 968         (*dai_links)++;
 969
 970         return 0;
 971 }
 972
 973 static int create_hdmi_dailinks(struct snd_soc_card *card,
 974                                 struct snd_soc_dai_link **dai_links, int *be_id,
 975                                 int hdmi_num)
 976 {
 977         struct device *dev = card->dev;
 978         struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
 979         struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private;
 980         int i, ret;
 981
 982         for (i = 0; i < hdmi_num; i++) {
 983                 char *name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d", i + 1);
 984                 char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d Pin", i + 1);
 985                 if (!name || !cpu_dai_name)
 986                         return -ENOMEM;
 987
 988                 char *codec_name, *codec_dai_name;
 989
 990                 if (intel_ctx->hdmi.idisp_codec) {
 991                         codec_name = "ehdaudio0D2";
 992                         codec_dai_name = devm_kasprintf(dev, GFP_KERNEL,
 993                                                         "intel-hdmi-hifi%d", i + 1);
 994                 } else {
 995                         codec_name = "snd-soc-dummy";
 996                         codec_dai_name = "snd-soc-dummy-dai";
 997                 }
 998
 999                 if (!codec_dai_name)
1000                         return -ENOMEM;
1001
1002                 ret = asoc_sdw_init_simple_dai_link(dev, *dai_links, be_id, name,
1003                                                     1, 0, // HDMI only supports playback
1004                                                     cpu_dai_name, platform_component->name,
1005                                                     ARRAY_SIZE(platform_component),
1006                                                     codec_name, codec_dai_name, 1,
1007                                                     i == 0 ? sof_sdw_hdmi_init : NULL, NULL);
1008                 if (ret)
1009                         return ret;
1010
1011                 (*dai_links)++;
1012         }
1013
1014         return 0;
1015 }
1016
1017 static int create_bt_dailinks(struct snd_soc_card *card,
1018                               struct snd_soc_dai_link **dai_links, int *be_id)
1019 {
1020         struct device *dev = card->dev;
1021         int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >>
1022                         SOF_BT_OFFLOAD_SSP_SHIFT;
1023         char *name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port);
1024         char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port);
1025         if (!name || !cpu_dai_name)
1026                 return -ENOMEM;
1027
1028         int ret;
1029
1030         ret = asoc_sdw_init_simple_dai_link(dev, *dai_links, be_id, name,
1031                                             1, 1, cpu_dai_name, platform_component->name,
1032                                             ARRAY_SIZE(platform_component),
1033                                             snd_soc_dummy_dlc.name, snd_soc_dummy_dlc.dai_name,
1034                                             1, NULL, NULL);
1035         if (ret)
1036                 return ret;
1037
1038         (*dai_links)++;
1039
1040         return 0;
1041 }
1042
1043 static int sof_card_dai_links_create(struct snd_soc_card *card)
1044 {
1045         struct device *dev = card->dev;
1046         struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev);
1047         int sdw_be_num = 0, ssp_num = 0, dmic_num = 0, bt_num = 0;
1048         struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
1049         struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private;
1050         struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params;
1051         struct snd_soc_codec_conf *codec_conf;
1052         struct asoc_sdw_codec_info *ssp_info;
1053         struct asoc_sdw_endpoint *sof_ends;
1054         struct asoc_sdw_dailink *sof_dais;
1055         int num_devs = 0;
1056         int num_ends = 0;
1057         struct snd_soc_dai_link *dai_links;
1058         int num_links;
1059         int be_id = 0;
1060         int hdmi_num;
1061         unsigned long ssp_mask;
1062         int ret;
1063
1064         ret = asoc_sdw_count_sdw_endpoints(card, &num_devs, &num_ends);
1065         if (ret < 0) {
1066                 dev_err(dev, "failed to count devices/endpoints: %d\n", ret);
1067                 return ret;
1068         }
1069
1070         /* One per DAI link, worst case is a DAI link for every endpoint */
1071         sof_dais = kcalloc(num_ends, sizeof(*sof_dais), GFP_KERNEL);
1072         if (!sof_dais)
1073                 return -ENOMEM;
1074
1075         /* One per endpoint, ie. each DAI on each codec/amp */
1076         sof_ends = kcalloc(num_ends, sizeof(*sof_ends), GFP_KERNEL);
1077         if (!sof_ends) {
1078                 ret = -ENOMEM;
1079                 goto err_dai;
1080         }
1081
1082         ret = asoc_sdw_parse_sdw_endpoints(card, sof_dais, sof_ends, &num_devs);
1083         if (ret < 0)
1084                 goto err_end;
1085
1086         sdw_be_num = ret;
1087
1088         /*
1089          * on generic tgl platform, I2S or sdw mode is supported
1090          * based on board rework. A ACPI device is registered in
1091          * system only when I2S mode is supported, not sdw mode.
1092          * Here check ACPI ID to confirm I2S is supported.
1093          */
1094         ssp_info = asoc_sdw_find_codec_info_acpi(mach->id);
1095         if (ssp_info) {
1096                 ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk);
1097                 ssp_num = hweight_long(ssp_mask);
1098         }
1099
1100         if (mach_params->codec_mask & IDISP_CODEC_MASK)
1101                 intel_ctx->hdmi.idisp_codec = true;
1102
1103         if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
1104                 hdmi_num = SOF_TGL_HDMI_COUNT;
1105         else
1106                 hdmi_num = SOF_PRE_TGL_HDMI_COUNT;
1107
1108         /* enable dmic01 & dmic16k */
1109         if (sof_sdw_quirk & SOC_SDW_PCH_DMIC || mach_params->dmic_num) {
1110                 if (ctx->ignore_internal_dmic)
1111                         dev_warn(dev, "Ignoring PCH DMIC\n");
1112                 else
1113                         dmic_num = 2;
1114         }
1115         /*
1116          * mach_params->dmic_num will be used to set the cfg-mics value of card->components
1117          * string. Overwrite it to the actual number of PCH DMICs used in the device.
1118          */
1119         mach_params->dmic_num = dmic_num;
1120
1121         if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT)
1122                 bt_num = 1;
1123
1124         dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d, bt: %d\n",
1125                 sdw_be_num, ssp_num, dmic_num,
1126                 intel_ctx->hdmi.idisp_codec ? hdmi_num : 0, bt_num);
1127
1128         codec_conf = devm_kcalloc(dev, num_devs, sizeof(*codec_conf), GFP_KERNEL);
1129         if (!codec_conf) {
1130                 ret = -ENOMEM;
1131                 goto err_end;
1132         }
1133
1134         /* allocate BE dailinks */
1135         num_links = sdw_be_num + ssp_num + dmic_num + hdmi_num + bt_num;
1136         dai_links = devm_kcalloc(dev, num_links, sizeof(*dai_links), GFP_KERNEL);
1137         if (!dai_links) {
1138                 ret = -ENOMEM;
1139                 goto err_end;
1140         }
1141
1142         card->codec_conf = codec_conf;
1143         card->num_configs = num_devs;
1144         card->dai_link = dai_links;
1145         card->num_links = num_links;
1146
1147         /* SDW */
1148         if (sdw_be_num) {
1149                 ret = create_sdw_dailinks(card, &dai_links, &be_id,
1150                                           sof_dais, &codec_conf);
1151                 if (ret)
1152                         goto err_end;
1153         }
1154
1155         /* SSP */
1156         if (ssp_num) {
1157                 ret = create_ssp_dailinks(card, &dai_links, &be_id,
1158                                           ssp_info, ssp_mask);
1159                 if (ret)
1160                         goto err_end;
1161         }
1162
1163         /* dmic */
1164         if (dmic_num) {
1165                 ret = create_dmic_dailinks(card, &dai_links, &be_id);
1166                 if (ret)
1167                         goto err_end;
1168         }
1169
1170         /* HDMI */
1171         ret = create_hdmi_dailinks(card, &dai_links, &be_id, hdmi_num);
1172         if (ret)
1173                 goto err_end;
1174
1175         /* BT */
1176         if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) {
1177                 ret = create_bt_dailinks(card, &dai_links, &be_id);
1178                 if (ret)
1179                         goto err_end;
1180         }
1181
1182         WARN_ON(codec_conf != card->codec_conf + card->num_configs);
1183         WARN_ON(dai_links != card->dai_link + card->num_links);
1184
1185 err_end:
1186         kfree(sof_ends);
1187 err_dai:
1188         kfree(sof_dais);
1189
1190         return ret;
1191 }
1192
1193 static int sof_sdw_card_late_probe(struct snd_soc_card *card)
1194 {
1195         struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
1196         struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private;
1197         int ret = 0;
1198
1199         ret = asoc_sdw_card_late_probe(card);
1200         if (ret < 0)
1201                 return ret;
1202
1203         if (intel_ctx->hdmi.idisp_codec)
1204                 ret = sof_sdw_hdmi_card_late_probe(card);
1205
1206         return ret;
1207 }
1208
1209 static int mc_probe(struct platform_device *pdev)
1210 {
1211         struct snd_soc_acpi_mach *mach = dev_get_platdata(&pdev->dev);
1212         struct snd_soc_card *card;
1213         struct asoc_sdw_mc_private *ctx;
1214         struct intel_mc_ctx *intel_ctx;
1215         int amp_num = 0, i;
1216         int ret;
1217
1218         dev_dbg(&pdev->dev, "Entry\n");
1219
1220         intel_ctx = devm_kzalloc(&pdev->dev, sizeof(*intel_ctx), GFP_KERNEL);
1221         if (!intel_ctx)
1222                 return -ENOMEM;
1223
1224         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
1225         if (!ctx)
1226                 return -ENOMEM;
1227
1228         ctx->private = intel_ctx;
1229         ctx->codec_info_list_count = asoc_sdw_get_codec_info_list_count();
1230         card = &ctx->card;
1231         card->dev = &pdev->dev;
1232         card->name = "soundwire";
1233         card->owner = THIS_MODULE;
1234         card->late_probe = sof_sdw_card_late_probe;
1235
1236         snd_soc_card_set_drvdata(card, ctx);
1237
1238         dmi_check_system(sof_sdw_quirk_table);
1239
1240         if (quirk_override != -1) {
1241                 dev_info(card->dev, "Overriding quirk 0x%lx => 0x%x\n",
1242                          sof_sdw_quirk, quirk_override);
1243                 sof_sdw_quirk = quirk_override;
1244         }
1245
1246         log_quirks(card->dev);
1247
1248         ctx->mc_quirk = sof_sdw_quirk;
1249         /* reset amp_num to ensure amp_num++ starts from 0 in each probe */
1250         for (i = 0; i < ctx->codec_info_list_count; i++)
1251                 codec_info_list[i].amp_num = 0;
1252
1253         if (mach->mach_params.subsystem_id_set) {
1254                 snd_soc_card_set_pci_ssid(card,
1255                                           mach->mach_params.subsystem_vendor,
1256                                           mach->mach_params.subsystem_device);
1257         }
1258
1259         ret = sof_card_dai_links_create(card);
1260         if (ret < 0)
1261                 return ret;
1262
1263         /*
1264          * the default amp_num is zero for each codec and
1265          * amp_num will only be increased for active amp
1266          * codecs on used platform
1267          */
1268         for (i = 0; i < ctx->codec_info_list_count; i++)
1269                 amp_num += codec_info_list[i].amp_num;
1270
1271         card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1272                                           " cfg-amp:%d", amp_num);
1273         if (!card->components)
1274                 return -ENOMEM;
1275
1276         if (mach->mach_params.dmic_num) {
1277                 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1278                                                   "%s mic:dmic cfg-mics:%d",
1279                                                   card->components,
1280                                                   mach->mach_params.dmic_num);
1281                 if (!card->components)
1282                         return -ENOMEM;
1283         }
1284
1285         /* Register the card */
1286         ret = devm_snd_soc_register_card(card->dev, card);
1287         if (ret) {
1288                 dev_err_probe(card->dev, ret, "snd_soc_register_card failed %d\n", ret);
1289                 asoc_sdw_mc_dailink_exit_loop(card);
1290                 return ret;
1291         }
1292
1293         platform_set_drvdata(pdev, card);
1294
1295         return ret;
1296 }
1297
1298 static void mc_remove(struct platform_device *pdev)
1299 {
1300         struct snd_soc_card *card = platform_get_drvdata(pdev);
1301
1302         asoc_sdw_mc_dailink_exit_loop(card);
1303 }
1304
1305 static const struct platform_device_id mc_id_table[] = {
1306         { "sof_sdw", },
1307         {}
1308 };
1309 MODULE_DEVICE_TABLE(platform, mc_id_table);
1310
1311 static struct platform_driver sof_sdw_driver = {
1312         .driver = {
1313                 .name = "sof_sdw",
1314                 .pm = &snd_soc_pm_ops,
1315         },
1316         .probe = mc_probe,
1317         .remove = mc_remove,
1318         .id_table = mc_id_table,
1319 };
1320
1321 module_platform_driver(sof_sdw_driver);
1322
1323 MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver");
1324 MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>");
1325 MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>");
1326 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>");
1327 MODULE_LICENSE("GPL v2");
1328 MODULE_IMPORT_NS("SND_SOC_INTEL_HDA_DSP_COMMON");
1329 MODULE_IMPORT_NS("SND_SOC_SDW_UTILS");