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