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 "../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_put_autosuspend(cs35l56->base.dev); 93 } 94 95 static void cs35l56_hda_playback_hook(struct device *dev, int action) 96 { 97 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 98 99 dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action); 100 101 switch (action) { 102 case HDA_GEN_PCM_ACT_PREPARE: 103 if (cs35l56->playing) 104 break; 105 106 /* If we're suspended: flag that resume should start playback */ 107 if (cs35l56->suspended) { 108 cs35l56->playing = true; 109 break; 110 } 111 112 cs35l56_hda_play(cs35l56); 113 break; 114 case HDA_GEN_PCM_ACT_CLEANUP: 115 if (!cs35l56->playing) 116 break; 117 118 cs35l56_hda_pause(cs35l56); 119 break; 120 default: 121 break; 122 } 123 } 124 125 static int cs35l56_hda_runtime_suspend(struct device *dev) 126 { 127 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 128 129 if (cs35l56->cs_dsp.booted) 130 cs_dsp_stop(&cs35l56->cs_dsp); 131 132 return cs35l56_runtime_suspend_common(&cs35l56->base); 133 } 134 135 static int cs35l56_hda_runtime_resume(struct device *dev) 136 { 137 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 138 int ret; 139 140 ret = cs35l56_runtime_resume_common(&cs35l56->base, false); 141 if (ret < 0) 142 return ret; 143 144 if (cs35l56->cs_dsp.booted) { 145 ret = cs_dsp_run(&cs35l56->cs_dsp); 146 if (ret) { 147 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret); 148 goto err; 149 } 150 } 151 152 return 0; 153 154 err: 155 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE); 156 regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1, 157 CS35L56_MBOX_CMD_HIBERNATE_NOW); 158 159 regcache_cache_only(cs35l56->base.regmap, true); 160 161 return ret; 162 } 163 164 static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol, 165 struct snd_ctl_elem_info *uinfo) 166 { 167 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 168 uinfo->count = 1; 169 uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC; 170 if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC) 171 uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1; 172 strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item], 173 sizeof(uinfo->value.enumerated.name)); 174 175 return 0; 176 } 177 178 static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol, 179 struct snd_ctl_elem_value *ucontrol) 180 { 181 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 182 unsigned int reg_val; 183 int i, ret; 184 185 cs35l56_hda_wait_dsp_ready(cs35l56); 186 187 ret = regmap_read(cs35l56->base.regmap, kcontrol->private_value, 188 ®_val); 189 if (ret) 190 return ret; 191 192 reg_val &= CS35L56_ASP_TXn_SRC_MASK; 193 194 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) { 195 if (cs35l56_tx_input_values[i] == reg_val) { 196 ucontrol->value.enumerated.item[0] = i; 197 break; 198 } 199 } 200 201 return 0; 202 } 203 204 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol, 205 struct snd_ctl_elem_value *ucontrol) 206 { 207 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 208 unsigned int item = ucontrol->value.enumerated.item[0]; 209 bool changed; 210 int ret; 211 212 if (item >= CS35L56_NUM_INPUT_SRC) 213 return -EINVAL; 214 215 cs35l56_hda_wait_dsp_ready(cs35l56); 216 217 ret = regmap_update_bits_check(cs35l56->base.regmap, 218 kcontrol->private_value, 219 CS35L56_INPUT_MASK, 220 cs35l56_tx_input_values[item], 221 &changed); 222 if (ret) 223 return ret; 224 225 return changed; 226 } 227 228 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol, 229 struct snd_ctl_elem_info *uinfo) 230 { 231 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 232 uinfo->count = 1; 233 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN; 234 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX; 235 return 0; 236 } 237 238 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol, 239 struct snd_ctl_elem_value *ucontrol) 240 { 241 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 242 unsigned int pos; 243 int ret; 244 245 cs35l56_hda_wait_dsp_ready(cs35l56); 246 247 ret = regmap_read(cs35l56->base.regmap, 248 cs35l56->base.fw_reg->posture_number, &pos); 249 if (ret) 250 return ret; 251 252 ucontrol->value.integer.value[0] = pos; 253 254 return 0; 255 } 256 257 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol, 258 struct snd_ctl_elem_value *ucontrol) 259 { 260 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 261 long pos = ucontrol->value.integer.value[0]; 262 bool changed; 263 int ret; 264 265 if ((pos < CS35L56_MAIN_POSTURE_MIN) || 266 (pos > CS35L56_MAIN_POSTURE_MAX)) 267 return -EINVAL; 268 269 cs35l56_hda_wait_dsp_ready(cs35l56); 270 271 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number, 272 CS35L56_MAIN_POSTURE_MASK, pos, &changed); 273 if (ret) 274 return ret; 275 276 return changed; 277 } 278 279 static const struct { 280 const char *name; 281 unsigned int reg; 282 } cs35l56_hda_mixer_controls[] = { 283 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT }, 284 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT }, 285 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT }, 286 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT }, 287 }; 288 289 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0); 290 291 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol, 292 struct snd_ctl_elem_info *uinfo) 293 { 294 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 295 uinfo->count = 1; 296 uinfo->value.integer.step = 1; 297 uinfo->value.integer.min = 0; 298 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX - 299 CS35L56_MAIN_RENDER_USER_VOLUME_MIN; 300 301 return 0; 302 } 303 304 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol, 305 struct snd_ctl_elem_value *ucontrol) 306 { 307 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 308 unsigned int raw_vol; 309 int vol; 310 int ret; 311 312 cs35l56_hda_wait_dsp_ready(cs35l56); 313 314 ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol); 315 316 if (ret) 317 return ret; 318 319 vol = (s16)(raw_vol & 0xFFFF); 320 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT; 321 322 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT)) 323 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1)); 324 325 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN; 326 327 return 0; 328 } 329 330 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol, 331 struct snd_ctl_elem_value *ucontrol) 332 { 333 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol); 334 long vol = ucontrol->value.integer.value[0]; 335 unsigned int raw_vol; 336 bool changed; 337 int ret; 338 339 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX - 340 CS35L56_MAIN_RENDER_USER_VOLUME_MIN))) 341 return -EINVAL; 342 343 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) << 344 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT; 345 346 cs35l56_hda_wait_dsp_ready(cs35l56); 347 348 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, 349 CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed); 350 if (ret) 351 return ret; 352 353 return changed; 354 } 355 356 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56) 357 { 358 struct snd_kcontrol_new ctl_template = { 359 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 360 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 361 .info = cs35l56_hda_posture_info, 362 .get = cs35l56_hda_posture_get, 363 .put = cs35l56_hda_posture_put, 364 }; 365 char name[64]; 366 int i; 367 368 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name); 369 ctl_template.name = name; 370 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56); 371 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl)) 372 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name); 373 374 /* Mixer controls */ 375 ctl_template.info = cs35l56_hda_mixer_info; 376 ctl_template.get = cs35l56_hda_mixer_get; 377 ctl_template.put = cs35l56_hda_mixer_put; 378 379 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls)); 380 381 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) { 382 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name, 383 cs35l56_hda_mixer_controls[i].name); 384 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg; 385 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56); 386 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) { 387 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", 388 ctl_template.name); 389 } 390 } 391 392 ctl_template.info = cs35l56_hda_vol_info; 393 ctl_template.get = cs35l56_hda_vol_get; 394 ctl_template.put = cs35l56_hda_vol_put; 395 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ); 396 ctl_template.tlv.p = cs35l56_hda_vol_tlv; 397 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name); 398 ctl_template.name = name; 399 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56); 400 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl)) 401 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name); 402 } 403 404 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56) 405 { 406 int i; 407 408 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--) 409 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]); 410 411 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl); 412 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl); 413 } 414 415 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56, 416 const struct firmware **firmware, char **filename, 417 const char *base_name, const char *system_name, 418 const char *amp_name, 419 const char *filetype) 420 { 421 char *s, c; 422 int ret = 0; 423 424 if (system_name && amp_name) 425 *filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name, 426 system_name, amp_name, filetype); 427 else if (system_name) 428 *filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name, 429 system_name, filetype); 430 else 431 *filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype); 432 433 if (!*filename) 434 return -ENOMEM; 435 436 /* 437 * Make sure that filename is lower-case and any non alpha-numeric 438 * characters except full stop and forward slash are replaced with 439 * hyphens. 440 */ 441 s = *filename; 442 while (*s) { 443 c = *s; 444 if (isalnum(c)) 445 *s = tolower(c); 446 else if (c != '.' && c != '/') 447 *s = '-'; 448 s++; 449 } 450 451 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev); 452 if (ret) { 453 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename); 454 kfree(*filename); 455 *filename = NULL; 456 return ret; 457 } 458 459 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename); 460 461 return 0; 462 } 463 464 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56, 465 unsigned int preloaded_fw_ver, 466 const struct firmware **wmfw_firmware, 467 char **wmfw_filename, 468 const struct firmware **coeff_firmware, 469 char **coeff_filename) 470 { 471 const char *system_name = cs35l56->system_name; 472 const char *amp_name = cs35l56->amp_name; 473 char base_name[37]; 474 int ret; 475 476 if (preloaded_fw_ver) { 477 snprintf(base_name, sizeof(base_name), 478 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc", 479 cs35l56->base.type, 480 cs35l56->base.rev, 481 cs35l56->base.secured ? "-s" : "", 482 preloaded_fw_ver & 0xffffff); 483 } else { 484 snprintf(base_name, sizeof(base_name), 485 "cirrus/cs35l%02x-%02x%s-dsp1-misc", 486 cs35l56->base.type, 487 cs35l56->base.rev, 488 cs35l56->base.secured ? "-s" : ""); 489 } 490 491 if (system_name && amp_name) { 492 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 493 base_name, system_name, amp_name, "wmfw")) { 494 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 495 base_name, system_name, amp_name, "bin"); 496 return; 497 } 498 } 499 500 if (system_name) { 501 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 502 base_name, system_name, NULL, "wmfw")) { 503 if (amp_name) 504 cs35l56_hda_request_firmware_file(cs35l56, 505 coeff_firmware, coeff_filename, 506 base_name, system_name, 507 amp_name, "bin"); 508 if (!*coeff_firmware) 509 cs35l56_hda_request_firmware_file(cs35l56, 510 coeff_firmware, coeff_filename, 511 base_name, system_name, 512 NULL, "bin"); 513 return; 514 } 515 516 /* 517 * Check for system-specific bin files without wmfw before 518 * falling back to generic firmware 519 */ 520 if (amp_name) 521 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 522 base_name, system_name, amp_name, "bin"); 523 if (!*coeff_firmware) 524 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 525 base_name, system_name, NULL, "bin"); 526 527 if (*coeff_firmware) 528 return; 529 } 530 531 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename, 532 base_name, NULL, NULL, "wmfw"); 533 if (!ret) { 534 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 535 base_name, NULL, NULL, "bin"); 536 return; 537 } 538 539 if (!*coeff_firmware) 540 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename, 541 base_name, NULL, NULL, "bin"); 542 } 543 544 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware, 545 char *wmfw_filename, 546 const struct firmware *coeff_firmware, 547 char *coeff_filename) 548 { 549 release_firmware(wmfw_firmware); 550 kfree(wmfw_filename); 551 552 release_firmware(coeff_firmware); 553 kfree(coeff_filename); 554 } 555 556 static int cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56) 557 { 558 int ret; 559 560 if (!cs35l56->base.cal_data_valid || cs35l56->base.secured) 561 return -EACCES; 562 563 ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp, 564 &cs35l56_calibration_controls, 565 &cs35l56->base.cal_data); 566 if (ret < 0) { 567 dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret); 568 return ret; 569 } 570 571 dev_info(cs35l56->base.dev, "Calibration applied\n"); 572 573 return 0; 574 } 575 576 static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56) 577 { 578 const struct firmware *coeff_firmware = NULL; 579 const struct firmware *wmfw_firmware = NULL; 580 char *coeff_filename = NULL; 581 char *wmfw_filename = NULL; 582 unsigned int preloaded_fw_ver; 583 bool firmware_missing; 584 int ret; 585 586 /* 587 * Prepare for a new DSP power-up. If the DSP has had firmware 588 * downloaded previously then it needs to be powered down so that it 589 * can be updated. 590 */ 591 if (cs35l56->base.fw_patched) 592 cs_dsp_power_down(&cs35l56->cs_dsp); 593 594 cs35l56->base.fw_patched = false; 595 596 PM_RUNTIME_ACQUIRE_IF_ENABLED(cs35l56->base.dev, pm); 597 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 598 if (ret < 0) { 599 dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret); 600 return; 601 } 602 603 /* 604 * The firmware can only be upgraded if it is currently running 605 * from the built-in ROM. If not, the wmfw/bin must be for the 606 * version of firmware that is running on the chip. 607 */ 608 ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver); 609 if (ret) 610 return; 611 612 if (firmware_missing) 613 preloaded_fw_ver = 0; 614 615 cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver, 616 &wmfw_firmware, &wmfw_filename, 617 &coeff_firmware, &coeff_filename); 618 619 /* 620 * If the BIOS didn't patch the firmware a bin file is mandatory to 621 * enable the ASP· 622 */ 623 if (!coeff_firmware && firmware_missing) { 624 dev_err(cs35l56->base.dev, ".bin file required but not found\n"); 625 goto err_fw_release; 626 } 627 628 mutex_lock(&cs35l56->base.irq_lock); 629 630 /* 631 * If the firmware hasn't been patched it must be shutdown before 632 * doing a full patch and reset afterwards. If it is already 633 * running a patched version the firmware files only contain 634 * tunings and we can use the lower cost reinit sequence instead. 635 */ 636 if (firmware_missing && (wmfw_firmware || coeff_firmware)) { 637 ret = cs35l56_firmware_shutdown(&cs35l56->base); 638 if (ret) 639 goto err; 640 } 641 642 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename, 643 coeff_firmware, coeff_filename, "misc"); 644 if (ret) { 645 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret); 646 goto err; 647 } 648 649 if (wmfw_filename) 650 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename); 651 652 if (coeff_filename) 653 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename); 654 655 /* If we downloaded firmware, reset the device and wait for it to boot */ 656 if (firmware_missing && (wmfw_firmware || coeff_firmware)) { 657 cs35l56_system_reset(&cs35l56->base, false); 658 regcache_mark_dirty(cs35l56->base.regmap); 659 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base); 660 if (ret) 661 goto err_powered_up; 662 663 regcache_cache_only(cs35l56->base.regmap, false); 664 } 665 666 /* Disable auto-hibernate so that runtime_pm has control */ 667 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE); 668 if (ret) 669 goto err_powered_up; 670 671 regcache_sync(cs35l56->base.regmap); 672 673 regmap_clear_bits(cs35l56->base.regmap, 674 cs35l56->base.fw_reg->prot_sts, 675 CS35L56_FIRMWARE_MISSING); 676 cs35l56->base.fw_patched = true; 677 678 ret = cs_dsp_run(&cs35l56->cs_dsp); 679 if (ret) 680 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret); 681 682 /* Don't need to check return code, it's not fatal if this fails */ 683 cs35l56_hda_apply_calibration(cs35l56); 684 685 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT); 686 if (ret) 687 cs_dsp_stop(&cs35l56->cs_dsp); 688 689 cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp); 690 691 err_powered_up: 692 if (!cs35l56->base.fw_patched) 693 cs_dsp_power_down(&cs35l56->cs_dsp); 694 err: 695 mutex_unlock(&cs35l56->base.irq_lock); 696 err_fw_release: 697 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename, 698 coeff_firmware, coeff_filename); 699 } 700 701 static void cs35l56_hda_dsp_work(struct work_struct *work) 702 { 703 struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work); 704 705 cs35l56_hda_fw_load(cs35l56); 706 } 707 708 static ssize_t cs35l56_hda_debugfs_calibrate_write(struct file *file, 709 const char __user *from, 710 size_t count, loff_t *ppos) 711 { 712 struct cs35l56_base *cs35l56_base = file->private_data; 713 ssize_t ret; 714 715 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm); 716 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 717 if (ret) 718 return ret; 719 720 return cs35l56_calibrate_debugfs_write(cs35l56_base, from, count, ppos); 721 } 722 723 static ssize_t cs35l56_hda_debugfs_cal_temperature_write(struct file *file, 724 const char __user *from, 725 size_t count, loff_t *ppos) 726 { 727 struct cs35l56_base *cs35l56_base = file->private_data; 728 ssize_t ret; 729 730 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm); 731 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 732 if (ret) 733 return ret; 734 735 return cs35l56_cal_ambient_debugfs_write(cs35l56_base, from, count, ppos); 736 } 737 738 static ssize_t cs35l56_hda_debugfs_cal_data_read(struct file *file, 739 char __user *to, 740 size_t count, loff_t *ppos) 741 { 742 struct cs35l56_base *cs35l56_base = file->private_data; 743 ssize_t ret; 744 745 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm); 746 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 747 if (ret) 748 return ret; 749 750 return cs35l56_cal_data_debugfs_read(cs35l56_base, to, count, ppos); 751 } 752 753 static ssize_t cs35l56_hda_debugfs_cal_data_write(struct file *file, 754 const char __user *from, 755 size_t count, loff_t *ppos) 756 { 757 struct cs35l56_base *cs35l56_base = file->private_data; 758 struct cs35l56_hda *cs35l56 = cs35l56_hda_from_base(cs35l56_base); 759 ssize_t ret; 760 761 ret = cs35l56_cal_data_debugfs_write(cs35l56_base, from, count, ppos); 762 if (ret == -ENODATA) 763 return count; /* Ignore writes of empty cal blobs */ 764 765 if (ret < 0) 766 return ret; 767 768 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(cs35l56_base->dev, pm); 769 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 770 if (ret) 771 return ret; 772 773 ret = cs35l56_hda_apply_calibration(cs35l56); 774 if (ret == 0) 775 cs35l56_mbox_send(cs35l56_base, CS35L56_MBOX_CMD_AUDIO_REINIT); 776 else 777 count = -EIO; 778 779 return count; 780 } 781 782 static const struct cs35l56_cal_debugfs_fops cs35l56_hda_cal_debugfs_fops = { 783 .calibrate = { 784 .write = cs35l56_hda_debugfs_calibrate_write, 785 }, 786 .cal_temperature = { 787 .write = cs35l56_hda_debugfs_cal_temperature_write, 788 }, 789 .cal_data = { 790 .read = cs35l56_hda_debugfs_cal_data_read, 791 .write = cs35l56_hda_debugfs_cal_data_write, 792 }, 793 }; 794 795 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data) 796 { 797 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 798 struct hda_component_parent *parent = master_data; 799 struct hda_component *comp; 800 801 comp = hda_component_from_index(parent, cs35l56->index); 802 if (!comp) 803 return -EINVAL; 804 805 if (comp->dev) 806 return -EBUSY; 807 808 comp->dev = dev; 809 cs35l56->codec = parent->codec; 810 strscpy(comp->name, dev_name(dev), sizeof(comp->name)); 811 comp->playback_hook = cs35l56_hda_playback_hook; 812 813 queue_work(system_long_wq, &cs35l56->dsp_work); 814 815 cs35l56_hda_create_controls(cs35l56); 816 817 #if IS_ENABLED(CONFIG_SND_DEBUG) 818 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root); 819 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root); 820 #endif 821 822 if (IS_ENABLED(CONFIG_SND_HDA_SCODEC_CS35L56_CAL_DEBUGFS)) 823 cs35l56_create_cal_debugfs(&cs35l56->base, &cs35l56_hda_cal_debugfs_fops); 824 825 dev_dbg(cs35l56->base.dev, "Bound\n"); 826 827 return 0; 828 } 829 830 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data) 831 { 832 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 833 struct hda_component_parent *parent = master_data; 834 struct hda_component *comp; 835 836 cancel_work_sync(&cs35l56->dsp_work); 837 838 cs35l56_remove_cal_debugfs(&cs35l56->base); 839 cs35l56_hda_remove_controls(cs35l56); 840 841 #if IS_ENABLED(CONFIG_SND_DEBUG) 842 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp); 843 debugfs_remove_recursive(cs35l56->debugfs_root); 844 #endif 845 846 if (cs35l56->base.fw_patched) 847 cs_dsp_power_down(&cs35l56->cs_dsp); 848 849 comp = hda_component_from_index(parent, cs35l56->index); 850 if (comp && (comp->dev == dev)) 851 memset(comp, 0, sizeof(*comp)); 852 853 cs35l56->codec = NULL; 854 855 dev_dbg(cs35l56->base.dev, "Unbound\n"); 856 } 857 858 static const struct component_ops cs35l56_hda_comp_ops = { 859 .bind = cs35l56_hda_bind, 860 .unbind = cs35l56_hda_unbind, 861 }; 862 863 static int cs35l56_hda_system_suspend(struct device *dev) 864 { 865 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 866 867 cs35l56_hda_wait_dsp_ready(cs35l56); 868 869 if (cs35l56->playing) 870 cs35l56_hda_pause(cs35l56); 871 872 cs35l56->suspended = true; 873 874 /* 875 * The interrupt line is normally shared, but after we start suspending 876 * we can't check if our device is the source of an interrupt, and can't 877 * clear it. Prevent this race by temporarily disabling the parent irq 878 * until we reach _no_irq. 879 */ 880 if (cs35l56->base.irq) 881 disable_irq(cs35l56->base.irq); 882 883 return pm_runtime_force_suspend(dev); 884 } 885 886 static int cs35l56_hda_system_suspend_late(struct device *dev) 887 { 888 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 889 890 /* 891 * RESET is usually shared by all amps so it must not be asserted until 892 * all driver instances have done their suspend() stage. 893 */ 894 if (cs35l56->base.reset_gpio) { 895 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 896 cs35l56_wait_min_reset_pulse(); 897 } 898 899 return 0; 900 } 901 902 static int cs35l56_hda_system_suspend_no_irq(struct device *dev) 903 { 904 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 905 906 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */ 907 if (cs35l56->base.irq) 908 enable_irq(cs35l56->base.irq); 909 910 return 0; 911 } 912 913 static int cs35l56_hda_system_resume_no_irq(struct device *dev) 914 { 915 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 916 917 /* 918 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause 919 * spurious interrupts, and the interrupt line is normally shared. 920 * We can't check if our device is the source of an interrupt, and can't 921 * clear it, until it has fully resumed. Prevent this race by temporarily 922 * disabling the parent irq until we complete resume(). 923 */ 924 if (cs35l56->base.irq) 925 disable_irq(cs35l56->base.irq); 926 927 return 0; 928 } 929 930 static int cs35l56_hda_system_resume_early(struct device *dev) 931 { 932 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 933 934 /* Ensure a spec-compliant RESET pulse. */ 935 if (cs35l56->base.reset_gpio) { 936 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 937 cs35l56_wait_min_reset_pulse(); 938 939 /* Release shared RESET before drivers start resume(). */ 940 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1); 941 cs35l56_wait_control_port_ready(); 942 } 943 944 return 0; 945 } 946 947 static int cs35l56_hda_system_resume(struct device *dev) 948 { 949 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 950 int ret; 951 952 /* Undo pm_runtime_force_suspend() before re-enabling the irq */ 953 ret = pm_runtime_force_resume(dev); 954 if (cs35l56->base.irq) 955 enable_irq(cs35l56->base.irq); 956 957 if (ret) 958 return ret; 959 960 cs35l56->suspended = false; 961 962 if (!cs35l56->codec) 963 return 0; 964 965 ret = cs35l56_is_fw_reload_needed(&cs35l56->base); 966 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret); 967 if (ret > 0) 968 queue_work(system_long_wq, &cs35l56->dsp_work); 969 970 if (cs35l56->playing) 971 cs35l56_hda_play(cs35l56); 972 973 return 0; 974 } 975 976 static int cs35l56_hda_fixup_yoga9(struct cs35l56_hda *cs35l56, int *bus_addr) 977 { 978 /* The cirrus,dev-index property has the wrong values */ 979 cs35l56->num_amps = 2; 980 switch (*bus_addr) { 981 case 0x30: 982 cs35l56->index = 1; 983 return 0; 984 case 0x31: 985 cs35l56->index = 0; 986 return 0; 987 default: 988 /* There is a pseudo-address for broadcast to both amps - ignore it */ 989 dev_dbg(cs35l56->base.dev, "Ignoring I2C address %#x\n", *bus_addr); 990 return 0; 991 } 992 } 993 994 static const struct { 995 const char *sub; 996 int (*fixup_fn)(struct cs35l56_hda *cs35l56, int *bus_addr); 997 } cs35l56_hda_fixups[] = { 998 { 999 .sub = "17AA390B", /* Lenovo Yoga Book 9i GenX */ 1000 .fixup_fn = cs35l56_hda_fixup_yoga9, 1001 }, 1002 }; 1003 1004 static int cs35l56_hda_apply_platform_fixups(struct cs35l56_hda *cs35l56, const char *sub, 1005 int *bus_addr) 1006 { 1007 int i; 1008 1009 if (IS_ERR(sub)) 1010 return 0; 1011 1012 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_fixups); i++) { 1013 if (strcasecmp(cs35l56_hda_fixups[i].sub, sub) == 0) { 1014 dev_dbg(cs35l56->base.dev, "Applying fixup for %s\n", 1015 cs35l56_hda_fixups[i].sub); 1016 return (cs35l56_hda_fixups[i].fixup_fn)(cs35l56, bus_addr); 1017 } 1018 } 1019 1020 return 0; 1021 } 1022 1023 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id) 1024 { 1025 u32 values[HDA_MAX_COMPONENTS]; 1026 char hid_string[8]; 1027 struct acpi_device *adev; 1028 const char *property, *sub; 1029 int i, ret; 1030 1031 /* 1032 * ACPI_COMPANION isn't available when this driver was instantiated by 1033 * the serial-multi-instantiate driver, so lookup the node by HID 1034 */ 1035 if (!ACPI_COMPANION(cs35l56->base.dev)) { 1036 snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid); 1037 adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1); 1038 if (!adev) { 1039 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n", 1040 dev_name(cs35l56->base.dev)); 1041 return -ENODEV; 1042 } 1043 ACPI_COMPANION_SET(cs35l56->base.dev, adev); 1044 } 1045 1046 /* Initialize things that could be overwritten by a fixup */ 1047 cs35l56->index = -1; 1048 1049 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev)); 1050 ret = cs35l56_hda_apply_platform_fixups(cs35l56, sub, &id); 1051 if (ret) 1052 return ret; 1053 1054 if (cs35l56->index == -1) { 1055 property = "cirrus,dev-index"; 1056 ret = device_property_count_u32(cs35l56->base.dev, property); 1057 if (ret <= 0) 1058 goto err; 1059 1060 if (ret > ARRAY_SIZE(values)) { 1061 ret = -EINVAL; 1062 goto err; 1063 } 1064 cs35l56->num_amps = ret; 1065 1066 ret = device_property_read_u32_array(cs35l56->base.dev, property, values, 1067 cs35l56->num_amps); 1068 if (ret) 1069 goto err; 1070 1071 for (i = 0; i < cs35l56->num_amps; i++) { 1072 if (values[i] == id) { 1073 cs35l56->index = i; 1074 break; 1075 } 1076 } 1077 1078 /* 1079 * It's not an error for the ID to be missing: for I2C there can be 1080 * an alias address that is not a real device. So reject silently. 1081 */ 1082 if (cs35l56->index == -1) { 1083 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property); 1084 ret = -ENODEV; 1085 goto err; 1086 } 1087 } 1088 1089 if (IS_ERR(sub)) { 1090 dev_info(cs35l56->base.dev, 1091 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n", 1092 PTR_ERR(sub)); 1093 } else { 1094 ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index, 1095 cs35l56->num_amps, -1); 1096 if (ret == -ENOENT) { 1097 cs35l56->system_name = sub; 1098 } else if (ret >= 0) { 1099 cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret); 1100 kfree(sub); 1101 if (!cs35l56->system_name) 1102 return -ENOMEM; 1103 } else { 1104 return ret; 1105 } 1106 } 1107 1108 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev, 1109 "reset", 1110 cs35l56->index, 1111 GPIOD_OUT_LOW); 1112 if (IS_ERR(cs35l56->base.reset_gpio)) { 1113 ret = PTR_ERR(cs35l56->base.reset_gpio); 1114 1115 /* 1116 * If RESET is shared the first amp to probe will grab the reset 1117 * line and reset all the amps 1118 */ 1119 if (ret != -EBUSY) 1120 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n"); 1121 1122 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n"); 1123 cs35l56->base.reset_gpio = NULL; 1124 } 1125 1126 return 0; 1127 1128 err: 1129 if (ret != -ENODEV) 1130 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret); 1131 1132 return ret; 1133 } 1134 1135 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id) 1136 { 1137 int ret; 1138 1139 mutex_init(&cs35l56->base.irq_lock); 1140 dev_set_drvdata(cs35l56->base.dev, cs35l56); 1141 1142 INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work); 1143 1144 ret = cs35l56_hda_read_acpi(cs35l56, hid, id); 1145 if (ret) 1146 goto err; 1147 1148 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d", 1149 cs35l56->index + 1); 1150 if (!cs35l56->amp_name) { 1151 ret = -ENOMEM; 1152 goto err; 1153 } 1154 1155 cs35l56->base.type = hid & 0xff; 1156 cs35l56->base.cal_index = cs35l56->index; 1157 1158 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp); 1159 1160 if (cs35l56->base.reset_gpio) { 1161 dev_dbg(cs35l56->base.dev, "Hard reset\n"); 1162 1163 /* 1164 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the 1165 * ACPI defines a different default state. So explicitly set low. 1166 */ 1167 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1168 cs35l56_wait_min_reset_pulse(); 1169 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1); 1170 } 1171 1172 ret = cs35l56_hw_init(&cs35l56->base); 1173 if (ret < 0) 1174 goto err; 1175 1176 /* Reset the device and wait for it to boot */ 1177 cs35l56_system_reset(&cs35l56->base, false); 1178 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base); 1179 if (ret) 1180 goto err; 1181 1182 regcache_cache_only(cs35l56->base.regmap, false); 1183 1184 ret = cs35l56_set_patch(&cs35l56->base); 1185 if (ret) 1186 goto err; 1187 1188 regcache_mark_dirty(cs35l56->base.regmap); 1189 regcache_sync(cs35l56->base.regmap); 1190 1191 /* Disable auto-hibernate so that runtime_pm has control */ 1192 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE); 1193 if (ret) 1194 goto err; 1195 1196 ret = cs35l56_get_calibration(&cs35l56->base); 1197 if (ret) 1198 goto err; 1199 1200 ret = cs_dsp_halo_init(&cs35l56->cs_dsp); 1201 if (ret) { 1202 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n"); 1203 goto err; 1204 } 1205 1206 dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n", 1207 cs35l56->system_name, cs35l56->amp_name); 1208 1209 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config, 1210 ARRAY_SIZE(cs35l56_hda_dai_config)); 1211 1212 /* 1213 * By default only enable one ASP1TXn, where n=amplifier index, 1214 * This prevents multiple amps trying to drive the same slot. 1215 */ 1216 cs35l56->asp_tx_mask = BIT(cs35l56->index); 1217 1218 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000); 1219 pm_runtime_use_autosuspend(cs35l56->base.dev); 1220 pm_runtime_set_active(cs35l56->base.dev); 1221 pm_runtime_mark_last_busy(cs35l56->base.dev); 1222 pm_runtime_enable(cs35l56->base.dev); 1223 1224 cs35l56->base.init_done = true; 1225 1226 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops); 1227 if (ret) { 1228 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret); 1229 goto pm_err; 1230 } 1231 1232 return 0; 1233 1234 pm_err: 1235 pm_runtime_disable(cs35l56->base.dev); 1236 cs_dsp_remove(&cs35l56->cs_dsp); 1237 err: 1238 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1239 1240 return ret; 1241 } 1242 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56"); 1243 1244 void cs35l56_hda_remove(struct device *dev) 1245 { 1246 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev); 1247 1248 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops); 1249 1250 pm_runtime_dont_use_autosuspend(cs35l56->base.dev); 1251 pm_runtime_get_sync(cs35l56->base.dev); 1252 pm_runtime_disable(cs35l56->base.dev); 1253 1254 cs_dsp_remove(&cs35l56->cs_dsp); 1255 1256 kfree(cs35l56->system_name); 1257 pm_runtime_put_noidle(cs35l56->base.dev); 1258 1259 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0); 1260 } 1261 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56"); 1262 1263 const struct dev_pm_ops cs35l56_hda_pm_ops = { 1264 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL) 1265 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume) 1266 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late, 1267 cs35l56_hda_system_resume_early) 1268 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq, 1269 cs35l56_hda_system_resume_no_irq) 1270 }; 1271 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56"); 1272 1273 MODULE_DESCRIPTION("CS35L56 HDA Driver"); 1274 MODULE_IMPORT_NS("FW_CS_DSP"); 1275 MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC"); 1276 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED"); 1277 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB"); 1278 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 1279 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>"); 1280 MODULE_LICENSE("GPL"); 1281 MODULE_FIRMWARE("cirrus/cs35l54-*.wmfw"); 1282 MODULE_FIRMWARE("cirrus/cs35l54-*.bin"); 1283 MODULE_FIRMWARE("cirrus/cs35l56-*.wmfw"); 1284 MODULE_FIRMWARE("cirrus/cs35l56-*.bin"); 1285