ALSA: hda: cs35l41: Use shared cs-amp-lib to apply calibration

The original mechanism for applying calibration assumed that the
calibration data would be ordered the same as the amp instances.
However, for some 4 amp laptops, this is not the case.
To ensure that the correct calibration is applied to the correct amp,
the calibration data contains a unique id, which matches a unique id
inside the CS35L41. This can be used to match to the correct data
entry. This mechanism is available inside the shared module cs-amp-lib.

Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Message-ID: <20240411110813.330483-6-sbinding@opensource.cirrus.com>

diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index f806636242ee902c4fd5ac58d5d60aa0b6befd89..0da625533afc27ac4e1fd6bce5e22e0a748122a6 100644 (file)
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -128,6 +128,7 @@ config SND_HDA_SCODEC_CS35L41_I2C
        select SND_SOC_CS35L41_LIB
        select SND_HDA_SCODEC_CS35L41
        select SND_HDA_CS_DSP_CONTROLS
+       select SND_SOC_CS_AMP_LIB
        help
          Say Y or M here to include CS35L41 I2C HD-audio side codec support
          in snd-hda-intel driver, such as ALC287.
@@ -144,6 +145,7 @@ config SND_HDA_SCODEC_CS35L41_SPI
        select SND_SOC_CS35L41_LIB
        select SND_HDA_SCODEC_CS35L41
        select SND_HDA_CS_DSP_CONTROLS
+       select SND_SOC_CS_AMP_LIB
        help
          Say Y or M here to include CS35L41 SPI HD-audio side codec support
          in snd-hda-intel driver, such as ALC287.

diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
index 17e812c60ac9b63c3f50ceb04efa602ccd6310a7..5208e9c06af0bcb240e1f43483992a44b8ae7387 100644 (file)
--- a/sound/pci/hda/cs35l41_hda.c
+++ b/sound/pci/hda/cs35l41_hda.c
@@ -64,6 +64,16 @@ struct cs35l41_tuning_params {
        u8 data[];
 } __packed;
 
+/* Firmware calibration controls */
+static const struct cirrus_amp_cal_controls cs35l41_calibration_controls = {
+       .alg_id =       CAL_DSP_CTL_ALG,
+       .mem_region =   CAL_DSP_CTL_TYPE,
+       .ambient =      CAL_AMBIENT_DSP_CTL_NAME,
+       .calr =         CAL_R_DSP_CTL_NAME,
+       .status =       CAL_STATUS_DSP_CTL_NAME,
+       .checksum =     CAL_CHECKSUM_DSP_CTL_NAME,
+};
+
 static bool firmware_autostart = 1;
 module_param(firmware_autostart, bool, 0444);
 MODULE_PARM_DESC(firmware_autostart, "Allow automatic firmware download on boot"
@@ -403,95 +413,74 @@ fallback:
                                              coeff_firmware, coeff_filename);
 }
 
-#if IS_ENABLED(CONFIG_EFI)
-static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, __be32 ambient, __be32 r0,
-                                    __be32 status, __be32 checksum)
+
+static void cs35l41_hda_apply_calibration(struct cs35l41_hda *cs35l41)
 {
        int ret;
 
-       ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
-                                  CAL_DSP_CTL_ALG, &ambient, 4);
-       if (ret) {
-               dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
-                       ret);
-               return ret;
-       }
-       ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
-                                  CAL_DSP_CTL_ALG, &r0, 4);
-       if (ret) {
-               dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
-               return ret;
-       }
-       ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
-                                  CAL_DSP_CTL_ALG, &status, 4);
+       if (!cs35l41->cal_data_valid)
+               return;
+
+       ret = cs_amp_write_cal_coeffs(&cs35l41->cs_dsp, &cs35l41_calibration_controls,
+                                     &cs35l41->cal_data);
+       if (ret < 0)
+               dev_warn(cs35l41->dev, "Failed to apply calibration: %d\n", ret);
+       else
+               dev_info(cs35l41->dev, "Calibration applied: R0=%d\n", cs35l41->cal_data.calR);
+}
+
+static int cs35l41_read_silicon_uid(struct cs35l41_hda *cs35l41, u64 *uid)
+{
+       u32 tmp;
+       int ret;
+
+       ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS2, &tmp);
        if (ret) {
-               dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
-                       ret);
+               dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS2: %d\n", ret);
                return ret;
        }
-       ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
-                                  CAL_DSP_CTL_ALG, &checksum, 4);
+
+       *uid = tmp;
+       *uid <<= 32;
+
+       ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS1, &tmp);
        if (ret) {
-               dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
-                       ret);
+               dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS1: %d\n", ret);
                return ret;
        }
 
+       *uid |= tmp;
+
+       dev_dbg(cs35l41->dev, "UniqueID = %#llx\n", *uid);
+
        return 0;
 }
 
-static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
+static int cs35l41_get_calibration(struct cs35l41_hda *cs35l41)
 {
-       static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe,
-                                             0x5a, 0xa3, 0x5d, 0xb3);
-       static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData";
-       const struct cs35l41_amp_efi_data *efi_data;
-       const struct cs35l41_amp_cal_data *cl;
-       unsigned long data_size = 0;
-       efi_status_t status;
-       int ret = 0;
-       u8 *data = NULL;
-       u32 attr;
+       u64 silicon_uid;
+       int ret;
+
+       ret = cs35l41_read_silicon_uid(cs35l41, &silicon_uid);
+       if (ret < 0)
+               return ret;
+
+       ret = cs_amp_get_efi_calibration_data(cs35l41->dev, silicon_uid,
+                                             cs35l41->index,
+                                             &cs35l41->cal_data);
+
+       /* Only return an error status if probe should be aborted */
+       if ((ret == -ENOENT) || (ret == -EOVERFLOW))
+               return 0;
+
+       if (ret < 0)
+               return ret;
+
+       cs35l41->cal_data_valid = true;
 
-       /* Get real size of UEFI variable */
-       status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
-       if (status == EFI_BUFFER_TOO_SMALL) {
-               ret = -ENODEV;
-               /* Allocate data buffer of data_size bytes */
-               data = vmalloc(data_size);
-               if (!data)
-                       return -ENOMEM;
-               /* Get variable contents into buffer */
-               status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
-               if (status == EFI_SUCCESS) {
-                       efi_data = (struct cs35l41_amp_efi_data *)data;
-                       dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
-                               efi_data->size, efi_data->count);
-                       if (efi_data->count > cs35l41->index) {
-                               cl = &efi_data->data[cs35l41->index];
-                               dev_dbg(cs35l41->dev,
-                                       "Calibration: Ambient=%02x, Status=%02x, R0=%d\n",
-                                       cl->calAmbient, cl->calStatus, cl->calR);
-
-                               /* Calibration can only be applied whilst the DSP is not running */
-                               ret = cs35l41_apply_calibration(cs35l41,
-                                                               cpu_to_be32(cl->calAmbient),
-                                                               cpu_to_be32(cl->calR),
-                                                               cpu_to_be32(cl->calStatus),
-                                                               cpu_to_be32(cl->calR + 1));
-                       }
-               }
-               vfree(data);
-       }
-       return ret;
-}
-#else
-static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
-{
-       dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
        return 0;
 }
-#endif
+
 
 static void cs35l41_set_default_tuning_params(struct cs35l41_hda *cs35l41)
 {
@@ -624,7 +613,7 @@ static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
 
        cs35l41_add_controls(cs35l41);
 
-       ret = cs35l41_save_calibration(cs35l41);
+       cs35l41_hda_apply_calibration(cs35l41);
 
 err:
        if (ret)
@@ -1960,6 +1949,10 @@ int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int i
        if (ret)
                goto err;
 
+       ret = cs35l41_get_calibration(cs35l41);
+       if (ret && ret != -ENOENT)
+               goto err;
+
        cs35l41_mute(cs35l41->dev, true);
 
        INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
@@ -2040,6 +2033,7 @@ EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
 
 MODULE_DESCRIPTION("CS35L41 HDA Driver");
 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
+MODULE_IMPORT_NS(SND_SOC_CS_AMP_LIB);
 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
 MODULE_LICENSE("GPL");
 MODULE_IMPORT_NS(FW_CS_DSP);

diff --git a/sound/pci/hda/cs35l41_hda.h b/sound/pci/hda/cs35l41_hda.h
index d60aa98bfafca6e8384ba9458ceb62df39d2446b..b0bebb7784623052a63349f7f6d1301f37792952 100644 (file)
--- a/sound/pci/hda/cs35l41_hda.h
+++ b/sound/pci/hda/cs35l41_hda.h
@@ -16,6 +16,7 @@
 #include <linux/gpio/consumer.h>
 #include <linux/device.h>
 #include <sound/cs35l41.h>
+#include <sound/cs-amp-lib.h>
 
 #include <linux/firmware/cirrus/cs_dsp.h>
 #include <linux/firmware/cirrus/wmfw.h>
@@ -86,6 +87,8 @@ struct cs35l41_hda {
        enum control_bus control_bus;
        bool bypass_fw;
        unsigned int tuning_gain;
+       struct cirrus_amp_cal_data cal_data;
+       bool cal_data_valid;
 
 };