korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-13 22:14:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Stefan Binding 2024-04-11 12:08:11 +01:00 committed by Takashi Iwai
parent b627054837
commit 068fc7f326
3 changed files with 71 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sound/pci/hda/Kconfig
View File

@ -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.

138
sound/pci/hda/cs35l41_hda.c
View File

@ -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 (!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_AMBIENT_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_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
CAL_DSP_CTL_ALG, &r0, 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_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 (ret) {
dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
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);
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;
/* 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);
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;
/* 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);

3
sound/pci/hda/cs35l41_hda.h
View File

@ -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;
};