Lines Matching defs:cs35l41
25 #define CS35L41_PART "cs35l41"
143 static int cs35l41_request_tuning_param_file(struct cs35l41_hda *cs35l41, char *tuning_filename,
154 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
156 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
164 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
169 const char * const dsp_name = cs35l41->cs_dsp.name;
175 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type],
179 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type],
183 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type],
187 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type],
191 dsp_name, cs35l41_hda_fw_ids[cs35l41->firmware_type],
211 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
213 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
221 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
230 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
231 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
232 cs35l41->speaker_id, "wmfw");
235 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
236 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
237 cs35l41->speaker_id, "bin");
245 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
246 cs35l41->acpi_subsystem_id,
247 cs35l41->amp_name, -1, "wmfw");
250 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
251 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
252 cs35l41->speaker_id, "bin");
260 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
261 cs35l41->acpi_subsystem_id,
262 NULL, cs35l41->speaker_id, "wmfw");
265 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
266 cs35l41->acpi_subsystem_id,
267 cs35l41->amp_name, cs35l41->speaker_id, "bin");
270 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
272 cs35l41->acpi_subsystem_id, NULL,
273 cs35l41->speaker_id, "bin");
281 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
282 cs35l41->acpi_subsystem_id,
286 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
287 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
288 cs35l41->speaker_id, "bin");
291 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
293 cs35l41->acpi_subsystem_id, NULL,
294 cs35l41->speaker_id, "bin");
306 static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41,
315 dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
318 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
324 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
334 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
338 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
346 if (cs35l41->speaker_id > -1) {
347 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
353 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
354 cs35l41->acpi_subsystem_id,
355 cs35l41->amp_name, -1, "wmfw");
358 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
359 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
368 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
369 cs35l41->acpi_subsystem_id,
373 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
374 cs35l41->acpi_subsystem_id,
375 cs35l41->amp_name, -1, "bin");
378 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
379 cs35l41->acpi_subsystem_id, NULL, -1,
396 return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
401 static void cs35l41_hda_apply_calibration(struct cs35l41_hda *cs35l41)
405 if (!cs35l41->cal_data_valid)
408 ret = cs_amp_write_cal_coeffs(&cs35l41->cs_dsp, &cs35l41_calibration_controls,
409 &cs35l41->cal_data);
411 dev_warn(cs35l41->dev, "Failed to apply calibration: %d\n", ret);
413 dev_info(cs35l41->dev, "Calibration applied: R0=%d\n", cs35l41->cal_data.calR);
416 static int cs35l41_read_silicon_uid(struct cs35l41_hda *cs35l41, u64 *uid)
421 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS2, &tmp);
423 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS2: %d\n", ret);
430 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS1, &tmp);
432 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS1: %d\n", ret);
438 dev_dbg(cs35l41->dev, "UniqueID = %#llx\n", *uid);
443 static int cs35l41_get_calibration(struct cs35l41_hda *cs35l41)
448 ret = cs35l41_read_silicon_uid(cs35l41, &silicon_uid);
452 ret = cs_amp_get_efi_calibration_data(cs35l41->dev, silicon_uid,
453 cs35l41->index,
454 &cs35l41->cal_data);
463 cs35l41->cal_data_valid = true;
469 static void cs35l41_set_default_tuning_params(struct cs35l41_hda *cs35l41)
471 cs35l41->tuning_gain = DEFAULT_AMP_GAIN_PCM;
474 static int cs35l41_read_tuning_params(struct cs35l41_hda *cs35l41, const struct firmware *firmware)
484 dev_err(cs35l41->dev, "Wrong Size for Tuning Param file. Expected %d got %zu\n",
490 dev_err(cs35l41->dev, "Unsupported Tuning Param Version: %d\n",
496 dev_err(cs35l41->dev,
518 cs35l41->tuning_gain = le32_to_cpu(param->gain);
519 dev_dbg(cs35l41->dev, "Applying Gain: %d\n", cs35l41->tuning_gain);
529 static int cs35l41_load_tuning_params(struct cs35l41_hda *cs35l41, char *tuning_filename)
535 ret = cs35l41_request_tuning_param_file(cs35l41, tuning_filename, &tuning_param_file,
536 &tuning_param_filename, cs35l41->acpi_subsystem_id);
538 dev_dbg(cs35l41->dev, "Missing Tuning Param for file: %s: %d\n", tuning_filename,
543 ret = cs35l41_read_tuning_params(cs35l41, tuning_param_file);
545 dev_err(cs35l41->dev, "Error reading Tuning Params from file: %s: %d\n",
548 cs35l41_set_default_tuning_params(cs35l41);
557 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
561 struct cs_dsp *dsp = &cs35l41->cs_dsp;
566 if (!cs35l41->halo_initialized) {
567 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
570 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
573 cs35l41->halo_initialized = true;
576 cs35l41_set_default_tuning_params(cs35l41);
578 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
583 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
585 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
586 ret = cs35l41_load_tuning_params(cs35l41, coeff_filename);
588 dev_warn(cs35l41->dev, "Unable to load Tuning Parameters: %d\n", ret);
590 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
594 cs35l41_hda_fw_ids[cs35l41->firmware_type]);
598 cs35l41_hda_apply_calibration(cs35l41);
602 cs35l41_set_default_tuning_params(cs35l41);
611 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
613 struct cs_dsp *dsp = &cs35l41->cs_dsp;
615 cs35l41_set_default_tuning_params(cs35l41);
618 dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
621 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
623 struct cs_dsp *dsp = &cs35l41->cs_dsp;
625 cancel_work_sync(&cs35l41->fw_load_work);
627 guard(mutex)(&cs35l41->fw_mutex);
628 cs35l41_shutdown_dsp(cs35l41);
630 cs35l41->halo_initialized = false;
642 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
644 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
645 cs35l41->irq_errors = 0;
648 static void cs35l41_update_mixer(struct cs35l41_hda *cs35l41)
650 struct regmap *reg = cs35l41->regmap;
656 if (cs35l41->cs_dsp.running) {
660 if (cs35l41->hw_cfg.bst_type == CS35L41_INT_BOOST)
669 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER) {
685 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
686 struct regmap *reg = cs35l41->regmap;
690 if (cs35l41->playback_started) {
695 cs35l41->playback_started = true;
697 cs35l41_update_mixer(cs35l41);
699 if (cs35l41->cs_dsp.running) {
703 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
706 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
713 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
714 struct regmap *reg = cs35l41->regmap;
717 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override,
718 cs35l41->playback_started);
720 if (cs35l41->playback_started) {
721 if (mute || cs35l41->mute_override) {
726 if (cs35l41->cs_dsp.running) {
727 dev_dbg(dev, "Using Tuned Gain: %d\n", cs35l41->tuning_gain);
728 amp_gain = (cs35l41->tuning_gain << CS35L41_AMP_GAIN_PCM_SHIFT) |
744 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
745 struct regmap *reg = cs35l41->regmap;
749 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
750 &cs35l41->cs_dsp);
756 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
757 struct regmap *reg = cs35l41->regmap;
762 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
763 &cs35l41->cs_dsp);
768 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
769 struct regmap *reg = cs35l41->regmap;
774 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
776 if (cs35l41->cs_dsp.running) {
782 cs35l41_irq_release(cs35l41);
783 cs35l41->playback_started = false;
788 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
792 scoped_guard(mutex, &cs35l41->fw_mutex) {
802 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
815 scoped_guard(mutex, &cs35l41->fw_mutex) {
820 scoped_guard(mutex, &cs35l41->fw_mutex) {
825 scoped_guard(mutex, &cs35l41->fw_mutex) {
826 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load &&
827 !cs35l41->fw_request_ongoing) {
829 cs35l41->fw_request_ongoing = true;
830 schedule_work(&cs35l41->fw_load_work);
847 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
851 scoped_guard(mutex, &cs35l41->fw_mutex) {
860 static int cs35l41_hda_channel_map(struct cs35l41_hda *cs35l41)
868 if (!cs35l41->amp_name) {
869 if (cs35l41->hw_cfg.spk_pos >= ARRAY_SIZE(channel_name))
872 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%c%d",
873 channel_name[cs35l41->hw_cfg.spk_pos],
874 cs35l41->channel_index);
875 if (!cs35l41->amp_name)
880 if (cs35l41->hw_cfg.spk_pos == CS35L41_CENTER)
883 rx_slot = &cs35l41->hw_cfg.spk_pos;
885 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
889 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid)
894 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid);
896 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
900 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid);
902 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
910 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid);
917 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
919 guard(mutex)(&cs35l41->fw_mutex);
920 if (cs35l41->cs_dsp.running) {
921 cs35l41->cs_dsp.running = false;
922 cs35l41->cs_dsp.booted = false;
924 regcache_mark_dirty(cs35l41->regmap);
931 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
933 dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
935 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
936 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
940 guard(mutex)(&cs35l41->fw_mutex);
941 if (cs35l41->playback_started)
949 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
952 dev_dbg(cs35l41->dev, "System Suspend\n");
954 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
955 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
959 scoped_guard(mutex, &cs35l41->fw_mutex) {
960 if (cs35l41->playback_started)
971 ret = cs35l41_ready_for_reset(cs35l41);
975 if (cs35l41->reset_gpio) {
976 dev_info(cs35l41->dev, "Asserting Reset\n");
977 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
981 dev_dbg(cs35l41->dev, "System Suspended\n");
986 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41)
991 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
994 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n");
998 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status);
1000 dev_err(cs35l41->dev, "OTP Boot status %x error\n",
1012 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1015 dev_dbg(cs35l41->dev, "System Resume\n");
1017 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1018 dev_err_once(cs35l41->dev, "System Resume not supported\n");
1022 if (cs35l41->reset_gpio) {
1023 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1025 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1030 regcache_cache_only(cs35l41->regmap, false);
1032 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1035 ret = cs35l41_wait_boot_done(cs35l41);
1039 regcache_cache_only(cs35l41->regmap, true);
1047 guard(mutex)(&cs35l41->fw_mutex);
1049 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
1050 cs35l41->fw_request_ongoing = true;
1051 schedule_work(&cs35l41->fw_load_work);
1059 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1061 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
1068 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1071 dev_dbg(cs35l41->dev, "Runtime Suspend\n");
1073 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1074 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
1078 guard(mutex)(&cs35l41->fw_mutex);
1080 if (cs35l41->cs_dsp.running) {
1081 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
1082 cs35l41->hw_cfg.bst_type);
1086 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
1089 regcache_cache_only(cs35l41->regmap, true);
1090 regcache_mark_dirty(cs35l41->regmap);
1097 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1101 dev_dbg(cs35l41->dev, "Runtime Resume\n");
1103 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1104 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
1108 guard(mutex)(&cs35l41->fw_mutex);
1110 regcache_cache_only(cs35l41->regmap, false);
1112 if (cs35l41->cs_dsp.running) {
1113 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
1115 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
1120 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1125 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1126 ret = regcache_sync(cs35l41->regmap);
1127 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1129 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
1133 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
1134 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
1136 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid);
1148 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
1154 if (cs35l41->bypass_fw) {
1155 dev_warn(cs35l41->dev, "Bypassing Firmware.\n");
1159 ret = cs35l41_init_dsp(cs35l41);
1161 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
1165 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
1167 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
1171 ret = cs_dsp_run(&cs35l41->cs_dsp);
1173 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
1179 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
1184 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
1189 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status);
1191 dev_err(cs35l41->dev,
1201 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n",
1207 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
1209 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
1213 dev_info(cs35l41->dev, "Firmware Loaded - Type: %s, Gain: %d\n",
1214 cs35l41_hda_fw_ids[cs35l41->firmware_type], cs35l41->tuning_gain);
1219 cs35l41_shutdown_dsp(cs35l41);
1223 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
1225 if (cs35l41->cs_dsp.running && !load) {
1226 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
1227 cs35l41_shutdown_dsp(cs35l41);
1228 } else if (!cs35l41->cs_dsp.running && load) {
1229 dev_dbg(cs35l41->dev, "Loading Firmware\n");
1230 cs35l41_smart_amp(cs35l41);
1232 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
1239 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1241 ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
1248 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1250 ucontrol->value.integer.value[0] = cs35l41->mute_override;
1256 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
1258 pm_runtime_get_sync(cs35l41->dev);
1260 scoped_guard(mutex, &cs35l41->fw_mutex) {
1262 if (cs35l41->playback_started)
1263 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
1265 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
1267 cs35l41->fw_request_ongoing = false;
1270 pm_runtime_put_autosuspend(cs35l41->dev);
1276 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1278 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
1281 if (cs35l41->fw_request_ongoing) {
1282 dev_dbg(cs35l41->dev, "Existing request not complete\n");
1287 if (cs35l41->playback_started) {
1288 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
1292 cs35l41->fw_request_ongoing = true;
1293 cs35l41->request_fw_load = ucontrol->value.integer.value[0];
1294 schedule_work(&cs35l41->fw_load_work);
1302 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1304 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
1312 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1315 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
1316 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
1331 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
1360 cs35l41->amp_name);
1362 cs35l41->amp_name);
1364 cs35l41->amp_name);
1366 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
1368 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
1372 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
1374 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
1376 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
1380 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
1382 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41));
1384 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name,
1389 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name);
1403 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle)
1416 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute);
1419 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute);
1426 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1432 mute = cs35l41_get_acpi_mute_state(cs35l41, handle);
1434 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute);
1438 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute);
1439 cs35l41->mute_override = (mute > 0);
1440 cs35l41_mute(cs35l41->dev, cs35l41->mute_override);
1445 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1451 comp = hda_component_from_index(parent, cs35l41->index);
1460 mutex_lock(&cs35l41->fw_mutex);
1463 cs35l41->codec = parent->codec;
1464 if (!cs35l41->acpi_subsystem_id)
1465 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1466 cs35l41->codec->core.subsystem_id);
1470 cs35l41->firmware_type = CS35L41_HDA_FW_SPK_PROT;
1473 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1474 cs35l41->request_fw_load = true;
1475 if (cs35l41_smart_amp(cs35l41) < 0)
1476 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1478 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1481 ret = cs35l41_create_controls(cs35l41);
1487 comp->adev = cs35l41->dacpi;
1492 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41,
1493 acpi_device_handle(cs35l41->dacpi)) > 0;
1495 mutex_unlock(&cs35l41->fw_mutex);
1498 if (!device_link_add(&cs35l41->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1504 dev_info(cs35l41->dev,
1506 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1507 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1508 channel_name[cs35l41->hw_cfg.spk_pos],
1509 cs35l41->cs_dsp.running, cs35l41->speaker_id);
1516 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1521 comp = hda_component_from_index(parent, cs35l41->index);
1527 device_link_remove(&cs35l41->codec->core.dev, cs35l41->dev);
1540 struct cs35l41_hda *cs35l41 = data;
1542 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1543 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1550 struct cs35l41_hda *cs35l41 = data;
1552 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1553 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1560 struct cs35l41_hda *cs35l41 = data;
1562 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1563 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1570 struct cs35l41_hda *cs35l41 = data;
1572 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1573 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1580 struct cs35l41_hda *cs35l41 = data;
1582 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1583 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1590 struct cs35l41_hda *cs35l41 = data;
1592 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1593 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1617 .name = "cs35l41 IRQ1 Controller",
1627 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol)
1633 if (!cs35l41->irq) {
1634 dev_warn(cs35l41->dev, "No Interrupt Found");
1638 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1640 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1642 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret);
1647 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1650 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name,
1655 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1658 cs35l41_irqs[i].name, cs35l41);
1660 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.",
1667 dev_warn(cs35l41->dev,
1671 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1673 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1678 if (!cs35l41->hw_cfg.valid)
1681 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1697 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1712 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1717 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1720 cs35l41_configure_interrupt(cs35l41, irq_pol);
1722 return cs35l41_hda_channel_map(cs35l41);
1779 int cs35l41_hda_parse_acpi(struct cs35l41_hda *cs35l41, struct device *physdev, int id)
1781 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1802 cs35l41->index = -1;
1805 cs35l41->index = i;
1809 if (cs35l41->index == -1) {
1810 dev_err(cs35l41->dev, "No index found in %s\n", property);
1818 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(cs35l41->dacpi), "reset",
1819 cs35l41->index, GPIOD_OUT_LOW,
1820 "cs35l41-reset");
1826 hw_cfg->spk_pos = values[cs35l41->index];
1828 cs35l41->channel_index = 0;
1829 for (i = 0; i < cs35l41->index; i++)
1831 cs35l41->channel_index++;
1837 hw_cfg->gpio1.func = values[cs35l41->index];
1844 hw_cfg->gpio2.func = values[cs35l41->index];
1850 hw_cfg->bst_ipk = values[cs35l41->index];
1857 hw_cfg->bst_ind = values[cs35l41->index];
1864 hw_cfg->bst_cap = values[cs35l41->index];
1868 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1879 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1883 acpi_dev_put(cs35l41->dacpi);
1888 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1898 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1902 cs35l41->dacpi = adev;
1908 cs35l41->acpi_subsystem_id = sub;
1910 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1912 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1916 ret = cs35l41_hda_parse_acpi(cs35l41, physdev, id);
1924 cs35l41->bypass_fw = false;
1925 if (cs35l41->control_bus == SPI) {
1926 spi = to_spi_device(cs35l41->dev);
1928 dev_warn(cs35l41->dev,
1931 cs35l41->bypass_fw = true;
1942 struct cs35l41_hda *cs35l41;
1951 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1952 if (!cs35l41)
1955 cs35l41->dev = dev;
1956 cs35l41->irq = irq;
1957 cs35l41->regmap = regmap;
1958 cs35l41->control_bus = control_bus;
1959 dev_set_drvdata(dev, cs35l41);
1961 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1963 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1965 if (IS_ERR(cs35l41->reset_gpio)) {
1966 ret = PTR_ERR(cs35l41->reset_gpio);
1967 cs35l41->reset_gpio = NULL;
1969 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1971 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1975 if (cs35l41->reset_gpio) {
1976 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1978 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1982 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1985 ret = cs35l41_wait_boot_done(cs35l41);
1989 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1993 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1997 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
2001 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
2003 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
2007 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
2011 ret = cs35l41_get_calibration(cs35l41);
2015 cs35l41_mute(cs35l41->dev, true);
2017 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
2018 mutex_init(&cs35l41->fw_mutex);
2020 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
2021 pm_runtime_use_autosuspend(cs35l41->dev);
2022 pm_runtime_set_active(cs35l41->dev);
2023 pm_runtime_get_noresume(cs35l41->dev);
2024 pm_runtime_enable(cs35l41->dev);
2026 ret = cs35l41_hda_apply_properties(cs35l41);
2030 pm_runtime_put_autosuspend(cs35l41->dev);
2032 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
2034 dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
2038 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
2043 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2044 pm_runtime_disable(cs35l41->dev);
2045 pm_runtime_put_noidle(cs35l41->dev);
2048 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2049 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2050 gpiod_put(cs35l41->reset_gpio);
2051 gpiod_put(cs35l41->cs_gpio);
2052 acpi_dev_put(cs35l41->dacpi);
2053 kfree(cs35l41->acpi_subsystem_id);
2061 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
2063 component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
2065 pm_runtime_get_sync(cs35l41->dev);
2066 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2067 pm_runtime_disable(cs35l41->dev);
2069 if (cs35l41->halo_initialized)
2070 cs35l41_remove_dsp(cs35l41);
2072 acpi_dev_put(cs35l41->dacpi);
2074 pm_runtime_put_noidle(cs35l41->dev);
2076 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2077 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2078 gpiod_put(cs35l41->reset_gpio);
2079 gpiod_put(cs35l41->cs_gpio);
2080 kfree(cs35l41->acpi_subsystem_id);
2097 MODULE_FIRMWARE("cirrus/cs35l41-*.wmfw");
2098 MODULE_FIRMWARE("cirrus/cs35l41-*.bin");