1// SPDX-License-Identifier: GPL-2.0
2//
3// TAS2781 HDA Shared Lib for I2C&SPI driver
4//
5// Copyright 2025 Texas Instruments, Inc.
6//
7// Author: Shenghao Ding <shenghao-ding@ti.com>
8
9#include <linux/component.h>
10#include <linux/crc8.h>
11#include <linux/crc32.h>
12#include <linux/efi.h>
13#include <linux/firmware.h>
14#include <linux/i2c.h>
15#include <linux/pm_runtime.h>
16#include <sound/soc.h>
17#include <sound/tas2781.h>
18
19#include "tas2781_hda.h"
20
21#define CALIBRATION_DATA_AREA_NUM 2
22
23const efi_guid_t tasdev_fct_efi_guid[] = {
24 /* DELL */
25 EFI_GUID(0xcc92382d, 0x6337, 0x41cb, 0xa8, 0x8b, 0x8e, 0xce, 0x74,
26 0x91, 0xea, 0x9f),
27 /* HP */
28 EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe, 0x5a,
29 0xa3, 0x5d, 0xb3),
30 /* LENOVO & OTHERS */
31 EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, 0x09, 0x43, 0xa3, 0xf4,
32 0x31, 0x0a, 0x92),
33};
34EXPORT_SYMBOL_NS_GPL(tasdev_fct_efi_guid, "SND_HDA_SCODEC_TAS2781");
35
36/*
37 * The order of calibrated-data writing function is a bit different from the
38 * order in UEFI. Here is the conversion to match the order of calibrated-data
39 * writing function.
40 */
41static void cali_cnv(unsigned char *data, unsigned int base, int offset)
42{
43 struct cali_reg reg_data;
44
45 memcpy(&reg_data, &data[base], sizeof(reg_data));
46 /* the data order has to be swapped between r0_low_reg and inv0_reg */
47 swap(reg_data.r0_low_reg, reg_data.invr0_reg);
48
49 cpu_to_be32_array(dst: (__force __be32 *)(data + offset + 1),
50 src: (u32 *)&reg_data, TASDEV_CALIB_N);
51}
52
53static void tas2781_apply_calib(struct tasdevice_priv *p)
54{
55 struct calidata *cali_data = &p->cali_data;
56 struct cali_reg *r = &cali_data->cali_reg_array;
57 unsigned char *data = cali_data->data;
58 unsigned int *tmp_val = (unsigned int *)data;
59 unsigned int cali_reg[TASDEV_CALIB_N] = {
60 TASDEVICE_REG(0, 0x17, 0x74),
61 TASDEVICE_REG(0, 0x18, 0x0c),
62 TASDEVICE_REG(0, 0x18, 0x14),
63 TASDEVICE_REG(0, 0x13, 0x70),
64 TASDEVICE_REG(0, 0x18, 0x7c),
65 };
66 unsigned int crc, oft, node_num;
67 unsigned char *buf;
68 int i, j, k, l;
69
70 if (tmp_val[0] == 2781) {
71 /*
72 * New features were added in calibrated Data V3:
73 * 1. Added calibration registers address define in
74 * a node, marked as Device id == 0x80.
75 * New features were added in calibrated Data V2:
76 * 1. Added some the fields to store the link_id and
77 * uniqie_id for multi-link solutions
78 * 2. Support flexible number of devices instead of
79 * fixed one in V1.
80 * Layout of calibrated data V2 in UEFI(total 256 bytes):
81 * ChipID (2781, 4 bytes)
82 * Data-Group-Sum (4 bytes)
83 * TimeStamp of Calibration (4 bytes)
84 * for (i = 0; i < Data-Group-Sum; i++) {
85 * if (Data type != 0x80) (4 bytes)
86 * Calibrated Data of Device #i (20 bytes)
87 * else
88 * Calibration registers address (5*4 = 20 bytes)
89 * # V2: No reg addr in data grp section.
90 * # V3: Normally the last grp is the reg addr.
91 * }
92 * CRC (4 bytes)
93 * Reserved (the rest)
94 */
95 crc = crc32(crc: ~0, p: data, len: (3 + tmp_val[1] * 6) * 4) ^ ~0;
96
97 if (crc != tmp_val[3 + tmp_val[1] * 6]) {
98 cali_data->total_sz = 0;
99 dev_err(p->dev, "%s: CRC error\n", __func__);
100 return;
101 }
102 node_num = tmp_val[1];
103
104 for (j = 0, k = 0; j < node_num; j++) {
105 oft = j * 6 + 3;
106 if (tmp_val[oft] == TASDEV_UEFI_CALI_REG_ADDR_FLG) {
107 for (i = 0; i < TASDEV_CALIB_N; i++) {
108 buf = &data[(oft + i + 1) * 4];
109 cali_reg[i] = TASDEVICE_REG(buf[1],
110 buf[2], buf[3]);
111 }
112 } else {
113 l = j * (cali_data->cali_dat_sz_per_dev + 1);
114 if (k >= p->ndev || l > oft * 4) {
115 dev_err(p->dev, "%s: dev sum error\n",
116 __func__);
117 cali_data->total_sz = 0;
118 return;
119 }
120
121 data[l] = k;
122 oft++;
123 cali_cnv(data, base: 4 * oft, offset: l);
124 k++;
125 }
126 }
127 } else {
128 /*
129 * Calibration data is in V1 format.
130 * struct cali_data {
131 * char cali_data[20];
132 * }
133 *
134 * struct {
135 * struct cali_data cali_data[4];
136 * int TimeStamp of Calibration (4 bytes)
137 * int CRC (4 bytes)
138 * } ueft;
139 */
140 crc = crc32(crc: ~0, p: data, len: 84) ^ ~0;
141 if (crc != tmp_val[21]) {
142 cali_data->total_sz = 0;
143 dev_err(p->dev, "%s: V1 CRC error\n", __func__);
144 return;
145 }
146
147 for (j = p->ndev - 1; j >= 0; j--) {
148 l = j * (cali_data->cali_dat_sz_per_dev + 1);
149 cali_cnv(data, base: cali_data->cali_dat_sz_per_dev * j, offset: l);
150 data[l] = j;
151 }
152 }
153
154 if (p->dspbin_typ == TASDEV_BASIC) {
155 r->r0_reg = cali_reg[0];
156 r->invr0_reg = cali_reg[1];
157 r->r0_low_reg = cali_reg[2];
158 r->pow_reg = cali_reg[3];
159 r->tlimit_reg = cali_reg[4];
160 }
161
162 p->is_user_space_calidata = true;
163 cali_data->total_sz = p->ndev * (cali_data->cali_dat_sz_per_dev + 1);
164}
165
166/*
167 * Update the calibration data, including speaker impedance, f0, etc,
168 * into algo. Calibrate data is done by manufacturer in the factory.
169 * The data is used by Algo for calculating the speaker temperature,
170 * speaker membrane excursion and f0 in real time during playback.
171 * Calibration data format in EFI is V2, since 2024.
172 */
173int tas2781_save_calibration(struct tas2781_hda *hda)
174{
175 /*
176 * GUID was used for data access in BIOS, it was provided by board
177 * manufactory.
178 */
179 efi_guid_t efi_guid = tasdev_fct_efi_guid[LENOVO];
180 /*
181 * Some devices save the calibrated data into L"CALI_DATA",
182 * and others into L"SmartAmpCalibrationData".
183 */
184 static efi_char16_t *efi_name[CALIBRATION_DATA_AREA_NUM] = {
185 L"CALI_DATA",
186 L"SmartAmpCalibrationData",
187 };
188 struct tasdevice_priv *p = hda->priv;
189 struct calidata *cali_data = &p->cali_data;
190 unsigned long total_sz = 0;
191 unsigned int attr, size;
192 unsigned char *data;
193 efi_status_t status;
194 int i;
195
196 if (!efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE)) {
197 dev_err(p->dev, "%s: NO EFI FOUND!\n", __func__);
198 return -EINVAL;
199 }
200
201 if (hda->catlog_id < LENOVO)
202 efi_guid = tasdev_fct_efi_guid[hda->catlog_id];
203
204 cali_data->cali_dat_sz_per_dev = 20;
205 size = p->ndev * (cali_data->cali_dat_sz_per_dev + 1);
206 for (i = 0; i < CALIBRATION_DATA_AREA_NUM; i++) {
207 /* Get real size of UEFI variable */
208 status = efi.get_variable(efi_name[i], &efi_guid, &attr,
209 &total_sz, NULL);
210 cali_data->total_sz = total_sz > size ? total_sz : size;
211 if (status == EFI_BUFFER_TOO_SMALL) {
212 /* Allocate data buffer of data_size bytes */
213 data = cali_data->data = devm_kzalloc(dev: p->dev,
214 size: cali_data->total_sz, GFP_KERNEL);
215 if (!data) {
216 status = -ENOMEM;
217 continue;
218 }
219 /* Get variable contents into buffer */
220 status = efi.get_variable(efi_name[i], &efi_guid,
221 &attr, &cali_data->total_sz, data);
222 }
223 /* Check whether get the calibrated data */
224 if (status == EFI_SUCCESS)
225 break;
226 }
227
228 if (status != EFI_SUCCESS) {
229 cali_data->total_sz = 0;
230 return status;
231 }
232
233 tas2781_apply_calib(p);
234
235 return 0;
236}
237EXPORT_SYMBOL_NS_GPL(tas2781_save_calibration, "SND_HDA_SCODEC_TAS2781");
238
239void tas2781_hda_remove(struct device *dev,
240 const struct component_ops *ops)
241{
242 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
243
244 component_del(tas_hda->dev, ops);
245
246 pm_runtime_get_sync(dev: tas_hda->dev);
247 pm_runtime_disable(dev: tas_hda->dev);
248
249 pm_runtime_put_noidle(dev: tas_hda->dev);
250
251 tasdevice_remove(tas_priv: tas_hda->priv);
252}
253EXPORT_SYMBOL_NS_GPL(tas2781_hda_remove, "SND_HDA_SCODEC_TAS2781");
254
255int tasdevice_info_profile(struct snd_kcontrol *kcontrol,
256 struct snd_ctl_elem_info *uinfo)
257{
258 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
259
260 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
261 uinfo->count = 1;
262 uinfo->value.integer.min = 0;
263 uinfo->value.integer.max = tas_priv->rcabin.ncfgs - 1;
264
265 return 0;
266}
267EXPORT_SYMBOL_NS_GPL(tasdevice_info_profile, "SND_HDA_SCODEC_TAS2781");
268
269int tasdevice_info_programs(struct snd_kcontrol *kcontrol,
270 struct snd_ctl_elem_info *uinfo)
271{
272 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
273
274 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
275 uinfo->count = 1;
276 uinfo->value.integer.min = 0;
277 uinfo->value.integer.max = tas_priv->fmw->nr_programs - 1;
278
279 return 0;
280}
281EXPORT_SYMBOL_NS_GPL(tasdevice_info_programs, "SND_HDA_SCODEC_TAS2781");
282
283int tasdevice_info_config(struct snd_kcontrol *kcontrol,
284 struct snd_ctl_elem_info *uinfo)
285{
286 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
287 struct tasdevice_fw *tas_fw = tas_priv->fmw;
288
289 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
290 uinfo->count = 1;
291 uinfo->value.integer.min = 0;
292 uinfo->value.integer.max = tas_fw->nr_configurations - 1;
293
294 return 0;
295}
296EXPORT_SYMBOL_NS_GPL(tasdevice_info_config, "SND_HDA_SCODEC_TAS2781");
297
298int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol,
299 struct snd_ctl_elem_value *ucontrol)
300{
301 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
302
303 ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
304
305 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n", __func__,
306 kcontrol->id.name, tas_priv->rcabin.profile_cfg_id);
307
308 return 0;
309}
310EXPORT_SYMBOL_NS_GPL(tasdevice_get_profile_id, "SND_HDA_SCODEC_TAS2781");
311
312int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol,
313 struct snd_ctl_elem_value *ucontrol)
314{
315 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
316 int profile_id = ucontrol->value.integer.value[0];
317 int max = tas_priv->rcabin.ncfgs - 1;
318 int val, ret = 0;
319
320 val = clamp(profile_id, 0, max);
321
322 guard(mutex)(T: &tas_priv->codec_lock);
323
324 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n", __func__,
325 kcontrol->id.name, tas_priv->rcabin.profile_cfg_id, val);
326
327 if (tas_priv->rcabin.profile_cfg_id != val) {
328 tas_priv->rcabin.profile_cfg_id = val;
329 ret = 1;
330 }
331
332 return ret;
333}
334EXPORT_SYMBOL_NS_GPL(tasdevice_set_profile_id, "SND_HDA_SCODEC_TAS2781");
335
336int tasdevice_program_get(struct snd_kcontrol *kcontrol,
337 struct snd_ctl_elem_value *ucontrol)
338{
339 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
340
341 ucontrol->value.integer.value[0] = tas_priv->cur_prog;
342
343 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n", __func__,
344 kcontrol->id.name, tas_priv->cur_prog);
345
346 return 0;
347}
348EXPORT_SYMBOL_NS_GPL(tasdevice_program_get, "SND_HDA_SCODEC_TAS2781");
349
350int tasdevice_program_put(struct snd_kcontrol *kcontrol,
351 struct snd_ctl_elem_value *ucontrol)
352{
353 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
354 struct tasdevice_fw *tas_fw = tas_priv->fmw;
355 int nr_program = ucontrol->value.integer.value[0];
356 int max = tas_fw->nr_programs - 1;
357 int val, ret = 0;
358
359 val = clamp(nr_program, 0, max);
360
361 guard(mutex)(T: &tas_priv->codec_lock);
362
363 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n", __func__,
364 kcontrol->id.name, tas_priv->cur_prog, val);
365
366 if (tas_priv->cur_prog != val) {
367 tas_priv->cur_prog = val;
368 ret = 1;
369 }
370
371 return ret;
372}
373EXPORT_SYMBOL_NS_GPL(tasdevice_program_put, "SND_HDA_SCODEC_TAS2781");
374
375int tasdevice_config_get(struct snd_kcontrol *kcontrol,
376 struct snd_ctl_elem_value *ucontrol)
377{
378 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
379
380 ucontrol->value.integer.value[0] = tas_priv->cur_conf;
381
382 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n", __func__,
383 kcontrol->id.name, tas_priv->cur_conf);
384
385 return 0;
386}
387EXPORT_SYMBOL_NS_GPL(tasdevice_config_get, "SND_HDA_SCODEC_TAS2781");
388
389int tasdevice_config_put(struct snd_kcontrol *kcontrol,
390 struct snd_ctl_elem_value *ucontrol)
391{
392 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
393 struct tasdevice_fw *tas_fw = tas_priv->fmw;
394 int nr_config = ucontrol->value.integer.value[0];
395 int max = tas_fw->nr_configurations - 1;
396 int val, ret = 0;
397
398 val = clamp(nr_config, 0, max);
399
400 guard(mutex)(T: &tas_priv->codec_lock);
401
402 dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n", __func__,
403 kcontrol->id.name, tas_priv->cur_conf, val);
404
405 if (tas_priv->cur_conf != val) {
406 tas_priv->cur_conf = val;
407 ret = 1;
408 }
409
410 return ret;
411}
412EXPORT_SYMBOL_NS_GPL(tasdevice_config_put, "SND_HDA_SCODEC_TAS2781");
413
414MODULE_DESCRIPTION("TAS2781 HDA Driver");
415MODULE_LICENSE("GPL");
416MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
417

source code of linux/sound/hda/codecs/side-codecs/tas2781_hda.c