Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
0004 //
0005 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
0006 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
0007 //
0008 
0009 #include <linux/acpi.h>
0010 #include <linux/module.h>
0011 #include <linux/dmi.h>
0012 #include <linux/pci.h>
0013 #include <linux/platform_device.h>
0014 #include <sound/hda_codec.h>
0015 #include <sound/hda_register.h>
0016 #include <sound/intel-nhlt.h>
0017 #include <sound/soc-acpi.h>
0018 #include <sound/soc-component.h>
0019 #include "avs.h"
0020 
0021 static bool i2s_test;
0022 module_param(i2s_test, bool, 0444);
0023 MODULE_PARM_DESC(i2s_test, "Probe I2S test-board and skip all other I2S boards");
0024 
0025 static const struct dmi_system_id kbl_dmi_table[] = {
0026     {
0027         .matches = {
0028             DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
0029             DMI_MATCH(DMI_BOARD_NAME, "Skylake Y LPDDR3 RVP3"),
0030         },
0031     },
0032     {}
0033 };
0034 
0035 static const struct dmi_system_id kblr_dmi_table[] = {
0036     {
0037         .matches = {
0038             DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
0039             DMI_MATCH(DMI_BOARD_NAME, "Kabylake R DDR4 RVP"),
0040         },
0041     },
0042     {}
0043 };
0044 
0045 static struct snd_soc_acpi_mach *dmi_match_quirk(void *arg)
0046 {
0047     struct snd_soc_acpi_mach *mach = arg;
0048     const struct dmi_system_id *dmi_id;
0049     struct dmi_system_id *dmi_table;
0050 
0051     if (mach->quirk_data == NULL)
0052         return mach;
0053 
0054     dmi_table = (struct dmi_system_id *)mach->quirk_data;
0055 
0056     dmi_id = dmi_first_match(dmi_table);
0057     if (!dmi_id)
0058         return NULL;
0059 
0060     return mach;
0061 }
0062 
0063 #define AVS_SSP(x)      (BIT(x))
0064 #define AVS_SSP_RANGE(a, b) (GENMASK(b, a))
0065 
0066 /* supported I2S board codec configurations */
0067 static struct snd_soc_acpi_mach avs_skl_i2s_machines[] = {
0068     {
0069         .id = "INT343A",
0070         .drv_name = "avs_rt286",
0071         .mach_params = {
0072             .i2s_link_mask = AVS_SSP(0),
0073         },
0074         .tplg_filename = "rt286-tplg.bin",
0075     },
0076     {
0077         .id = "10508825",
0078         .drv_name = "avs_nau8825",
0079         .mach_params = {
0080             .i2s_link_mask = AVS_SSP(1),
0081         },
0082         .tplg_filename = "nau8825-tplg.bin",
0083     },
0084     {
0085         .id = "INT343B",
0086         .drv_name = "avs_ssm4567",
0087         .mach_params = {
0088             .i2s_link_mask = AVS_SSP(0),
0089         },
0090         .tplg_filename = "ssm4567-tplg.bin",
0091     },
0092     {
0093         .id = "MX98357A",
0094         .drv_name = "avs_max98357a",
0095         .mach_params = {
0096             .i2s_link_mask = AVS_SSP(0),
0097         },
0098         .tplg_filename = "max98357a-tplg.bin",
0099     },
0100     {},
0101 };
0102 
0103 static struct snd_soc_acpi_mach avs_kbl_i2s_machines[] = {
0104     {
0105         .id = "INT343A",
0106         .drv_name = "avs_rt286",
0107         .mach_params = {
0108             .i2s_link_mask = AVS_SSP(0),
0109         },
0110         .quirk_data = &kbl_dmi_table,
0111         .machine_quirk = dmi_match_quirk,
0112         .tplg_filename = "rt286-tplg.bin",
0113     },
0114     {
0115         .id = "INT343A",
0116         .drv_name = "avs_rt298",
0117         .mach_params = {
0118             .i2s_link_mask = AVS_SSP(0),
0119         },
0120         .quirk_data = &kblr_dmi_table,
0121         .machine_quirk = dmi_match_quirk,
0122         .tplg_filename = "rt298-tplg.bin",
0123     },
0124     {
0125         .id = "MX98373",
0126         .drv_name = "avs_max98373",
0127         .mach_params = {
0128             .i2s_link_mask = AVS_SSP(0),
0129         },
0130         .tplg_filename = "max98373-tplg.bin",
0131     },
0132     {
0133         .id = "DLGS7219",
0134         .drv_name = "avs_da7219",
0135         .mach_params = {
0136             .i2s_link_mask = AVS_SSP(1),
0137         },
0138         .tplg_filename = "da7219-tplg.bin",
0139     },
0140     {},
0141 };
0142 
0143 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = {
0144     {
0145         .id = "INT343A",
0146         .drv_name = "avs_rt298",
0147         .mach_params = {
0148             .i2s_link_mask = AVS_SSP(5),
0149         },
0150         .tplg_filename = "rt298-tplg.bin",
0151     },
0152     {
0153         .id = "INT34C3",
0154         .drv_name = "avs_tdf8532",
0155         .mach_params = {
0156             .i2s_link_mask = AVS_SSP_RANGE(0, 5),
0157         },
0158         .pdata = (unsigned long[]){ 0, 0, 0x14, 0, 0, 0 }, /* SSP2 TDMs */
0159         .tplg_filename = "tdf8532-tplg.bin",
0160     },
0161     {
0162         .id = "MX98357A",
0163         .drv_name = "avs_max98357a",
0164         .mach_params = {
0165             .i2s_link_mask = AVS_SSP(5),
0166         },
0167         .tplg_filename = "max98357a-tplg.bin",
0168     },
0169     {
0170         .id = "DLGS7219",
0171         .drv_name = "avs_da7219",
0172         .mach_params = {
0173             .i2s_link_mask = AVS_SSP(1),
0174         },
0175         .tplg_filename = "da7219-tplg.bin",
0176     },
0177     {},
0178 };
0179 
0180 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = {
0181     {
0182         .id = "INT343A",
0183         .drv_name = "avs_rt298",
0184         .mach_params = {
0185             .i2s_link_mask = AVS_SSP(2),
0186         },
0187         .tplg_filename = "rt298-tplg.bin",
0188     },
0189     {},
0190 };
0191 
0192 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = {
0193     {
0194         .drv_name = "avs_i2s_test",
0195         .mach_params = {
0196             .i2s_link_mask = AVS_SSP(0),
0197         },
0198         .tplg_filename = "i2s-test-tplg.bin",
0199     },
0200     {
0201         .drv_name = "avs_i2s_test",
0202         .mach_params = {
0203             .i2s_link_mask = AVS_SSP(1),
0204         },
0205         .tplg_filename = "i2s-test-tplg.bin",
0206     },
0207     {
0208         .drv_name = "avs_i2s_test",
0209         .mach_params = {
0210             .i2s_link_mask = AVS_SSP(2),
0211         },
0212         .tplg_filename = "i2s-test-tplg.bin",
0213     },
0214     {
0215         .drv_name = "avs_i2s_test",
0216         .mach_params = {
0217             .i2s_link_mask = AVS_SSP(3),
0218         },
0219         .tplg_filename = "i2s-test-tplg.bin",
0220     },
0221     {
0222         .drv_name = "avs_i2s_test",
0223         .mach_params = {
0224             .i2s_link_mask = AVS_SSP(4),
0225         },
0226         .tplg_filename = "i2s-test-tplg.bin",
0227     },
0228     {
0229         .drv_name = "avs_i2s_test",
0230         .mach_params = {
0231             .i2s_link_mask = AVS_SSP(5),
0232         },
0233         .tplg_filename = "i2s-test-tplg.bin",
0234     },
0235     /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */
0236 };
0237 
0238 struct avs_acpi_boards {
0239     int id;
0240     struct snd_soc_acpi_mach *machs;
0241 };
0242 
0243 #define AVS_MACH_ENTRY(_id, _mach) \
0244     { .id = (_id), .machs = (_mach), }
0245 
0246 /* supported I2S boards per platform */
0247 static const struct avs_acpi_boards i2s_boards[] = {
0248     AVS_MACH_ENTRY(0x9d70, avs_skl_i2s_machines), /* SKL */
0249     AVS_MACH_ENTRY(0x9d71, avs_kbl_i2s_machines), /* KBL */
0250     AVS_MACH_ENTRY(0x5a98, avs_apl_i2s_machines), /* APL */
0251     AVS_MACH_ENTRY(0x3198, avs_gml_i2s_machines), /* GML */
0252     {},
0253 };
0254 
0255 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev)
0256 {
0257     int id, i;
0258 
0259     id = adev->base.pci->device;
0260     for (i = 0; i < ARRAY_SIZE(i2s_boards); i++)
0261         if (i2s_boards[i].id == id)
0262             return &i2s_boards[i];
0263     return NULL;
0264 }
0265 
0266 /* platform devices owned by AVS audio are removed with this hook */
0267 static void board_pdev_unregister(void *data)
0268 {
0269     platform_device_unregister(data);
0270 }
0271 
0272 static int avs_register_dmic_board(struct avs_dev *adev)
0273 {
0274     struct platform_device *codec, *board;
0275     struct snd_soc_acpi_mach mach = {{0}};
0276     int ret;
0277 
0278     if (!adev->nhlt ||
0279         !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_DMIC)) {
0280         dev_dbg(adev->dev, "no DMIC endpoints present\n");
0281         return 0;
0282     }
0283 
0284     codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0);
0285     if (IS_ERR(codec)) {
0286         dev_err(adev->dev, "dmic codec register failed\n");
0287         return PTR_ERR(codec);
0288     }
0289 
0290     ret = devm_add_action(adev->dev, board_pdev_unregister, codec);
0291     if (ret < 0) {
0292         platform_device_unregister(codec);
0293         return ret;
0294     }
0295 
0296     ret = avs_dmic_platform_register(adev, "dmic-platform");
0297     if (ret < 0)
0298         return ret;
0299 
0300     mach.tplg_filename = "dmic-tplg.bin";
0301     mach.mach_params.platform = "dmic-platform";
0302 
0303     board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE,
0304                     (const void *)&mach, sizeof(mach));
0305     if (IS_ERR(board)) {
0306         dev_err(adev->dev, "dmic board register failed\n");
0307         return PTR_ERR(board);
0308     }
0309 
0310     ret = devm_add_action(adev->dev, board_pdev_unregister, board);
0311     if (ret < 0) {
0312         platform_device_unregister(board);
0313         return ret;
0314     }
0315 
0316     return 0;
0317 }
0318 
0319 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach)
0320 {
0321     struct platform_device *board;
0322     int num_ssps;
0323     char *name;
0324     int ret;
0325 
0326     num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
0327     if (fls(mach->mach_params.i2s_link_mask) > num_ssps) {
0328         dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n",
0329             num_ssps, mach->drv_name,
0330             (unsigned long)__fls(mach->mach_params.i2s_link_mask));
0331         return -ENODEV;
0332     }
0333 
0334     name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name,
0335                   mach->mach_params.i2s_link_mask);
0336     if (!name)
0337         return -ENOMEM;
0338 
0339     ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata);
0340     if (ret < 0)
0341         return ret;
0342 
0343     mach->mach_params.platform = name;
0344 
0345     board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask,
0346                           (const void *)mach, sizeof(*mach));
0347     if (IS_ERR(board)) {
0348         dev_err(adev->dev, "ssp board register failed\n");
0349         return PTR_ERR(board);
0350     }
0351 
0352     ret = devm_add_action(adev->dev, board_pdev_unregister, board);
0353     if (ret < 0) {
0354         platform_device_unregister(board);
0355         return ret;
0356     }
0357 
0358     return 0;
0359 }
0360 
0361 static int avs_register_i2s_boards(struct avs_dev *adev)
0362 {
0363     const struct avs_acpi_boards *boards;
0364     struct snd_soc_acpi_mach *mach;
0365     int ret;
0366 
0367     if (!adev->nhlt || !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_SSP)) {
0368         dev_dbg(adev->dev, "no I2S endpoints present\n");
0369         return 0;
0370     }
0371 
0372     if (i2s_test) {
0373         int i, num_ssps;
0374 
0375         num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
0376         /* constrain just in case FW says there can be more SSPs than possible */
0377         num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps);
0378 
0379         mach = avs_test_i2s_machines;
0380 
0381         for (i = 0; i < num_ssps; i++) {
0382             ret = avs_register_i2s_board(adev, &mach[i]);
0383             if (ret < 0)
0384                 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name,
0385                      ret);
0386         }
0387         return 0;
0388     }
0389 
0390     boards = avs_get_i2s_boards(adev);
0391     if (!boards) {
0392         dev_dbg(adev->dev, "no I2S endpoints supported\n");
0393         return 0;
0394     }
0395 
0396     for (mach = boards->machs; mach->id[0]; mach++) {
0397         if (!acpi_dev_present(mach->id, NULL, -1))
0398             continue;
0399 
0400         if (mach->machine_quirk)
0401             if (!mach->machine_quirk(mach))
0402                 continue;
0403 
0404         ret = avs_register_i2s_board(adev, mach);
0405         if (ret < 0)
0406             dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret);
0407     }
0408 
0409     return 0;
0410 }
0411 
0412 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec)
0413 {
0414     struct snd_soc_acpi_mach mach = {{0}};
0415     struct platform_device *board;
0416     struct hdac_device *hdev = &codec->core;
0417     char *pname;
0418     int ret, id;
0419 
0420     pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev));
0421     if (!pname)
0422         return -ENOMEM;
0423 
0424     ret = avs_hda_platform_register(adev, pname);
0425     if (ret < 0)
0426         return ret;
0427 
0428     mach.pdata = codec;
0429     mach.mach_params.platform = pname;
0430     mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "hda-%08x-tplg.bin",
0431                         hdev->vendor_id);
0432     if (!mach.tplg_filename)
0433         return -ENOMEM;
0434 
0435     id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr;
0436     board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach,
0437                           sizeof(mach));
0438     if (IS_ERR(board)) {
0439         dev_err(adev->dev, "hda board register failed\n");
0440         return PTR_ERR(board);
0441     }
0442 
0443     ret = devm_add_action(adev->dev, board_pdev_unregister, board);
0444     if (ret < 0) {
0445         platform_device_unregister(board);
0446         return ret;
0447     }
0448 
0449     return 0;
0450 }
0451 
0452 static int avs_register_hda_boards(struct avs_dev *adev)
0453 {
0454     struct hdac_bus *bus = &adev->base.core;
0455     struct hdac_device *hdev;
0456     int ret;
0457 
0458     if (!bus->num_codecs) {
0459         dev_dbg(adev->dev, "no HDA endpoints present\n");
0460         return 0;
0461     }
0462 
0463     list_for_each_entry(hdev, &bus->codec_list, list) {
0464         struct hda_codec *codec;
0465 
0466         codec = dev_to_hda_codec(&hdev->dev);
0467 
0468         ret = avs_register_hda_board(adev, codec);
0469         if (ret < 0)
0470             dev_warn(adev->dev, "register hda-%08x failed: %d\n",
0471                  codec->core.vendor_id, ret);
0472     }
0473 
0474     return 0;
0475 }
0476 
0477 int avs_register_all_boards(struct avs_dev *adev)
0478 {
0479     int ret;
0480 
0481     ret = avs_register_dmic_board(adev);
0482     if (ret < 0)
0483         dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n",
0484              ret);
0485 
0486     ret = avs_register_i2s_boards(adev);
0487     if (ret < 0)
0488         dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n",
0489              ret);
0490 
0491     ret = avs_register_hda_boards(adev);
0492     if (ret < 0)
0493         dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n",
0494              ret);
0495 
0496     return 0;
0497 }
0498 
0499 void avs_unregister_all_boards(struct avs_dev *adev)
0500 {
0501     snd_soc_unregister_component(adev->dev);
0502 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!