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