Lines Matching defs:cs35l41
25 #define CS35L41_PART "cs35l41"
101 static void cs35l41_add_controls(struct cs35l41_hda *cs35l41)
105 info.device_name = cs35l41->amp_name;
106 info.fw_type = cs35l41->firmware_type;
107 info.card = cs35l41->codec->card;
109 hda_cs_dsp_add_controls(&cs35l41->cs_dsp, &info);
116 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
121 const char * const dsp_name = cs35l41->cs_dsp.name;
127 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
131 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
135 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
139 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
143 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
163 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
165 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
173 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
182 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
184 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
185 cs35l41->speaker_id, "wmfw");
188 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
190 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
191 cs35l41->speaker_id, "bin");
199 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
200 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
201 cs35l41->amp_name, -1, "wmfw");
204 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
206 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
207 cs35l41->speaker_id, "bin");
215 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
216 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
217 NULL, cs35l41->speaker_id, "wmfw");
220 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
222 cs35l41->acpi_subsystem_id,
223 cs35l41->amp_name, cs35l41->speaker_id, "bin");
226 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
228 cs35l41->acpi_subsystem_id, NULL,
229 cs35l41->speaker_id, "bin");
237 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
238 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
242 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
244 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
245 cs35l41->speaker_id, "bin");
248 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
250 cs35l41->acpi_subsystem_id, NULL,
251 cs35l41->speaker_id, "bin");
263 static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41,
272 dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
275 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
281 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
291 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
295 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
303 if (cs35l41->speaker_id > -1) {
304 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
310 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
311 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
312 cs35l41->amp_name, -1, "wmfw");
315 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
317 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
326 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
327 CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
331 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
333 cs35l41->acpi_subsystem_id,
334 cs35l41->amp_name, -1, "bin");
337 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
339 cs35l41->acpi_subsystem_id, NULL, -1,
356 return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
361 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, __be32 ambient, __be32 r0,
366 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
369 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
373 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
376 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
379 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
382 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
386 ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
389 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
397 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
422 dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
424 if (efi_data->count > cs35l41->index) {
425 cl = &efi_data->data[cs35l41->index];
426 dev_dbg(cs35l41->dev,
431 ret = cs35l41_apply_calibration(cs35l41,
443 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
445 dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
450 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
454 struct cs_dsp *dsp = &cs35l41->cs_dsp;
459 if (!cs35l41->halo_initialized) {
460 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
463 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
466 cs35l41->halo_initialized = true;
469 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
474 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
476 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
478 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
481 hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
485 cs35l41_add_controls(cs35l41);
487 ret = cs35l41_save_calibration(cs35l41);
498 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
500 struct cs_dsp *dsp = &cs35l41->cs_dsp;
504 cs35l41->firmware_running = false;
505 dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
508 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
510 struct cs_dsp *dsp = &cs35l41->cs_dsp;
512 cancel_work_sync(&cs35l41->fw_load_work);
514 mutex_lock(&cs35l41->fw_mutex);
515 cs35l41_shutdown_dsp(cs35l41);
517 cs35l41->halo_initialized = false;
518 mutex_unlock(&cs35l41->fw_mutex);
530 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
532 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
533 cs35l41->irq_errors = 0;
538 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
539 struct regmap *reg = cs35l41->regmap;
543 if (cs35l41->playback_started) {
548 cs35l41->playback_started = true;
550 if (cs35l41->firmware_running) {
556 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
561 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
568 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
569 struct regmap *reg = cs35l41->regmap;
573 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
574 cs35l41->firmware_running);
575 if (cs35l41->firmware_running) {
586 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
587 struct regmap *reg = cs35l41->regmap;
592 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
593 cs35l41->firmware_running);
598 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
599 struct regmap *reg = cs35l41->regmap;
604 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
606 if (cs35l41->firmware_running) {
612 cs35l41_irq_release(cs35l41);
613 cs35l41->playback_started = false;
618 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
622 mutex_lock(&cs35l41->fw_mutex);
624 mutex_unlock(&cs35l41->fw_mutex);
632 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
645 mutex_lock(&cs35l41->fw_mutex);
647 mutex_unlock(&cs35l41->fw_mutex);
650 mutex_lock(&cs35l41->fw_mutex);
652 mutex_unlock(&cs35l41->fw_mutex);
655 mutex_lock(&cs35l41->fw_mutex);
656 if (!cs35l41->firmware_running && cs35l41->request_fw_load &&
657 !cs35l41->fw_request_ongoing) {
659 cs35l41->fw_request_ongoing = true;
660 schedule_work(&cs35l41->fw_load_work);
662 mutex_unlock(&cs35l41->fw_mutex);
678 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
682 mutex_lock(&cs35l41->fw_mutex);
684 mutex_unlock(&cs35l41->fw_mutex);
694 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
697 if (!cs35l41->amp_name) {
701 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
702 channel_name[*rx_slot], cs35l41->channel_index);
703 if (!cs35l41->amp_name)
707 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
711 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
715 mutex_lock(&cs35l41->fw_mutex);
716 if (cs35l41->firmware_running) {
718 regcache_cache_only(cs35l41->regmap, false);
720 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
722 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
727 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
728 ret = regcache_sync(cs35l41->regmap);
729 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
731 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
735 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
736 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
738 cs35l41_shutdown_dsp(cs35l41);
739 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
742 regcache_cache_only(cs35l41->regmap, true);
743 regcache_mark_dirty(cs35l41->regmap);
745 mutex_unlock(&cs35l41->fw_mutex);
752 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
754 dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
756 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
757 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
761 mutex_lock(&cs35l41->fw_mutex);
762 if (cs35l41->playback_started)
764 mutex_unlock(&cs35l41->fw_mutex);
771 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
774 dev_dbg(cs35l41->dev, "System Suspend\n");
776 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
777 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
781 mutex_lock(&cs35l41->fw_mutex);
782 if (cs35l41->playback_started)
784 mutex_unlock(&cs35l41->fw_mutex);
793 ret = cs35l41_ready_for_reset(cs35l41);
807 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
810 dev_dbg(cs35l41->dev, "System Resume\n");
812 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
813 dev_err_once(cs35l41->dev, "System Resume not supported\n");
817 if (cs35l41->reset_gpio) {
819 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
830 mutex_lock(&cs35l41->fw_mutex);
832 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
833 cs35l41->fw_request_ongoing = true;
834 schedule_work(&cs35l41->fw_load_work);
836 mutex_unlock(&cs35l41->fw_mutex);
843 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
845 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
852 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
855 dev_dbg(cs35l41->dev, "Runtime Suspend\n");
857 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
858 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
862 mutex_lock(&cs35l41->fw_mutex);
864 if (cs35l41->firmware_running) {
865 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
866 cs35l41->hw_cfg.bst_type);
870 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
873 regcache_cache_only(cs35l41->regmap, true);
874 regcache_mark_dirty(cs35l41->regmap);
877 mutex_unlock(&cs35l41->fw_mutex);
884 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
887 dev_dbg(cs35l41->dev, "Runtime Resume\n");
889 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
890 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
894 mutex_lock(&cs35l41->fw_mutex);
896 regcache_cache_only(cs35l41->regmap, false);
898 if (cs35l41->firmware_running) {
899 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
901 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
907 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
908 ret = regcache_sync(cs35l41->regmap);
909 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
911 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
915 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
916 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
919 mutex_unlock(&cs35l41->fw_mutex);
924 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
929 ret = cs35l41_init_dsp(cs35l41);
931 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
935 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
937 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
941 ret = cs_dsp_run(&cs35l41->cs_dsp);
943 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
949 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
954 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
959 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
961 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
965 cs35l41->firmware_running = true;
970 cs35l41_shutdown_dsp(cs35l41);
974 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
976 if (cs35l41->firmware_running && !load) {
977 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
978 cs35l41_shutdown_dsp(cs35l41);
979 } else if (!cs35l41->firmware_running && load) {
980 dev_dbg(cs35l41->dev, "Loading Firmware\n");
981 cs35l41_smart_amp(cs35l41);
983 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
990 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
992 ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
998 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
1000 pm_runtime_get_sync(cs35l41->dev);
1002 mutex_lock(&cs35l41->fw_mutex);
1005 if (cs35l41->playback_started)
1006 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
1008 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
1010 cs35l41->fw_request_ongoing = false;
1011 mutex_unlock(&cs35l41->fw_mutex);
1013 pm_runtime_mark_last_busy(cs35l41->dev);
1014 pm_runtime_put_autosuspend(cs35l41->dev);
1020 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1022 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
1025 if (cs35l41->fw_request_ongoing) {
1026 dev_dbg(cs35l41->dev, "Existing request not complete\n");
1031 if (cs35l41->playback_started) {
1032 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
1036 cs35l41->fw_request_ongoing = true;
1037 cs35l41->request_fw_load = ucontrol->value.integer.value[0];
1038 schedule_work(&cs35l41->fw_load_work);
1046 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1048 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
1056 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1059 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
1060 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
1075 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
1096 cs35l41->amp_name);
1098 cs35l41->amp_name);
1100 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
1102 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
1106 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
1108 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
1110 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
1114 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
1121 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1126 if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
1129 comps = &comps[cs35l41->index];
1135 mutex_lock(&cs35l41->fw_mutex);
1138 if (!cs35l41->acpi_subsystem_id)
1139 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1141 cs35l41->codec = comps->codec;
1144 cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
1147 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1148 cs35l41->request_fw_load = true;
1149 if (cs35l41_smart_amp(cs35l41) < 0)
1150 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1152 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1155 ret = cs35l41_create_controls(cs35l41);
1161 mutex_unlock(&cs35l41->fw_mutex);
1164 if (!device_link_add(&comps->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1171 dev_info(cs35l41->dev,
1173 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1174 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1175 cs35l41->hw_cfg.spk_pos ? 'R' : 'L',
1176 cs35l41->firmware_running, cs35l41->speaker_id);
1183 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1187 if (comps[cs35l41->index].dev == dev) {
1188 memset(&comps[cs35l41->index], 0, sizeof(*comps));
1190 device_link_remove(&comps->codec->core.dev, cs35l41->dev);
1202 struct cs35l41_hda *cs35l41 = data;
1204 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1205 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1212 struct cs35l41_hda *cs35l41 = data;
1214 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1215 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1222 struct cs35l41_hda *cs35l41 = data;
1224 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1225 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1232 struct cs35l41_hda *cs35l41 = data;
1234 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1235 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1242 struct cs35l41_hda *cs35l41 = data;
1244 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1245 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1252 struct cs35l41_hda *cs35l41 = data;
1254 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1255 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1279 .name = "cs35l41 IRQ1 Controller",
1289 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1291 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1297 if (!cs35l41->hw_cfg.valid)
1300 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1316 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1331 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1336 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1338 if (cs35l41->irq && using_irq) {
1339 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1341 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1346 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1350 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1353 cs35l41_irqs[i].name, cs35l41);
1359 return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos);
1416 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1418 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1429 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1439 cs35l41->acpi_subsystem_id = sub;
1441 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1443 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1462 cs35l41->index = -1;
1465 cs35l41->index = i;
1469 if (cs35l41->index == -1) {
1470 dev_err(cs35l41->dev, "No index found in %s\n", property);
1478 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1479 GPIOD_OUT_LOW, "cs35l41-reset");
1485 hw_cfg->spk_pos = values[cs35l41->index];
1487 cs35l41->channel_index = 0;
1488 for (i = 0; i < cs35l41->index; i++)
1490 cs35l41->channel_index++;
1496 hw_cfg->gpio1.func = values[cs35l41->index];
1503 hw_cfg->gpio2.func = values[cs35l41->index];
1509 hw_cfg->bst_ipk = values[cs35l41->index];
1516 hw_cfg->bst_ind = values[cs35l41->index];
1523 hw_cfg->bst_cap = values[cs35l41->index];
1527 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1540 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1554 struct cs35l41_hda *cs35l41;
1563 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1564 if (!cs35l41)
1567 cs35l41->dev = dev;
1568 cs35l41->irq = irq;
1569 cs35l41->regmap = regmap;
1570 dev_set_drvdata(dev, cs35l41);
1572 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1574 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1576 if (IS_ERR(cs35l41->reset_gpio)) {
1577 ret = PTR_ERR(cs35l41->reset_gpio);
1578 cs35l41->reset_gpio = NULL;
1580 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1582 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1586 if (cs35l41->reset_gpio) {
1588 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1593 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
1596 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1600 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts);
1602 dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n",
1608 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, ®id);
1610 dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1614 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, ®_revid);
1616 dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1624 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid);
1629 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1633 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1637 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1639 dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1643 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1647 ret = regmap_multi_reg_write(cs35l41->regmap, cs35l41_hda_mute,
1652 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1653 mutex_init(&cs35l41->fw_mutex);
1655 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1656 pm_runtime_use_autosuspend(cs35l41->dev);
1657 pm_runtime_mark_last_busy(cs35l41->dev);
1658 pm_runtime_set_active(cs35l41->dev);
1659 pm_runtime_get_noresume(cs35l41->dev);
1660 pm_runtime_enable(cs35l41->dev);
1662 ret = cs35l41_hda_apply_properties(cs35l41);
1666 pm_runtime_put_autosuspend(cs35l41->dev);
1668 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1670 dev_err(cs35l41->dev, "Register component failed: %d\n", ret);
1674 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
1679 pm_runtime_dont_use_autosuspend(cs35l41->dev);
1680 pm_runtime_disable(cs35l41->dev);
1681 pm_runtime_put_noidle(cs35l41->dev);
1684 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1685 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1686 gpiod_put(cs35l41->reset_gpio);
1687 kfree(cs35l41->acpi_subsystem_id);
1695 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1697 pm_runtime_get_sync(cs35l41->dev);
1698 pm_runtime_dont_use_autosuspend(cs35l41->dev);
1699 pm_runtime_disable(cs35l41->dev);
1701 if (cs35l41->halo_initialized)
1702 cs35l41_remove_dsp(cs35l41);
1704 component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
1706 pm_runtime_put_noidle(cs35l41->dev);
1708 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1709 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1710 gpiod_put(cs35l41->reset_gpio);
1711 kfree(cs35l41->acpi_subsystem_id);