sound/soc/intel/avs/board_selection.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
   4 //
   5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
   6 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
   7 //
   8
   9 #include <linux/acpi.h>
  10 #include <linux/module.h>
  11 #include <linux/dmi.h>
  12 #include <linux/pci.h>
  13 #include <linux/platform_device.h>
  14 #include <sound/hda_codec.h>
  15 #include <sound/hda_register.h>
  16 #include <sound/intel-nhlt.h>
  17 #include <sound/soc-acpi.h>
  18 #include <sound/soc-component.h>
  19 #include "avs.h"
  20
  21 static bool i2s_test;
  22 module_param(i2s_test, bool, 0444);
  23 MODULE_PARM_DESC(i2s_test, "Probe I2S test-board and skip all other I2S boards");
  24
  25 static const struct dmi_system_id kbl_dmi_table[] = {
  26         {
  27                 .matches = {
  28                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
  29                         DMI_MATCH(DMI_BOARD_NAME, "Skylake Y LPDDR3 RVP3"),
  30                 },
  31         },
  32         {}
  33 };
  34
  35 static const struct dmi_system_id kblr_dmi_table[] = {
  36         {
  37                 .matches = {
  38                         DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
  39                         DMI_MATCH(DMI_BOARD_NAME, "Kabylake R DDR4 RVP"),
  40                 },
  41         },
  42         {}
  43 };
  44
  45 static struct snd_soc_acpi_mach *dmi_match_quirk(void *arg)
  46 {
  47         struct snd_soc_acpi_mach *mach = arg;
  48         const struct dmi_system_id *dmi_id;
  49         struct dmi_system_id *dmi_table;
  50
  51         if (mach->quirk_data == NULL)
  52                 return mach;
  53
  54         dmi_table = (struct dmi_system_id *)mach->quirk_data;
  55
  56         dmi_id = dmi_first_match(dmi_table);
  57         if (!dmi_id)
  58                 return NULL;
  59
  60         return mach;
  61 }
  62
  63 #define AVS_SSP(x)              (BIT(x))
  64 #define AVS_SSP_RANGE(a, b)     (GENMASK(b, a))
  65
  66 /* supported I2S board codec configurations */
  67 static struct snd_soc_acpi_mach avs_skl_i2s_machines[] = {
  68         {
  69                 .id = "INT343A",
  70                 .drv_name = "avs_rt286",
  71                 .mach_params = {
  72                         .i2s_link_mask = AVS_SSP(0),
  73                 },
  74                 .tplg_filename = "/*(DEBLOBBED)*/",
  75         },
  76         {
  77                 .id = "10508825",
  78                 .drv_name = "avs_nau8825",
  79                 .mach_params = {
  80                         .i2s_link_mask = AVS_SSP(1),
  81                 },
  82                 .tplg_filename = "/*(DEBLOBBED)*/",
  83         },
  84         {
  85                 .id = "INT343B",
  86                 .drv_name = "avs_ssm4567",
  87                 .mach_params = {
  88                         .i2s_link_mask = AVS_SSP(0),
  89                 },
  90                 .tplg_filename = "/*(DEBLOBBED)*/",
  91         },
  92         {
  93                 .id = "MX98357A",
  94                 .drv_name = "avs_max98357a",
  95                 .mach_params = {
  96                         .i2s_link_mask = AVS_SSP(0),
  97                 },
  98                 .tplg_filename = "/*(DEBLOBBED)*/",
  99         },
 100         {},
 101 };
 102
 103 static struct snd_soc_acpi_mach avs_kbl_i2s_machines[] = {
 104         {
 105                 .id = "INT343A",
 106                 .drv_name = "avs_rt286",
 107                 .mach_params = {
 108                         .i2s_link_mask = AVS_SSP(0),
 109                 },
 110                 .quirk_data = &kbl_dmi_table,
 111                 .machine_quirk = dmi_match_quirk,
 112                 .tplg_filename = "/*(DEBLOBBED)*/",
 113         },
 114         {
 115                 .id = "INT343A",
 116                 .drv_name = "avs_rt298",
 117                 .mach_params = {
 118                         .i2s_link_mask = AVS_SSP(0),
 119                 },
 120                 .quirk_data = &kblr_dmi_table,
 121                 .machine_quirk = dmi_match_quirk,
 122                 .tplg_filename = "/*(DEBLOBBED)*/",
 123         },
 124         {
 125                 .id = "MX98373",
 126                 .drv_name = "avs_max98373",
 127                 .mach_params = {
 128                         .i2s_link_mask = AVS_SSP(0),
 129                 },
 130                 .tplg_filename = "/*(DEBLOBBED)*/",
 131         },
 132         {
 133                 .id = "DLGS7219",
 134                 .drv_name = "avs_da7219",
 135                 .mach_params = {
 136                         .i2s_link_mask = AVS_SSP(1),
 137                 },
 138                 .tplg_filename = "/*(DEBLOBBED)*/",
 139         },
 140         {},
 141 };
 142
 143 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = {
 144         {
 145                 .id = "INT343A",
 146                 .drv_name = "avs_rt298",
 147                 .mach_params = {
 148                         .i2s_link_mask = AVS_SSP(5),
 149                 },
 150                 .tplg_filename = "/*(DEBLOBBED)*/",
 151         },
 152         {
 153                 .id = "INT34C3",
 154                 .drv_name = "avs_tdf8532",
 155                 .mach_params = {
 156                         .i2s_link_mask = AVS_SSP_RANGE(0, 5),
 157                 },
 158                 .pdata = (unsigned long[]){ 0, 0, 0x14, 0, 0, 0 }, /* SSP2 TDMs */
 159                 .tplg_filename = "/*(DEBLOBBED)*/",
 160         },
 161         {
 162                 .id = "MX98357A",
 163                 .drv_name = "avs_max98357a",
 164                 .mach_params = {
 165                         .i2s_link_mask = AVS_SSP(5),
 166                 },
 167                 .tplg_filename = "/*(DEBLOBBED)*/",
 168         },
 169         {
 170                 .id = "DLGS7219",
 171                 .drv_name = "avs_da7219",
 172                 .mach_params = {
 173                         .i2s_link_mask = AVS_SSP(1),
 174                 },
 175                 .tplg_filename = "/*(DEBLOBBED)*/",
 176         },
 177         {},
 178 };
 179
 180 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = {
 181         {
 182                 .id = "INT343A",
 183                 .drv_name = "avs_rt298",
 184                 .mach_params = {
 185                         .i2s_link_mask = AVS_SSP(2),
 186                 },
 187                 .tplg_filename = "/*(DEBLOBBED)*/",
 188         },
 189         {},
 190 };
 191
 192 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = {
 193         {
 194                 .drv_name = "avs_i2s_test",
 195                 .mach_params = {
 196                         .i2s_link_mask = AVS_SSP(0),
 197                 },
 198                 .tplg_filename = "/*(DEBLOBBED)*/",
 199         },
 200         {
 201                 .drv_name = "avs_i2s_test",
 202                 .mach_params = {
 203                         .i2s_link_mask = AVS_SSP(1),
 204                 },
 205                 .tplg_filename = "/*(DEBLOBBED)*/",
 206         },
 207         {
 208                 .drv_name = "avs_i2s_test",
 209                 .mach_params = {
 210                         .i2s_link_mask = AVS_SSP(2),
 211                 },
 212                 .tplg_filename = "/*(DEBLOBBED)*/",
 213         },
 214         {
 215                 .drv_name = "avs_i2s_test",
 216                 .mach_params = {
 217                         .i2s_link_mask = AVS_SSP(3),
 218                 },
 219                 .tplg_filename = "/*(DEBLOBBED)*/",
 220         },
 221         {
 222                 .drv_name = "avs_i2s_test",
 223                 .mach_params = {
 224                         .i2s_link_mask = AVS_SSP(4),
 225                 },
 226                 .tplg_filename = "/*(DEBLOBBED)*/",
 227         },
 228         {
 229                 .drv_name = "avs_i2s_test",
 230                 .mach_params = {
 231                         .i2s_link_mask = AVS_SSP(5),
 232                 },
 233                 .tplg_filename = "/*(DEBLOBBED)*/",
 234         },
 235         /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */
 236 };
 237
 238 struct avs_acpi_boards {
 239         int id;
 240         struct snd_soc_acpi_mach *machs;
 241 };
 242
 243 #define AVS_MACH_ENTRY(_id, _mach) \
 244         { .id = (_id), .machs = (_mach), }
 245
 246 /* supported I2S boards per platform */
 247 static const struct avs_acpi_boards i2s_boards[] = {
 248         AVS_MACH_ENTRY(0x9d70, avs_skl_i2s_machines), /* SKL */
 249         AVS_MACH_ENTRY(0x9d71, avs_kbl_i2s_machines), /* KBL */
 250         AVS_MACH_ENTRY(0x5a98, avs_apl_i2s_machines), /* APL */
 251         AVS_MACH_ENTRY(0x3198, avs_gml_i2s_machines), /* GML */
 252         {},
 253 };
 254
 255 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev)
 256 {
 257         int id, i;
 258
 259         id = adev->base.pci->device;
 260         for (i = 0; i < ARRAY_SIZE(i2s_boards); i++)
 261                 if (i2s_boards[i].id == id)
 262                         return &i2s_boards[i];
 263         return NULL;
 264 }
 265
 266 /* platform devices owned by AVS audio are removed with this hook */
 267 static void board_pdev_unregister(void *data)
 268 {
 269         platform_device_unregister(data);
 270 }
 271
 272 static int avs_register_dmic_board(struct avs_dev *adev)
 273 {
 274         struct platform_device *codec, *board;
 275         struct snd_soc_acpi_mach mach = {{0}};
 276         int ret;
 277
 278         if (!adev->nhlt ||
 279             !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_DMIC)) {
 280                 dev_dbg(adev->dev, "no DMIC endpoints present\n");
 281                 return 0;
 282         }
 283
 284         codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0);
 285         if (IS_ERR(codec)) {
 286                 dev_err(adev->dev, "dmic codec register failed\n");
 287                 return PTR_ERR(codec);
 288         }
 289
 290         ret = devm_add_action(adev->dev, board_pdev_unregister, codec);
 291         if (ret < 0) {
 292                 platform_device_unregister(codec);
 293                 return ret;
 294         }
 295
 296         ret = avs_dmic_platform_register(adev, "dmic-platform");
 297         if (ret < 0)
 298                 return ret;
 299
 300         mach.tplg_filename = "/*(DEBLOBBED)*/";
 301         mach.mach_params.platform = "dmic-platform";
 302
 303         board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE,
 304                                         (const void *)&mach, sizeof(mach));
 305         if (IS_ERR(board)) {
 306                 dev_err(adev->dev, "dmic board register failed\n");
 307                 return PTR_ERR(board);
 308         }
 309
 310         ret = devm_add_action(adev->dev, board_pdev_unregister, board);
 311         if (ret < 0) {
 312                 platform_device_unregister(board);
 313                 return ret;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach)
 320 {
 321         struct platform_device *board;
 322         int num_ssps;
 323         char *name;
 324         int ret;
 325
 326         num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
 327         if (fls(mach->mach_params.i2s_link_mask) > num_ssps) {
 328                 dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n",
 329                         num_ssps, mach->drv_name,
 330                         (unsigned long)__fls(mach->mach_params.i2s_link_mask));
 331                 return -ENODEV;
 332         }
 333
 334         name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name,
 335                               mach->mach_params.i2s_link_mask);
 336         if (!name)
 337                 return -ENOMEM;
 338
 339         ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata);
 340         if (ret < 0)
 341                 return ret;
 342
 343         mach->mach_params.platform = name;
 344
 345         board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask,
 346                                               (const void *)mach, sizeof(*mach));
 347         if (IS_ERR(board)) {
 348                 dev_err(adev->dev, "ssp board register failed\n");
 349                 return PTR_ERR(board);
 350         }
 351
 352         ret = devm_add_action(adev->dev, board_pdev_unregister, board);
 353         if (ret < 0) {
 354                 platform_device_unregister(board);
 355                 return ret;
 356         }
 357
 358         return 0;
 359 }
 360
 361 static int avs_register_i2s_boards(struct avs_dev *adev)
 362 {
 363         const struct avs_acpi_boards *boards;
 364         struct snd_soc_acpi_mach *mach;
 365         int ret;
 366
 367         if (!adev->nhlt || !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_SSP)) {
 368                 dev_dbg(adev->dev, "no I2S endpoints present\n");
 369                 return 0;
 370         }
 371
 372         if (i2s_test) {
 373                 int i, num_ssps;
 374
 375                 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
 376                 /* constrain just in case FW says there can be more SSPs than possible */
 377                 num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps);
 378
 379                 mach = avs_test_i2s_machines;
 380
 381                 for (i = 0; i < num_ssps; i++) {
 382                         ret = avs_register_i2s_board(adev, &mach[i]);
 383                         if (ret < 0)
 384                                 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name,
 385                                          ret);
 386                 }
 387                 return 0;
 388         }
 389
 390         boards = avs_get_i2s_boards(adev);
 391         if (!boards) {
 392                 dev_dbg(adev->dev, "no I2S endpoints supported\n");
 393                 return 0;
 394         }
 395
 396         for (mach = boards->machs; mach->id[0]; mach++) {
 397                 if (!acpi_dev_present(mach->id, NULL, -1))
 398                         continue;
 399
 400                 if (mach->machine_quirk)
 401                         if (!mach->machine_quirk(mach))
 402                                 continue;
 403
 404                 ret = avs_register_i2s_board(adev, mach);
 405                 if (ret < 0)
 406                         dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret);
 407         }
 408
 409         return 0;
 410 }
 411
 412 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec)
 413 {
 414         struct snd_soc_acpi_mach mach = {{0}};
 415         struct platform_device *board;
 416         struct hdac_device *hdev = &codec->core;
 417         char *pname;
 418         int ret, id;
 419
 420         pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev));
 421         if (!pname)
 422                 return -ENOMEM;
 423
 424         ret = avs_hda_platform_register(adev, pname);
 425         if (ret < 0)
 426                 return ret;
 427
 428         mach.pdata = codec;
 429         mach.mach_params.platform = pname;
 430         mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "/*(DEBLOBBED)*/",
 431                                             hdev->vendor_id);
 432         if (!mach.tplg_filename)
 433                 return -ENOMEM;
 434
 435         id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr;
 436         board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach,
 437                                               sizeof(mach));
 438         if (IS_ERR(board)) {
 439                 dev_err(adev->dev, "hda board register failed\n");
 440                 return PTR_ERR(board);
 441         }
 442
 443         ret = devm_add_action(adev->dev, board_pdev_unregister, board);
 444         if (ret < 0) {
 445                 platform_device_unregister(board);
 446                 return ret;
 447         }
 448
 449         return 0;
 450 }
 451
 452 static int avs_register_hda_boards(struct avs_dev *adev)
 453 {
 454         struct hdac_bus *bus = &adev->base.core;
 455         struct hdac_device *hdev;
 456         int ret;
 457
 458         if (!bus->num_codecs) {
 459                 dev_dbg(adev->dev, "no HDA endpoints present\n");
 460                 return 0;
 461         }
 462
 463         list_for_each_entry(hdev, &bus->codec_list, list) {
 464                 struct hda_codec *codec;
 465
 466                 codec = dev_to_hda_codec(&hdev->dev);
 467
 468                 ret = avs_register_hda_board(adev, codec);
 469                 if (ret < 0)
 470                         dev_warn(adev->dev, "register hda-%08x failed: %d\n",
 471                                  codec->core.vendor_id, ret);
 472         }
 473
 474         return 0;
 475 }
 476
 477 int avs_register_all_boards(struct avs_dev *adev)
 478 {
 479         int ret;
 480
 481         ret = avs_register_dmic_board(adev);
 482         if (ret < 0)
 483                 dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n",
 484                          ret);
 485
 486         ret = avs_register_i2s_boards(adev);
 487         if (ret < 0)
 488                 dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n",
 489                          ret);
 490
 491         ret = avs_register_hda_boards(adev);
 492         if (ret < 0)
 493                 dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n",
 494                          ret);
 495
 496         return 0;
 497 }
 498
 499 void avs_unregister_all_boards(struct avs_dev *adev)
 500 {
 501         snd_soc_unregister_component(adev->dev);
 502 }