1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // TAS2781 HDA I2C driver
4 //
5 // Copyright 2023 Texas Instruments, Inc.
6 //
7 // Author: Shenghao Ding <shenghao-ding@ti.com>
8
9 #include <linux/acpi.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/mod_devicetable.h>
16 #include <linux/module.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/regmap.h>
19 #include <sound/hda_codec.h>
20 #include <sound/soc.h>
21 #include <sound/tas2781.h>
22 #include <sound/tlv.h>
23 #include <sound/tas2781-tlv.h>
24
25 #include "hda_local.h"
26 #include "hda_auto_parser.h"
27 #include "hda_component.h"
28 #include "hda_jack.h"
29 #include "hda_generic.h"
30
31 #define TASDEVICE_SPEAKER_CALIBRATION_SIZE 20
32
33 /* No standard control callbacks for SNDRV_CTL_ELEM_IFACE_CARD
34 * Define two controls, one is Volume control callbacks, the other is
35 * flag setting control callbacks.
36 */
37
38 /* Volume control callbacks for tas2781 */
39 #define ACARD_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
40 xhandler_get, xhandler_put, tlv_array) \
41 { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = (xname),\
42 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
43 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
44 .tlv.p = (tlv_array), \
45 .info = snd_soc_info_volsw_range, \
46 .get = xhandler_get, .put = xhandler_put, \
47 .private_value = (unsigned long)&(struct soc_mixer_control) \
48 {.reg = xreg, .rreg = xreg, .shift = xshift, \
49 .rshift = xshift, .min = xmin, .max = xmax, \
50 .invert = xinvert} }
51
52 /* Flag control callbacks for tas2781 */
53 #define ACARD_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
54 { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = xname, \
55 .info = snd_ctl_boolean_mono_info, \
56 .get = xhandler_get, .put = xhandler_put, \
57 .private_value = xdata }
58
59 enum calib_data {
60 R0_VAL = 0,
61 INV_R0,
62 R0LOW,
63 POWER,
64 TLIM,
65 CALIB_MAX
66 };
67
68 struct tas2781_hda {
69 struct device *dev;
70 struct tasdevice_priv *priv;
71 struct snd_kcontrol *dsp_prog_ctl;
72 struct snd_kcontrol *dsp_conf_ctl;
73 struct snd_kcontrol *prof_ctl;
74 struct snd_kcontrol *snd_ctls[3];
75 };
76
tas2781_get_i2c_res(struct acpi_resource * ares,void * data)77 static int tas2781_get_i2c_res(struct acpi_resource *ares, void *data)
78 {
79 struct tasdevice_priv *tas_priv = data;
80 struct acpi_resource_i2c_serialbus *sb;
81
82 if (i2c_acpi_get_i2c_resource(ares, &sb)) {
83 if (tas_priv->ndev < TASDEVICE_MAX_CHANNELS &&
84 sb->slave_address != TAS2781_GLOBAL_ADDR) {
85 tas_priv->tasdevice[tas_priv->ndev].dev_addr =
86 (unsigned int)sb->slave_address;
87 tas_priv->ndev++;
88 }
89 }
90 return 1;
91 }
92
tas2781_read_acpi(struct tasdevice_priv * p,const char * hid)93 static int tas2781_read_acpi(struct tasdevice_priv *p, const char *hid)
94 {
95 struct acpi_device *adev;
96 struct device *physdev;
97 LIST_HEAD(resources);
98 const char *sub;
99 int ret;
100
101 adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
102 if (!adev) {
103 dev_err(p->dev,
104 "Failed to find an ACPI device for %s\n", hid);
105 return -ENODEV;
106 }
107
108 ret = acpi_dev_get_resources(adev, &resources, tas2781_get_i2c_res, p);
109 if (ret < 0)
110 goto err;
111
112 acpi_dev_free_resource_list(&resources);
113 strscpy(p->dev_name, hid, sizeof(p->dev_name));
114 physdev = get_device(acpi_get_first_physical_node(adev));
115 acpi_dev_put(adev);
116
117 /* No side-effect to the playback even if subsystem_id is NULL*/
118 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
119 if (IS_ERR(sub))
120 sub = NULL;
121
122 p->acpi_subsystem_id = sub;
123
124 put_device(physdev);
125
126 return 0;
127
128 err:
129 dev_err(p->dev, "read acpi error, ret: %d\n", ret);
130 acpi_dev_put(adev);
131
132 return ret;
133 }
134
tas2781_hda_playback_hook(struct device * dev,int action)135 static void tas2781_hda_playback_hook(struct device *dev, int action)
136 {
137 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
138
139 dev_dbg(tas_hda->dev, "%s: action = %d\n", __func__, action);
140 switch (action) {
141 case HDA_GEN_PCM_ACT_OPEN:
142 pm_runtime_get_sync(dev);
143 mutex_lock(&tas_hda->priv->codec_lock);
144 tasdevice_tuning_switch(tas_hda->priv, 0);
145 mutex_unlock(&tas_hda->priv->codec_lock);
146 break;
147 case HDA_GEN_PCM_ACT_CLOSE:
148 mutex_lock(&tas_hda->priv->codec_lock);
149 tasdevice_tuning_switch(tas_hda->priv, 1);
150 mutex_unlock(&tas_hda->priv->codec_lock);
151
152 pm_runtime_mark_last_busy(dev);
153 pm_runtime_put_autosuspend(dev);
154 break;
155 default:
156 dev_dbg(tas_hda->dev, "Playback action not supported: %d\n",
157 action);
158 break;
159 }
160 }
161
tasdevice_info_profile(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)162 static int tasdevice_info_profile(struct snd_kcontrol *kcontrol,
163 struct snd_ctl_elem_info *uinfo)
164 {
165 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
166
167 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
168 uinfo->count = 1;
169 uinfo->value.integer.min = 0;
170 uinfo->value.integer.max = tas_priv->rcabin.ncfgs - 1;
171
172 return 0;
173 }
174
tasdevice_get_profile_id(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)175 static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol,
176 struct snd_ctl_elem_value *ucontrol)
177 {
178 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
179
180 ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
181
182 return 0;
183 }
184
tasdevice_set_profile_id(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)185 static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol,
186 struct snd_ctl_elem_value *ucontrol)
187 {
188 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
189 int nr_profile = ucontrol->value.integer.value[0];
190 int max = tas_priv->rcabin.ncfgs - 1;
191 int val, ret = 0;
192
193 val = clamp(nr_profile, 0, max);
194
195 if (tas_priv->rcabin.profile_cfg_id != val) {
196 tas_priv->rcabin.profile_cfg_id = val;
197 ret = 1;
198 }
199
200 return ret;
201 }
202
tasdevice_info_programs(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)203 static int tasdevice_info_programs(struct snd_kcontrol *kcontrol,
204 struct snd_ctl_elem_info *uinfo)
205 {
206 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
207 struct tasdevice_fw *tas_fw = tas_priv->fmw;
208
209 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
210 uinfo->count = 1;
211 uinfo->value.integer.min = 0;
212 uinfo->value.integer.max = tas_fw->nr_programs - 1;
213
214 return 0;
215 }
216
tasdevice_info_config(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)217 static int tasdevice_info_config(struct snd_kcontrol *kcontrol,
218 struct snd_ctl_elem_info *uinfo)
219 {
220 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
221 struct tasdevice_fw *tas_fw = tas_priv->fmw;
222
223 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
224 uinfo->count = 1;
225 uinfo->value.integer.min = 0;
226 uinfo->value.integer.max = tas_fw->nr_configurations - 1;
227
228 return 0;
229 }
230
tasdevice_program_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)231 static int tasdevice_program_get(struct snd_kcontrol *kcontrol,
232 struct snd_ctl_elem_value *ucontrol)
233 {
234 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
235
236 ucontrol->value.integer.value[0] = tas_priv->cur_prog;
237
238 return 0;
239 }
240
tasdevice_program_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)241 static int tasdevice_program_put(struct snd_kcontrol *kcontrol,
242 struct snd_ctl_elem_value *ucontrol)
243 {
244 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
245 struct tasdevice_fw *tas_fw = tas_priv->fmw;
246 int nr_program = ucontrol->value.integer.value[0];
247 int max = tas_fw->nr_programs - 1;
248 int val, ret = 0;
249
250 val = clamp(nr_program, 0, max);
251
252 if (tas_priv->cur_prog != val) {
253 tas_priv->cur_prog = val;
254 ret = 1;
255 }
256
257 return ret;
258 }
259
tasdevice_config_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)260 static int tasdevice_config_get(struct snd_kcontrol *kcontrol,
261 struct snd_ctl_elem_value *ucontrol)
262 {
263 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
264
265 ucontrol->value.integer.value[0] = tas_priv->cur_conf;
266
267 return 0;
268 }
269
tasdevice_config_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)270 static int tasdevice_config_put(struct snd_kcontrol *kcontrol,
271 struct snd_ctl_elem_value *ucontrol)
272 {
273 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
274 struct tasdevice_fw *tas_fw = tas_priv->fmw;
275 int nr_config = ucontrol->value.integer.value[0];
276 int max = tas_fw->nr_configurations - 1;
277 int val, ret = 0;
278
279 val = clamp(nr_config, 0, max);
280
281 if (tas_priv->cur_conf != val) {
282 tas_priv->cur_conf = val;
283 ret = 1;
284 }
285
286 return ret;
287 }
288
289 /*
290 * tas2781_digital_getvol - get the volum control
291 * @kcontrol: control pointer
292 * @ucontrol: User data
293 * Customer Kcontrol for tas2781 is primarily for regmap booking, paging
294 * depends on internal regmap mechanism.
295 * tas2781 contains book and page two-level register map, especially
296 * book switching will set the register BXXP00R7F, after switching to the
297 * correct book, then leverage the mechanism for paging to access the
298 * register.
299 */
tas2781_digital_getvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)300 static int tas2781_digital_getvol(struct snd_kcontrol *kcontrol,
301 struct snd_ctl_elem_value *ucontrol)
302 {
303 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
304 struct soc_mixer_control *mc =
305 (struct soc_mixer_control *)kcontrol->private_value;
306
307 return tasdevice_digital_getvol(tas_priv, ucontrol, mc);
308 }
309
tas2781_amp_getvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)310 static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,
311 struct snd_ctl_elem_value *ucontrol)
312 {
313 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
314 struct soc_mixer_control *mc =
315 (struct soc_mixer_control *)kcontrol->private_value;
316
317 return tasdevice_amp_getvol(tas_priv, ucontrol, mc);
318 }
319
tas2781_digital_putvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)320 static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol,
321 struct snd_ctl_elem_value *ucontrol)
322 {
323 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
324 struct soc_mixer_control *mc =
325 (struct soc_mixer_control *)kcontrol->private_value;
326
327 /* The check of the given value is in tasdevice_digital_putvol. */
328 return tasdevice_digital_putvol(tas_priv, ucontrol, mc);
329 }
330
tas2781_amp_putvol(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)331 static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,
332 struct snd_ctl_elem_value *ucontrol)
333 {
334 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
335 struct soc_mixer_control *mc =
336 (struct soc_mixer_control *)kcontrol->private_value;
337
338 /* The check of the given value is in tasdevice_amp_putvol. */
339 return tasdevice_amp_putvol(tas_priv, ucontrol, mc);
340 }
341
tas2781_force_fwload_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)342 static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,
343 struct snd_ctl_elem_value *ucontrol)
344 {
345 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
346
347 ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
348 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
349 tas_priv->force_fwload_status ? "ON" : "OFF");
350
351 return 0;
352 }
353
tas2781_force_fwload_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)354 static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol,
355 struct snd_ctl_elem_value *ucontrol)
356 {
357 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
358 bool change, val = (bool)ucontrol->value.integer.value[0];
359
360 if (tas_priv->force_fwload_status == val)
361 change = false;
362 else {
363 change = true;
364 tas_priv->force_fwload_status = val;
365 }
366 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
367 tas_priv->force_fwload_status ? "ON" : "OFF");
368
369 return change;
370 }
371
372 static const struct snd_kcontrol_new tas2781_snd_controls[] = {
373 ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,
374 1, 0, 20, 0, tas2781_amp_getvol,
375 tas2781_amp_putvol, amp_vol_tlv),
376 ACARD_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2781_DVC_LVL,
377 0, 0, 200, 1, tas2781_digital_getvol,
378 tas2781_digital_putvol, dvc_tlv),
379 ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,
380 tas2781_force_fwload_get, tas2781_force_fwload_put),
381 };
382
383 static const struct snd_kcontrol_new tas2781_prof_ctrl = {
384 .name = "Speaker Profile Id",
385 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
386 .info = tasdevice_info_profile,
387 .get = tasdevice_get_profile_id,
388 .put = tasdevice_set_profile_id,
389 };
390
391 static const struct snd_kcontrol_new tas2781_dsp_prog_ctrl = {
392 .name = "Speaker Program Id",
393 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
394 .info = tasdevice_info_programs,
395 .get = tasdevice_program_get,
396 .put = tasdevice_program_put,
397 };
398
399 static const struct snd_kcontrol_new tas2781_dsp_conf_ctrl = {
400 .name = "Speaker Config Id",
401 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
402 .info = tasdevice_info_config,
403 .get = tasdevice_config_get,
404 .put = tasdevice_config_put,
405 };
406
tas2781_apply_calib(struct tasdevice_priv * tas_priv)407 static void tas2781_apply_calib(struct tasdevice_priv *tas_priv)
408 {
409 static const unsigned char page_array[CALIB_MAX] = {
410 0x17, 0x18, 0x18, 0x0d, 0x18
411 };
412 static const unsigned char rgno_array[CALIB_MAX] = {
413 0x74, 0x0c, 0x14, 0x3c, 0x7c
414 };
415 unsigned char *data;
416 int i, j, rc;
417
418 for (i = 0; i < tas_priv->ndev; i++) {
419 data = tas_priv->cali_data.data +
420 i * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
421 for (j = 0; j < CALIB_MAX; j++) {
422 rc = tasdevice_dev_bulk_write(tas_priv, i,
423 TASDEVICE_REG(0, page_array[j], rgno_array[j]),
424 &(data[4 * j]), 4);
425 if (rc < 0)
426 dev_err(tas_priv->dev,
427 "chn %d calib %d bulk_wr err = %d\n",
428 i, j, rc);
429 }
430 }
431 }
432
433 /* Update the calibrate data, including speaker impedance, f0, etc, into algo.
434 * Calibrate data is done by manufacturer in the factory. These data are used
435 * by Algo for calucating the speaker temperature, speaker membrance excursion
436 * and f0 in real time during playback.
437 */
tas2781_save_calibration(struct tasdevice_priv * tas_priv)438 static int tas2781_save_calibration(struct tasdevice_priv *tas_priv)
439 {
440 efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d,
441 0x93, 0xfe, 0x5a, 0xa3, 0x5d, 0xb3);
442 static efi_char16_t efi_name[] = L"CALI_DATA";
443 struct tm *tm = &tas_priv->tm;
444 unsigned int attr, crc;
445 unsigned int *tmp_val;
446 efi_status_t status;
447
448 /* Lenovo devices */
449 if (tas_priv->catlog_id == LENOVO)
450 efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, 0x09,
451 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
452
453 tas_priv->cali_data.total_sz = 0;
454 /* Get real size of UEFI variable */
455 status = efi.get_variable(efi_name, &efi_guid, &attr,
456 &tas_priv->cali_data.total_sz, tas_priv->cali_data.data);
457 if (status == EFI_BUFFER_TOO_SMALL) {
458 /* Allocate data buffer of data_size bytes */
459 tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
460 tas_priv->cali_data.total_sz, GFP_KERNEL);
461 if (!tas_priv->cali_data.data)
462 return -ENOMEM;
463 /* Get variable contents into buffer */
464 status = efi.get_variable(efi_name, &efi_guid, &attr,
465 &tas_priv->cali_data.total_sz,
466 tas_priv->cali_data.data);
467 }
468 if (status != EFI_SUCCESS)
469 return -EINVAL;
470
471 tmp_val = (unsigned int *)tas_priv->cali_data.data;
472
473 crc = crc32(~0, tas_priv->cali_data.data, 84) ^ ~0;
474 dev_dbg(tas_priv->dev, "cali crc 0x%08x PK tmp_val 0x%08x\n",
475 crc, tmp_val[21]);
476
477 if (crc == tmp_val[21]) {
478 time64_to_tm(tmp_val[20], 0, tm);
479 dev_dbg(tas_priv->dev, "%4ld-%2d-%2d, %2d:%2d:%2d\n",
480 tm->tm_year, tm->tm_mon, tm->tm_mday,
481 tm->tm_hour, tm->tm_min, tm->tm_sec);
482 tas2781_apply_calib(tas_priv);
483 } else
484 tas_priv->cali_data.total_sz = 0;
485
486 return 0;
487 }
488
tas2781_hda_remove_controls(struct tas2781_hda * tas_hda)489 static void tas2781_hda_remove_controls(struct tas2781_hda *tas_hda)
490 {
491 struct hda_codec *codec = tas_hda->priv->codec;
492
493 if (tas_hda->dsp_prog_ctl)
494 snd_ctl_remove(codec->card, tas_hda->dsp_prog_ctl);
495
496 if (tas_hda->dsp_conf_ctl)
497 snd_ctl_remove(codec->card, tas_hda->dsp_conf_ctl);
498
499 for (int i = ARRAY_SIZE(tas_hda->snd_ctls) - 1; i >= 0; i--)
500 if (tas_hda->snd_ctls[i])
501 snd_ctl_remove(codec->card, tas_hda->snd_ctls[i]);
502
503 if (tas_hda->prof_ctl)
504 snd_ctl_remove(codec->card, tas_hda->prof_ctl);
505 }
506
tasdev_fw_ready(const struct firmware * fmw,void * context)507 static void tasdev_fw_ready(const struct firmware *fmw, void *context)
508 {
509 struct tasdevice_priv *tas_priv = context;
510 struct tas2781_hda *tas_hda = dev_get_drvdata(tas_priv->dev);
511 struct hda_codec *codec = tas_priv->codec;
512 int i, ret;
513
514 pm_runtime_get_sync(tas_priv->dev);
515 mutex_lock(&tas_priv->codec_lock);
516
517 ret = tasdevice_rca_parser(tas_priv, fmw);
518 if (ret)
519 goto out;
520
521 tas_hda->prof_ctl = snd_ctl_new1(&tas2781_prof_ctrl, tas_priv);
522 ret = snd_ctl_add(codec->card, tas_hda->prof_ctl);
523 if (ret) {
524 dev_err(tas_priv->dev,
525 "Failed to add KControl %s = %d\n",
526 tas2781_prof_ctrl.name, ret);
527 goto out;
528 }
529
530 for (i = 0; i < ARRAY_SIZE(tas2781_snd_controls); i++) {
531 tas_hda->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_controls[i],
532 tas_priv);
533 ret = snd_ctl_add(codec->card, tas_hda->snd_ctls[i]);
534 if (ret) {
535 dev_err(tas_priv->dev,
536 "Failed to add KControl %s = %d\n",
537 tas2781_snd_controls[i].name, ret);
538 goto out;
539 }
540 }
541
542 tasdevice_dsp_remove(tas_priv);
543
544 tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
545 scnprintf(tas_priv->coef_binaryname, 64, "TAS2XXX%04X.bin",
546 codec->core.subsystem_id & 0xffff);
547 ret = tasdevice_dsp_parser(tas_priv);
548 if (ret) {
549 dev_err(tas_priv->dev, "dspfw load %s error\n",
550 tas_priv->coef_binaryname);
551 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
552 goto out;
553 }
554
555 tas_hda->dsp_prog_ctl = snd_ctl_new1(&tas2781_dsp_prog_ctrl,
556 tas_priv);
557 ret = snd_ctl_add(codec->card, tas_hda->dsp_prog_ctl);
558 if (ret) {
559 dev_err(tas_priv->dev,
560 "Failed to add KControl %s = %d\n",
561 tas2781_dsp_prog_ctrl.name, ret);
562 goto out;
563 }
564
565 tas_hda->dsp_conf_ctl = snd_ctl_new1(&tas2781_dsp_conf_ctrl,
566 tas_priv);
567 ret = snd_ctl_add(codec->card, tas_hda->dsp_conf_ctl);
568 if (ret) {
569 dev_err(tas_priv->dev,
570 "Failed to add KControl %s = %d\n",
571 tas2781_dsp_conf_ctrl.name, ret);
572 goto out;
573 }
574
575 tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
576 tasdevice_prmg_load(tas_priv, 0);
577 if (tas_priv->fmw->nr_programs > 0)
578 tas_priv->cur_prog = 0;
579 if (tas_priv->fmw->nr_configurations > 0)
580 tas_priv->cur_conf = 0;
581
582 /* If calibrated data occurs error, dsp will still works with default
583 * calibrated data inside algo.
584 */
585 tas2781_save_calibration(tas_priv);
586
587 out:
588 mutex_unlock(&tas_hda->priv->codec_lock);
589 if (fmw)
590 release_firmware(fmw);
591 pm_runtime_mark_last_busy(tas_hda->dev);
592 pm_runtime_put_autosuspend(tas_hda->dev);
593 }
594
tas2781_hda_bind(struct device * dev,struct device * master,void * master_data)595 static int tas2781_hda_bind(struct device *dev, struct device *master,
596 void *master_data)
597 {
598 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
599 struct hda_component *comps = master_data;
600 struct hda_codec *codec;
601 unsigned int subid;
602 int ret;
603
604 if (!comps || tas_hda->priv->index < 0 ||
605 tas_hda->priv->index >= HDA_MAX_COMPONENTS)
606 return -EINVAL;
607
608 comps = &comps[tas_hda->priv->index];
609 if (comps->dev)
610 return -EBUSY;
611
612 codec = comps->codec;
613 subid = codec->core.subsystem_id >> 16;
614
615 switch (subid) {
616 case 0x17aa:
617 tas_hda->priv->catlog_id = LENOVO;
618 break;
619 default:
620 tas_hda->priv->catlog_id = OTHERS;
621 break;
622 }
623
624 pm_runtime_get_sync(dev);
625
626 comps->dev = dev;
627
628 strscpy(comps->name, dev_name(dev), sizeof(comps->name));
629
630 ret = tascodec_init(tas_hda->priv, codec, THIS_MODULE, tasdev_fw_ready);
631 if (!ret)
632 comps->playback_hook = tas2781_hda_playback_hook;
633
634 pm_runtime_mark_last_busy(dev);
635 pm_runtime_put_autosuspend(dev);
636
637 return ret;
638 }
639
tas2781_hda_unbind(struct device * dev,struct device * master,void * master_data)640 static void tas2781_hda_unbind(struct device *dev,
641 struct device *master, void *master_data)
642 {
643 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
644 struct hda_component *comps = master_data;
645 comps = &comps[tas_hda->priv->index];
646
647 if (comps->dev == dev) {
648 comps->dev = NULL;
649 memset(comps->name, 0, sizeof(comps->name));
650 comps->playback_hook = NULL;
651 }
652
653 tas2781_hda_remove_controls(tas_hda);
654
655 tasdevice_config_info_remove(tas_hda->priv);
656 tasdevice_dsp_remove(tas_hda->priv);
657
658 tas_hda->priv->fw_state = TASDEVICE_DSP_FW_PENDING;
659 }
660
661 static const struct component_ops tas2781_hda_comp_ops = {
662 .bind = tas2781_hda_bind,
663 .unbind = tas2781_hda_unbind,
664 };
665
tas2781_hda_remove(struct device * dev)666 static void tas2781_hda_remove(struct device *dev)
667 {
668 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
669
670 pm_runtime_get_sync(tas_hda->dev);
671 pm_runtime_disable(tas_hda->dev);
672
673 component_del(tas_hda->dev, &tas2781_hda_comp_ops);
674
675 pm_runtime_put_noidle(tas_hda->dev);
676
677 tasdevice_remove(tas_hda->priv);
678 }
679
tas2781_hda_i2c_probe(struct i2c_client * clt)680 static int tas2781_hda_i2c_probe(struct i2c_client *clt)
681 {
682 struct tas2781_hda *tas_hda;
683 const char *device_name;
684 int ret;
685
686 if (strstr(dev_name(&clt->dev), "TIAS2781"))
687 device_name = "TIAS2781";
688 else
689 return -ENODEV;
690
691 tas_hda = devm_kzalloc(&clt->dev, sizeof(*tas_hda), GFP_KERNEL);
692 if (!tas_hda)
693 return -ENOMEM;
694
695 dev_set_drvdata(&clt->dev, tas_hda);
696 tas_hda->dev = &clt->dev;
697
698 tas_hda->priv = tasdevice_kzalloc(clt);
699 if (!tas_hda->priv)
700 return -ENOMEM;
701
702 tas_hda->priv->irq_info.irq = clt->irq;
703 ret = tas2781_read_acpi(tas_hda->priv, device_name);
704 if (ret)
705 return dev_err_probe(tas_hda->dev, ret,
706 "Platform not supported\n");
707
708 ret = tasdevice_init(tas_hda->priv);
709 if (ret)
710 goto err;
711
712 pm_runtime_set_autosuspend_delay(tas_hda->dev, 3000);
713 pm_runtime_use_autosuspend(tas_hda->dev);
714 pm_runtime_mark_last_busy(tas_hda->dev);
715 pm_runtime_set_active(tas_hda->dev);
716 pm_runtime_get_noresume(tas_hda->dev);
717 pm_runtime_enable(tas_hda->dev);
718
719 pm_runtime_put_autosuspend(tas_hda->dev);
720
721 tas2781_reset(tas_hda->priv);
722
723 ret = component_add(tas_hda->dev, &tas2781_hda_comp_ops);
724 if (ret) {
725 dev_err(tas_hda->dev, "Register component failed: %d\n", ret);
726 pm_runtime_disable(tas_hda->dev);
727 }
728
729 err:
730 if (ret)
731 tas2781_hda_remove(&clt->dev);
732 return ret;
733 }
734
tas2781_hda_i2c_remove(struct i2c_client * clt)735 static void tas2781_hda_i2c_remove(struct i2c_client *clt)
736 {
737 tas2781_hda_remove(&clt->dev);
738 }
739
tas2781_runtime_suspend(struct device * dev)740 static int tas2781_runtime_suspend(struct device *dev)
741 {
742 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
743 int i;
744
745 dev_dbg(tas_hda->dev, "Runtime Suspend\n");
746
747 mutex_lock(&tas_hda->priv->codec_lock);
748
749 if (tas_hda->priv->playback_started) {
750 tasdevice_tuning_switch(tas_hda->priv, 1);
751 tas_hda->priv->playback_started = false;
752 }
753
754 for (i = 0; i < tas_hda->priv->ndev; i++) {
755 tas_hda->priv->tasdevice[i].cur_book = -1;
756 tas_hda->priv->tasdevice[i].cur_prog = -1;
757 tas_hda->priv->tasdevice[i].cur_conf = -1;
758 }
759
760 mutex_unlock(&tas_hda->priv->codec_lock);
761
762 return 0;
763 }
764
tas2781_runtime_resume(struct device * dev)765 static int tas2781_runtime_resume(struct device *dev)
766 {
767 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
768 unsigned long calib_data_sz =
769 tas_hda->priv->ndev * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
770
771 dev_dbg(tas_hda->dev, "Runtime Resume\n");
772
773 mutex_lock(&tas_hda->priv->codec_lock);
774
775 tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
776
777 /* If calibrated data occurs error, dsp will still works with default
778 * calibrated data inside algo.
779 */
780 if (tas_hda->priv->cali_data.total_sz > calib_data_sz)
781 tas2781_apply_calib(tas_hda->priv);
782
783 mutex_unlock(&tas_hda->priv->codec_lock);
784
785 return 0;
786 }
787
tas2781_system_suspend(struct device * dev)788 static int tas2781_system_suspend(struct device *dev)
789 {
790 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
791 int ret;
792
793 dev_dbg(tas_hda->priv->dev, "System Suspend\n");
794
795 ret = pm_runtime_force_suspend(dev);
796 if (ret)
797 return ret;
798
799 /* Shutdown chip before system suspend */
800 tasdevice_tuning_switch(tas_hda->priv, 1);
801
802 /*
803 * Reset GPIO may be shared, so cannot reset here.
804 * However beyond this point, amps may be powered down.
805 */
806 return 0;
807 }
808
tas2781_system_resume(struct device * dev)809 static int tas2781_system_resume(struct device *dev)
810 {
811 struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
812 unsigned long calib_data_sz =
813 tas_hda->priv->ndev * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
814 int i, ret;
815
816 dev_info(tas_hda->priv->dev, "System Resume\n");
817
818 ret = pm_runtime_force_resume(dev);
819 if (ret)
820 return ret;
821
822 mutex_lock(&tas_hda->priv->codec_lock);
823
824 for (i = 0; i < tas_hda->priv->ndev; i++) {
825 tas_hda->priv->tasdevice[i].cur_book = -1;
826 tas_hda->priv->tasdevice[i].cur_prog = -1;
827 tas_hda->priv->tasdevice[i].cur_conf = -1;
828 }
829 tas2781_reset(tas_hda->priv);
830 tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
831
832 /* If calibrated data occurs error, dsp will still work with default
833 * calibrated data inside algo.
834 */
835 if (tas_hda->priv->cali_data.total_sz > calib_data_sz)
836 tas2781_apply_calib(tas_hda->priv);
837 mutex_unlock(&tas_hda->priv->codec_lock);
838
839 return 0;
840 }
841
842 static const struct dev_pm_ops tas2781_hda_pm_ops = {
843 RUNTIME_PM_OPS(tas2781_runtime_suspend, tas2781_runtime_resume, NULL)
844 SYSTEM_SLEEP_PM_OPS(tas2781_system_suspend, tas2781_system_resume)
845 };
846
847 static const struct i2c_device_id tas2781_hda_i2c_id[] = {
848 { "tas2781-hda", 0 },
849 {}
850 };
851
852 static const struct acpi_device_id tas2781_acpi_hda_match[] = {
853 {"TIAS2781", 0 },
854 {}
855 };
856 MODULE_DEVICE_TABLE(acpi, tas2781_acpi_hda_match);
857
858 static struct i2c_driver tas2781_hda_i2c_driver = {
859 .driver = {
860 .name = "tas2781-hda",
861 .acpi_match_table = tas2781_acpi_hda_match,
862 .pm = &tas2781_hda_pm_ops,
863 },
864 .id_table = tas2781_hda_i2c_id,
865 .probe = tas2781_hda_i2c_probe,
866 .remove = tas2781_hda_i2c_remove,
867 };
868 module_i2c_driver(tas2781_hda_i2c_driver);
869
870 MODULE_DESCRIPTION("TAS2781 HDA Driver");
871 MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
872 MODULE_LICENSE("GPL");
873 MODULE_IMPORT_NS(SND_SOC_TAS2781_FMWLIB);
874