1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // HDA audio driver for Cirrus Logic CS35L56 smart amp 4 // 5 // Copyright (C) 2023 Cirrus Logic, Inc. and 6 // Cirrus Logic International Semiconductor Ltd. 7 // 8 9 #include <linux/acpi.h> 10 #include <linux/debugfs.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/regmap.h> 15 #include <linux/slab.h> 16 #include <sound/core.h> 17 #include <sound/cs-amp-lib.h> 18 #include <sound/hda_codec.h> 19 #include <sound/tlv.h> 20 #include "cirrus_scodec.h" 21 #include "cs35l56_hda.h" 22 #include "hda_component.h" 23 #include "hda_generic.h" 24 25 /* 26 * The cs35l56_hda_dai_config[] reg sequence configures the device as 27 * ASP1_BCLK_FREQ = 3.072 MHz 28 * ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S 29 * ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots 30 * ASP1_RX_WL = 24 bits per sample 31 * ASP1_TX_WL = 24 bits per sample 32 * ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled 33 * 34 * Override any Windows-specific mixer settings applied by the firmware. 35 */ 36 static const struct reg_sequence cs35l56_hda_dai_config[] = { 37 { CS35L56_ASP1_CONTROL1, 0x00000021 }, 38 { CS35L56_ASP1_CONTROL2, 0x20200200 }, 39 { CS35L56_ASP1_CONTROL3, 0x00000003 }, 40 { CS35L56_ASP1_FRAME_CONTROL1, 0x03020100 }, 41 { CS35L56_ASP1_FRAME_CONTROL5, 0x00020100 }, 42 { CS35L56_ASP1_DATA_CONTROL5, 0x00000018 }, 43 { CS35L56_ASP1_DATA_CONTROL1, 0x00000018 }, 44 { CS35L56_ASP1_ENABLES1, 0x00000000 }, 45 { CS35L56_ASP1TX1_INPUT, 0x00000018 }, 46 { CS35L56_ASP1TX2_INPUT, 0x00000019 }, 47 { CS35L56_ASP1TX3_INPUT, 0x00000020 }, 48 { CS35L56_ASP1TX4_INPUT, 0x00000028 }, 49 50 }; 51 52 static void cs35l56_hda_wait_dsp_ready(struct cs35l56_hda *cs35l56) 53 { 54 /* Wait for patching to complete */ 55 flush_work(&cs35l56->dsp_work); 56 } 57 58 static void cs35l56_hda_play(struct cs35l56_hda *cs35l56) 59 { 60 unsigned int val; 61 int ret; 62 63 cs35l56_hda_wait_dsp_ready(cs35l56); 64 65 pm_runtime_get_sync(cs35l56->base.dev); 66 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY); 67 if (ret == 0) { 68 /* Wait for firmware to enter PS0 power state */ 69 ret = regmap_read_poll_timeout(cs35l56->base.regmap, 70 cs35l56->base.fw_reg->transducer_actual_ps, 71 val, (val == CS35L56_PS0), 72 CS35L56_PS0_POLL_US, 73 CS35L56_PS0_TIMEOUT_US); 74 if (ret) 75 dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret); 76 } 77 regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1, 78 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) | 79 cs35l56->asp_tx_mask); 80 cs35l56->playing = true; 81 } 82 83 static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56) 84 { 85 cs35l56->playing = false; 86 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE); 87 regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1, 88 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) | 89 BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) | 90 BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT)); 91 92 pm_runtime_mark_last_busy(cs35l56->base.dev); 93 pm_runtime_put_autosuspend(cs35l56->base.dev); 94 } 95 96 static void cs35l56_hda_playback_hook(struct device *dev, int action) 97 { 98 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 99 100 dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action); 101 102 switch (action) { 103 case HDA_GEN_PCM_ACT_PREPARE: 104 if (cs35l56->playing) 105 break; 106 107 /* If we're suspended: flag that resume should start playback */ 108 if (cs35l56->suspended) { 109 cs35l56->playing = true; 110 break; 111 } 112 113 cs35l56_hda_play(cs35l56); 114 break; 115 case HDA_GEN_PCM_ACT_CLEANUP: 116 if (!cs35l56->playing) 117 break; 118 119 cs35l56_hda_pause(cs35l56); 120 break; 121 default: 122 break; 123 } 124 } 125 126 static int cs35l56_hda_runtime_suspend(struct device *dev) 127 { 128 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 129 130 if (cs35l56->cs_dsp.booted) 131 cs_dsp_stop(&cs35l56->cs_dsp); 132 133 return cs35l56_runtime_suspend_common(&cs35l56->base); 134 } 135 136 static int cs35l56_hda_runtime_resume(struct device *dev) 137 { 138 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 139 int ret; 140 141 ret = cs35l56_runtime_resume_common(&cs35l56->base, false); 142 if (ret < 0) 143 return ret; 144 145 if (cs35l56->cs_dsp.booted) { 146 ret = cs_dsp_run(&cs35l56->cs_dsp); 147 if (ret) { 148 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret); 149 goto err; 150 } 151 } 152 153 return 0; 154 155 err: 156 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE); 157 regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1, 158 CS35L56_MBOX_CMD_HIBERNATE_NOW); 159 160 regcache_cache_only(cs35l56->base.regmap, true); 161 162 return ret; 163 } 164 165 static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol, 166 struct snd_ctl_elem_info *uinfo) 167 { 168 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 169 uinfo->count = 1; 170 uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC; 171 if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC) 172 uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1; 173 strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item], 174 sizeof(uinfo->value.enumerated.name)); 175 176 return 0; 177 } 178 179 static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol, 180 struct snd_ctl_elem_value *ucontrol) 181 { 182 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 183 unsigned int reg_val; 184 int i; 185 186 cs35l56_hda_wait_dsp_ready(cs35l56); 187 188 regmap_read(cs35l56->base.regmap, kcontrol->private_value, ®_val); 189 reg_val &= CS35L56_ASP_TXn_SRC_MASK; 190 191 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) { 192 if (cs35l56_tx_input_values[i] == reg_val) { 193 ucontrol->value.enumerated.item[0] = i; 194 break; 195 } 196 } 197 198 return 0; 199 } 200 201 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol, 202 struct snd_ctl_elem_value *ucontrol) 203 { 204 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 205 unsigned int item = ucontrol->value.enumerated.item[0]; 206 bool changed; 207 208 if (item >= CS35L56_NUM_INPUT_SRC) 209 return -EINVAL; 210 211 cs35l56_hda_wait_dsp_ready(cs35l56); 212 213 regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value, 214 CS35L56_INPUT_MASK, cs35l56_tx_input_values[item], 215 &changed); 216 217 return changed; 218 } 219 220 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol, 221 struct snd_ctl_elem_info *uinfo) 222 { 223 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 224 uinfo->count = 1; 225 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN; 226 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX; 227 return 0; 228 } 229 230 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol, 231 struct snd_ctl_elem_value *ucontrol) 232 { 233 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 234 unsigned int pos; 235 int ret; 236 237 cs35l56_hda_wait_dsp_ready(cs35l56); 238 239 ret = regmap_read(cs35l56->base.regmap, 240 cs35l56->base.fw_reg->posture_number, &pos); 241 if (ret) 242 return ret; 243 244 ucontrol->value.integer.value[0] = pos; 245 246 return 0; 247 } 248 249 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol, 250 struct snd_ctl_elem_value *ucontrol) 251 { 252 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 253 unsigned long pos = ucontrol->value.integer.value[0]; 254 bool changed; 255 int ret; 256 257 if ((pos < CS35L56_MAIN_POSTURE_MIN) || 258 (pos > CS35L56_MAIN_POSTURE_MAX)) 259 return -EINVAL; 260 261 cs35l56_hda_wait_dsp_ready(cs35l56); 262 263 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number, 264 CS35L56_MAIN_POSTURE_MASK, pos, &changed); 265 if (ret) 266 return ret; 267 268 return changed; 269 } 270 271 static const struct { 272 const char *name; 273 unsigned int reg; 274 } cs35l56_hda_mixer_controls[] = { 275 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT }, 276 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT }, 277 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT }, 278 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT }, 279 }; 280 281 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0); 282 283 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol, 284 struct snd_ctl_elem_info *uinfo) 285 { 286 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 287 uinfo->count = 1; 288 uinfo->value.integer.step = 1; 289 uinfo->value.integer.min = 0; 290 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX - 291 CS35L56_MAIN_RENDER_USER_VOLUME_MIN; 292 293 return 0; 294 } 295 296 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol, 297 struct snd_ctl_elem_value *ucontrol) 298 { 299 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 300 unsigned int raw_vol; 301 int vol; 302 int ret; 303 304 cs35l56_hda_wait_dsp_ready(cs35l56); 305 306 ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol); 307 308 if (ret) 309 return ret; 310 311 vol = (s16)(raw_vol & 0xFFFF); 312 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT; 313 314 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT)) 315 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1)); 316 317 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN; 318 319 return 0; 320 } 321 322 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol, 323 struct snd_ctl_elem_value *ucontrol) 324 { 325 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 326 long vol = ucontrol->value.integer.value[0]; 327 unsigned int raw_vol; 328 bool changed; 329 int ret; 330 331 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX - 332 CS35L56_MAIN_RENDER_USER_VOLUME_MIN))) 333 return -EINVAL; 334 335 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) << 336 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT; 337 338 cs35l56_hda_wait_dsp_ready(cs35l56); 339 340 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, 341 CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed); 342 if (ret) 343 return ret; 344 345 return changed; 346 } 347 348 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56) 349 { 350 struct snd_kcontrol_new ctl_template = { 351 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 352 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 353 .info = cs35l56_hda_posture_info, 354 .get = cs35l56_hda_posture_get, 355 .put = cs35l56_hda_posture_put, 356 }; 357 char name[64]; 358 int i; 359 360 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name); 361 ctl_template.name = name; 362 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56); 363 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl)) 364 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name); 365 366 /* Mixer controls */ 367 ctl_template.info = cs35l56_hda_mixer_info; 368 ctl_template.get = cs35l56_hda_mixer_get; 369 ctl_template.put = cs35l56_hda_mixer_put; 370 371 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls)); 372 373 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) { 374 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name, 375 cs35l56_hda_mixer_controls[i].name); 376 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg; 377 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56); 378 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) { 379 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", 380 ctl_template.name); 381 } 382 } 383 384 ctl_template.info = cs35l56_hda_vol_info; 385 ctl_template.get = cs35l56_hda_vol_get; 386 ctl_template.put = cs35l56_hda_vol_put; 387 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ); 388 ctl_template.tlv.p = cs35l56_hda_vol_tlv; 389 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name); 390 ctl_template.name = name; 391 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56); 392 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl)) 393 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name); 394 } 395 396 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56) 397 { 398 int i; 399 400 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--) 401 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]); 402 403 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl); 404 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl); 405 } 406 407 static const struct cs_dsp_client_ops cs35l56_hda_client_ops = { 408 /* cs_dsp requires the client to provide this even if it is empty */ 409 }; 410 411 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56, 412 const struct firmware **firmware, char **filename, 413 const char *base_name, const char *system_name, 414 const char *amp_name, 415 const char *filetype) 416 { 417 char *s, c; 418 int ret = 0; 419 420 if (system_name && amp_name) 421 *filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name, 422 system_name, amp_name, filetype); 423 else if (system_name) 424 *filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name, 425 system_name, filetype); 426 else 427 *filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype); 428 429 if (!*filename) 430 return -ENOMEM; 431 432 /* 433 * Make sure that filename is lower-case and any non alpha-numeric 434 * characters except full stop and forward slash are replaced with 435 * hyphens. 436 */ 437 s = *filename; 438 while (*s) { 439 c = *s; 440 if (isalnum(c)) 441 *s = tolower(c); 442 else if (c != '.' && c != '/') 443 *s = '-'; 444 s++; 445 } 446 447 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev); 448 if (ret) { 449 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename); 450 kfree(*filename); 451 *filename = NULL; 452 return ret; 453 } 454 455 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename); 456 457 return 0; 458 } 459 460 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56, 461 unsigned int preloaded_fw_ver, 462 const struct firmware **wmfw_firmware, 463 char **wmfw_filename, 464 const struct firmware **coeff_firmware, 465 char **coeff_filename) 466 { 467 const char *system_name = cs35l56->system_name; 468 const char *amp_name = cs35l56->amp_name; 469 char base_name[37]; 470 int ret; 471 472 if (preloaded_fw_ver) { 473 snprintf(base_name, sizeof(base_name), 474 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc", 475 cs35l56->base.type, 476 cs35l56->base.rev, 477 cs35l56->base.secured ? "-s" : "", 478 preloaded_fw_ver & 0xffffff); 479 } else { 480 snprintf(base_name, sizeof(base_name), 481 "cirrus/cs35l%02x-%02x%s-dsp1-misc", 482 cs35l56->base.type, 483 cs35l56->base.rev, 484 cs35l56->base.secured ? "-s" : ""); 485 } 486 487 if (system_name && amp_name) { 488 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 489 base_name, system_name, amp_name, "wmfw")) { 490 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 491 base_name, system_name, amp_name, "bin"); 492 return; 493 } 494 } 495 496 if (system_name) { 497 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 498 base_name, system_name, NULL, "wmfw")) { 499 if (amp_name) 500 cs35l56_hda_request_firmware_file(cs35l56, 501 coeff_firmware, coeff_filename, 502 base_name, system_name, 503 amp_name, "bin"); 504 if (!*coeff_firmware) 505 cs35l56_hda_request_firmware_file(cs35l56, 506 coeff_firmware, coeff_filename, 507 base_name, system_name, 508 NULL, "bin"); 509 return; 510 } 511 512 /* 513 * Check for system-specific bin files without wmfw before 514 * falling back to generic firmware 515 */ 516 if (amp_name) 517 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 518 base_name, system_name, amp_name, "bin"); 519 if (!*coeff_firmware) 520 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 521 base_name, system_name, NULL, "bin"); 522 523 if (*coeff_firmware) 524 return; 525 } 526 527 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 528 base_name, NULL, NULL, "wmfw"); 529 if (!ret) { 530 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 531 base_name, NULL, NULL, "bin"); 532 return; 533 } 534 535 if (!*coeff_firmware) 536 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 537 base_name, NULL, NULL, "bin"); 538 } 539 540 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware, 541 char *wmfw_filename, 542 const struct firmware *coeff_firmware, 543 char *coeff_filename) 544 { 545 release_firmware(wmfw_firmware); 546 kfree(wmfw_filename); 547 548 release_firmware(coeff_firmware); 549 kfree(coeff_filename); 550 } 551 552 static void cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56) 553 { 554 int ret; 555 556 if (!cs35l56->base.cal_data_valid || cs35l56->base.secured) 557 return; 558 559 ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp, 560 &cs35l56_calibration_controls, 561 &cs35l56->base.cal_data); 562 if (ret < 0) 563 dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret); 564 else 565 dev_info(cs35l56->base.dev, "Calibration applied\n"); 566 } 567 568 static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56) 569 { 570 const struct firmware *coeff_firmware = NULL; 571 const struct firmware *wmfw_firmware = NULL; 572 char *coeff_filename = NULL; 573 char *wmfw_filename = NULL; 574 unsigned int preloaded_fw_ver; 575 bool firmware_missing; 576 int ret; 577 578 /* 579 * Prepare for a new DSP power-up. If the DSP has had firmware 580 * downloaded previously then it needs to be powered down so that it 581 * can be updated. 582 */ 583 if (cs35l56->base.fw_patched) 584 cs_dsp_power_down(&cs35l56->cs_dsp); 585 586 cs35l56->base.fw_patched = false; 587 588 ret = pm_runtime_resume_and_get(cs35l56->base.dev); 589 if (ret < 0) { 590 dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret); 591 return; 592 } 593 594 /* 595 * The firmware can only be upgraded if it is currently running 596 * from the built-in ROM. If not, the wmfw/bin must be for the 597 * version of firmware that is running on the chip. 598 */ 599 ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver); 600 if (ret) 601 goto err_pm_put; 602 603 if (firmware_missing) 604 preloaded_fw_ver = 0; 605 606 cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver, 607 &wmfw_firmware, &wmfw_filename, 608 &coeff_firmware, &coeff_filename); 609 610 /* 611 * If the BIOS didn't patch the firmware a bin file is mandatory to 612 * enable the ASP· 613 */ 614 if (!coeff_firmware && firmware_missing) { 615 dev_err(cs35l56->base.dev, ".bin file required but not found\n"); 616 goto err_fw_release; 617 } 618 619 mutex_lock(&cs35l56->base.irq_lock); 620 621 /* 622 * If the firmware hasn't been patched it must be shutdown before 623 * doing a full patch and reset afterwards. If it is already 624 * running a patched version the firmware files only contain 625 * tunings and we can use the lower cost reinit sequence instead. 626 */ 627 if (firmware_missing && (wmfw_firmware || coeff_firmware)) { 628 ret = cs35l56_firmware_shutdown(&cs35l56->base); 629 if (ret) 630 goto err; 631 } 632 633 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename, 634 coeff_firmware, coeff_filename, "misc"); 635 if (ret) { 636 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret); 637 goto err; 638 } 639 640 if (wmfw_filename) 641 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename); 642 643 if (coeff_filename) 644 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename); 645 646 /* If we downloaded firmware, reset the device and wait for it to boot */ 647 if (firmware_missing && (wmfw_firmware || coeff_firmware)) { 648 cs35l56_system_reset(&cs35l56->base, false); 649 regcache_mark_dirty(cs35l56->base.regmap); 650 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base); 651 if (ret) 652 goto err_powered_up; 653 654 regcache_cache_only(cs35l56->base.regmap, false); 655 } 656 657 /* Disable auto-hibernate so that runtime_pm has control */ 658 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE); 659 if (ret) 660 goto err_powered_up; 661 662 regcache_sync(cs35l56->base.regmap); 663 664 regmap_clear_bits(cs35l56->base.regmap, 665 cs35l56->base.fw_reg->prot_sts, 666 CS35L56_FIRMWARE_MISSING); 667 cs35l56->base.fw_patched = true; 668 669 ret = cs_dsp_run(&cs35l56->cs_dsp); 670 if (ret) 671 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret); 672 673 cs35l56_hda_apply_calibration(cs35l56); 674 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT); 675 if (ret) 676 cs_dsp_stop(&cs35l56->cs_dsp); 677 678 cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp); 679 680 err_powered_up: 681 if (!cs35l56->base.fw_patched) 682 cs_dsp_power_down(&cs35l56->cs_dsp); 683 err: 684 mutex_unlock(&cs35l56->base.irq_lock); 685 err_fw_release: 686 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename, 687 coeff_firmware, coeff_filename); 688 err_pm_put: 689 pm_runtime_put(cs35l56->base.dev); 690 } 691 692 static void cs35l56_hda_dsp_work(struct work_struct *work) 693 { 694 struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work); 695 696 cs35l56_hda_fw_load(cs35l56); 697 } 698 699 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data) 700 { 701 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 702 struct hda_component_parent *parent = master_data; 703 struct hda_component *comp; 704 705 comp = hda_component_from_index(parent, cs35l56->index); 706 if (!comp) 707 return -EINVAL; 708 709 if (comp->dev) 710 return -EBUSY; 711 712 comp->dev = dev; 713 cs35l56->codec = parent->codec; 714 strscpy(comp->name, dev_name(dev), sizeof(comp->name)); 715 comp->playback_hook = cs35l56_hda_playback_hook; 716 717 queue_work(system_long_wq, &cs35l56->dsp_work); 718 719 cs35l56_hda_create_controls(cs35l56); 720 721 #if IS_ENABLED(CONFIG_SND_DEBUG) 722 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root); 723 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root); 724 #endif 725 726 dev_dbg(cs35l56->base.dev, "Bound\n"); 727 728 return 0; 729 } 730 731 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data) 732 { 733 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 734 struct hda_component_parent *parent = master_data; 735 struct hda_component *comp; 736 737 cancel_work_sync(&cs35l56->dsp_work); 738 739 cs35l56_hda_remove_controls(cs35l56); 740 741 #if IS_ENABLED(CONFIG_SND_DEBUG) 742 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp); 743 debugfs_remove_recursive(cs35l56->debugfs_root); 744 #endif 745 746 if (cs35l56->base.fw_patched) 747 cs_dsp_power_down(&cs35l56->cs_dsp); 748 749 comp = hda_component_from_index(parent, cs35l56->index); 750 if (comp && (comp->dev == dev)) 751 memset(comp, 0, sizeof(*comp)); 752 753 cs35l56->codec = NULL; 754 755 dev_dbg(cs35l56->base.dev, "Unbound\n"); 756 } 757 758 static const struct component_ops cs35l56_hda_comp_ops = { 759 .bind = cs35l56_hda_bind, 760 .unbind = cs35l56_hda_unbind, 761 }; 762 763 static int cs35l56_hda_system_suspend(struct device *dev) 764 { 765 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 766 767 cs35l56_hda_wait_dsp_ready(cs35l56); 768 769 if (cs35l56->playing) 770 cs35l56_hda_pause(cs35l56); 771 772 cs35l56->suspended = true; 773 774 /* 775 * The interrupt line is normally shared, but after we start suspending 776 * we can't check if our device is the source of an interrupt, and can't 777 * clear it. Prevent this race by temporarily disabling the parent irq 778 * until we reach _no_irq. 779 */ 780 if (cs35l56->base.irq) 781 disable_irq(cs35l56->base.irq); 782 783 return pm_runtime_force_suspend(dev); 784 } 785 786 static int cs35l56_hda_system_suspend_late(struct device *dev) 787 { 788 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 789 790 /* 791 * RESET is usually shared by all amps so it must not be asserted until 792 * all driver instances have done their suspend() stage. 793 */ 794 if (cs35l56->base.reset_gpio) { 795 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 796 cs35l56_wait_min_reset_pulse(); 797 } 798 799 return 0; 800 } 801 802 static int cs35l56_hda_system_suspend_no_irq(struct device *dev) 803 { 804 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 805 806 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */ 807 if (cs35l56->base.irq) 808 enable_irq(cs35l56->base.irq); 809 810 return 0; 811 } 812 813 static int cs35l56_hda_system_resume_no_irq(struct device *dev) 814 { 815 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 816 817 /* 818 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause 819 * spurious interrupts, and the interrupt line is normally shared. 820 * We can't check if our device is the source of an interrupt, and can't 821 * clear it, until it has fully resumed. Prevent this race by temporarily 822 * disabling the parent irq until we complete resume(). 823 */ 824 if (cs35l56->base.irq) 825 disable_irq(cs35l56->base.irq); 826 827 return 0; 828 } 829 830 static int cs35l56_hda_system_resume_early(struct device *dev) 831 { 832 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 833 834 /* Ensure a spec-compliant RESET pulse. */ 835 if (cs35l56->base.reset_gpio) { 836 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 837 cs35l56_wait_min_reset_pulse(); 838 839 /* Release shared RESET before drivers start resume(). */ 840 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1); 841 cs35l56_wait_control_port_ready(); 842 } 843 844 return 0; 845 } 846 847 static int cs35l56_hda_system_resume(struct device *dev) 848 { 849 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 850 int ret; 851 852 /* Undo pm_runtime_force_suspend() before re-enabling the irq */ 853 ret = pm_runtime_force_resume(dev); 854 if (cs35l56->base.irq) 855 enable_irq(cs35l56->base.irq); 856 857 if (ret) 858 return ret; 859 860 cs35l56->suspended = false; 861 862 if (!cs35l56->codec) 863 return 0; 864 865 ret = cs35l56_is_fw_reload_needed(&cs35l56->base); 866 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret); 867 if (ret > 0) 868 queue_work(system_long_wq, &cs35l56->dsp_work); 869 870 if (cs35l56->playing) 871 cs35l56_hda_play(cs35l56); 872 873 return 0; 874 } 875 876 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id) 877 { 878 u32 values[HDA_MAX_COMPONENTS]; 879 char hid_string[8]; 880 struct acpi_device *adev; 881 const char *property, *sub; 882 size_t nval; 883 int i, ret; 884 885 /* 886 * ACPI_COMPANION isn't available when this driver was instantiated by 887 * the serial-multi-instantiate driver, so lookup the node by HID 888 */ 889 if (!ACPI_COMPANION(cs35l56->base.dev)) { 890 snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid); 891 adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1); 892 if (!adev) { 893 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n", 894 dev_name(cs35l56->base.dev)); 895 return -ENODEV; 896 } 897 ACPI_COMPANION_SET(cs35l56->base.dev, adev); 898 } 899 900 property = "cirrus,dev-index"; 901 ret = device_property_count_u32(cs35l56->base.dev, property); 902 if (ret <= 0) 903 goto err; 904 905 if (ret > ARRAY_SIZE(values)) { 906 ret = -EINVAL; 907 goto err; 908 } 909 nval = ret; 910 911 ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval); 912 if (ret) 913 goto err; 914 915 cs35l56->index = -1; 916 for (i = 0; i < nval; i++) { 917 if (values[i] == id) { 918 cs35l56->index = i; 919 break; 920 } 921 } 922 /* 923 * It's not an error for the ID to be missing: for I2C there can be 924 * an alias address that is not a real device. So reject silently. 925 */ 926 if (cs35l56->index == -1) { 927 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property); 928 ret = -ENODEV; 929 goto err; 930 } 931 932 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev)); 933 934 if (IS_ERR(sub)) { 935 dev_info(cs35l56->base.dev, 936 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n", 937 PTR_ERR(sub)); 938 } else { 939 ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index, nval, -1); 940 if (ret == -ENOENT) { 941 cs35l56->system_name = sub; 942 } else if (ret >= 0) { 943 cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret); 944 kfree(sub); 945 if (!cs35l56->system_name) 946 return -ENOMEM; 947 } else { 948 return ret; 949 } 950 } 951 952 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev, 953 "reset", 954 cs35l56->index, 955 GPIOD_OUT_LOW); 956 if (IS_ERR(cs35l56->base.reset_gpio)) { 957 ret = PTR_ERR(cs35l56->base.reset_gpio); 958 959 /* 960 * If RESET is shared the first amp to probe will grab the reset 961 * line and reset all the amps 962 */ 963 if (ret != -EBUSY) 964 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n"); 965 966 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n"); 967 cs35l56->base.reset_gpio = NULL; 968 } 969 970 return 0; 971 972 err: 973 if (ret != -ENODEV) 974 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret); 975 976 return ret; 977 } 978 979 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id) 980 { 981 int ret; 982 983 mutex_init(&cs35l56->base.irq_lock); 984 dev_set_drvdata(cs35l56->base.dev, cs35l56); 985 986 INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work); 987 988 ret = cs35l56_hda_read_acpi(cs35l56, hid, id); 989 if (ret) 990 goto err; 991 992 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d", 993 cs35l56->index + 1); 994 if (!cs35l56->amp_name) { 995 ret = -ENOMEM; 996 goto err; 997 } 998 999 cs35l56->base.cal_index = -1; 1000 1001 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp); 1002 cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops; 1003 1004 if (cs35l56->base.reset_gpio) { 1005 dev_dbg(cs35l56->base.dev, "Hard reset\n"); 1006 1007 /* 1008 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the 1009 * ACPI defines a different default state. So explicitly set low. 1010 */ 1011 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1012 cs35l56_wait_min_reset_pulse(); 1013 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1); 1014 } 1015 1016 ret = cs35l56_hw_init(&cs35l56->base); 1017 if (ret < 0) 1018 goto err; 1019 1020 /* Reset the device and wait for it to boot */ 1021 cs35l56_system_reset(&cs35l56->base, false); 1022 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base); 1023 if (ret) 1024 goto err; 1025 1026 regcache_cache_only(cs35l56->base.regmap, false); 1027 1028 ret = cs35l56_set_patch(&cs35l56->base); 1029 if (ret) 1030 goto err; 1031 1032 regcache_mark_dirty(cs35l56->base.regmap); 1033 regcache_sync(cs35l56->base.regmap); 1034 1035 /* Disable auto-hibernate so that runtime_pm has control */ 1036 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE); 1037 if (ret) 1038 goto err; 1039 1040 ret = cs35l56_get_calibration(&cs35l56->base); 1041 if (ret) 1042 goto err; 1043 1044 ret = cs_dsp_halo_init(&cs35l56->cs_dsp); 1045 if (ret) { 1046 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n"); 1047 goto err; 1048 } 1049 1050 dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n", 1051 cs35l56->system_name, cs35l56->amp_name); 1052 1053 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config, 1054 ARRAY_SIZE(cs35l56_hda_dai_config)); 1055 1056 /* 1057 * By default only enable one ASP1TXn, where n=amplifier index, 1058 * This prevents multiple amps trying to drive the same slot. 1059 */ 1060 cs35l56->asp_tx_mask = BIT(cs35l56->index); 1061 1062 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000); 1063 pm_runtime_use_autosuspend(cs35l56->base.dev); 1064 pm_runtime_set_active(cs35l56->base.dev); 1065 pm_runtime_mark_last_busy(cs35l56->base.dev); 1066 pm_runtime_enable(cs35l56->base.dev); 1067 1068 cs35l56->base.init_done = true; 1069 1070 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops); 1071 if (ret) { 1072 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret); 1073 goto pm_err; 1074 } 1075 1076 return 0; 1077 1078 pm_err: 1079 pm_runtime_disable(cs35l56->base.dev); 1080 cs_dsp_remove(&cs35l56->cs_dsp); 1081 err: 1082 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1083 1084 return ret; 1085 } 1086 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56"); 1087 1088 void cs35l56_hda_remove(struct device *dev) 1089 { 1090 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 1091 1092 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops); 1093 1094 pm_runtime_dont_use_autosuspend(cs35l56->base.dev); 1095 pm_runtime_get_sync(cs35l56->base.dev); 1096 pm_runtime_disable(cs35l56->base.dev); 1097 1098 cs_dsp_remove(&cs35l56->cs_dsp); 1099 1100 kfree(cs35l56->system_name); 1101 pm_runtime_put_noidle(cs35l56->base.dev); 1102 1103 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1104 } 1105 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56"); 1106 1107 const struct dev_pm_ops cs35l56_hda_pm_ops = { 1108 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL) 1109 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume) 1110 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late, 1111 cs35l56_hda_system_resume_early) 1112 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq, 1113 cs35l56_hda_system_resume_no_irq) 1114 }; 1115 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56"); 1116 1117 MODULE_DESCRIPTION("CS35L56 HDA Driver"); 1118 MODULE_IMPORT_NS("FW_CS_DSP"); 1119 MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC"); 1120 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED"); 1121 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 1122 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 1123 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>"); 1124 MODULE_LICENSE("GPL"); 1125