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