Lines Matching defs:cs35l41
26 #define CS35L41_PART "cs35l41"
136 static void cs35l41_add_controls(struct cs35l41_hda *cs35l41)
140 info.device_name = cs35l41->amp_name;
141 info.fw_type = cs35l41->firmware_type;
142 info.card = cs35l41->codec->card;
144 hda_cs_dsp_add_controls(&cs35l41->cs_dsp, &info);
151 static int cs35l41_request_tuning_param_file(struct cs35l41_hda *cs35l41, char *tuning_filename,
162 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
164 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
172 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
177 const char * const dsp_name = cs35l41->cs_dsp.name;
183 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
187 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
191 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
195 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
199 dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
219 ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
221 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
229 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
238 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
239 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
240 cs35l41->speaker_id, "wmfw");
243 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
244 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
245 cs35l41->speaker_id, "bin");
253 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
254 cs35l41->acpi_subsystem_id,
255 cs35l41->amp_name, -1, "wmfw");
258 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
259 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
260 cs35l41->speaker_id, "bin");
268 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
269 cs35l41->acpi_subsystem_id,
270 NULL, cs35l41->speaker_id, "wmfw");
273 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
274 cs35l41->acpi_subsystem_id,
275 cs35l41->amp_name, cs35l41->speaker_id, "bin");
278 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
280 cs35l41->acpi_subsystem_id, NULL,
281 cs35l41->speaker_id, "bin");
289 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
290 cs35l41->acpi_subsystem_id,
294 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
295 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
296 cs35l41->speaker_id, "bin");
299 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware,
301 cs35l41->acpi_subsystem_id, NULL,
302 cs35l41->speaker_id, "bin");
314 static int cs35l41_fallback_firmware_file(struct cs35l41_hda *cs35l41,
323 dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
326 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
332 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
342 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
346 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
354 if (cs35l41->speaker_id > -1) {
355 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
361 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
362 cs35l41->acpi_subsystem_id,
363 cs35l41->amp_name, -1, "wmfw");
366 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
367 cs35l41->acpi_subsystem_id, cs35l41->amp_name,
376 ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
377 cs35l41->acpi_subsystem_id,
381 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
382 cs35l41->acpi_subsystem_id,
383 cs35l41->amp_name, -1, "bin");
386 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
387 cs35l41->acpi_subsystem_id, NULL, -1,
404 return cs35l41_fallback_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
409 static void cs35l41_hda_apply_calibration(struct cs35l41_hda *cs35l41)
413 if (!cs35l41->cal_data_valid)
416 ret = cs_amp_write_cal_coeffs(&cs35l41->cs_dsp, &cs35l41_calibration_controls,
417 &cs35l41->cal_data);
419 dev_warn(cs35l41->dev, "Failed to apply calibration: %d\n", ret);
421 dev_info(cs35l41->dev, "Calibration applied: R0=%d\n", cs35l41->cal_data.calR);
424 static int cs35l41_read_silicon_uid(struct cs35l41_hda *cs35l41, u64 *uid)
429 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS2, &tmp);
431 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS2: %d\n", ret);
438 ret = regmap_read(cs35l41->regmap, CS35L41_DIE_STS1, &tmp);
440 dev_err(cs35l41->dev, "Cannot obtain CS35L41_DIE_STS1: %d\n", ret);
446 dev_dbg(cs35l41->dev, "UniqueID = %#llx\n", *uid);
451 static int cs35l41_get_calibration(struct cs35l41_hda *cs35l41)
456 ret = cs35l41_read_silicon_uid(cs35l41, &silicon_uid);
460 ret = cs_amp_get_efi_calibration_data(cs35l41->dev, silicon_uid,
461 cs35l41->index,
462 &cs35l41->cal_data);
471 cs35l41->cal_data_valid = true;
477 static void cs35l41_set_default_tuning_params(struct cs35l41_hda *cs35l41)
479 cs35l41->tuning_gain = DEFAULT_AMP_GAIN_PCM;
482 static int cs35l41_read_tuning_params(struct cs35l41_hda *cs35l41, const struct firmware *firmware)
492 dev_err(cs35l41->dev, "Wrong Size for Tuning Param file. Expected %d got %zu\n",
498 dev_err(cs35l41->dev, "Unsupported Tuning Param Version: %d\n",
504 dev_err(cs35l41->dev,
526 cs35l41->tuning_gain = le32_to_cpu(param->gain);
527 dev_dbg(cs35l41->dev, "Applying Gain: %d\n", cs35l41->tuning_gain);
537 static int cs35l41_load_tuning_params(struct cs35l41_hda *cs35l41, char *tuning_filename)
543 ret = cs35l41_request_tuning_param_file(cs35l41, tuning_filename, &tuning_param_file,
544 &tuning_param_filename, cs35l41->acpi_subsystem_id);
546 dev_dbg(cs35l41->dev, "Missing Tuning Param for file: %s: %d\n", tuning_filename,
551 ret = cs35l41_read_tuning_params(cs35l41, tuning_param_file);
553 dev_err(cs35l41->dev, "Error reading Tuning Params from file: %s: %d\n",
556 cs35l41_set_default_tuning_params(cs35l41);
565 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
569 struct cs_dsp *dsp = &cs35l41->cs_dsp;
574 if (!cs35l41->halo_initialized) {
575 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
578 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
581 cs35l41->halo_initialized = true;
584 cs35l41_set_default_tuning_params(cs35l41);
586 ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
591 dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
593 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
594 ret = cs35l41_load_tuning_params(cs35l41, coeff_filename);
596 dev_warn(cs35l41->dev, "Unable to load Tuning Parameters: %d\n", ret);
598 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
602 hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
606 cs35l41_add_controls(cs35l41);
608 cs35l41_hda_apply_calibration(cs35l41);
612 cs35l41_set_default_tuning_params(cs35l41);
621 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
623 struct cs_dsp *dsp = &cs35l41->cs_dsp;
625 cs35l41_set_default_tuning_params(cs35l41);
628 dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
631 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
633 struct cs_dsp *dsp = &cs35l41->cs_dsp;
635 cancel_work_sync(&cs35l41->fw_load_work);
637 mutex_lock(&cs35l41->fw_mutex);
638 cs35l41_shutdown_dsp(cs35l41);
640 cs35l41->halo_initialized = false;
641 mutex_unlock(&cs35l41->fw_mutex);
653 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
655 cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
656 cs35l41->irq_errors = 0;
661 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
662 struct regmap *reg = cs35l41->regmap;
666 if (cs35l41->playback_started) {
671 cs35l41->playback_started = true;
673 if (cs35l41->cs_dsp.running) {
676 if (cs35l41->hw_cfg.bst_type == CS35L41_INT_BOOST)
683 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
688 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
695 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
696 struct regmap *reg = cs35l41->regmap;
699 dev_dbg(dev, "Mute(%d:%d) Playback Started: %d\n", mute, cs35l41->mute_override,
700 cs35l41->playback_started);
702 if (cs35l41->playback_started) {
703 if (mute || cs35l41->mute_override) {
708 if (cs35l41->cs_dsp.running) {
709 dev_dbg(dev, "Using Tuned Gain: %d\n", cs35l41->tuning_gain);
710 amp_gain = (cs35l41->tuning_gain << CS35L41_AMP_GAIN_PCM_SHIFT) |
726 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
727 struct regmap *reg = cs35l41->regmap;
731 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
732 &cs35l41->cs_dsp);
738 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
739 struct regmap *reg = cs35l41->regmap;
744 cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
745 &cs35l41->cs_dsp);
750 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
751 struct regmap *reg = cs35l41->regmap;
756 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
758 if (cs35l41->cs_dsp.running) {
764 cs35l41_irq_release(cs35l41);
765 cs35l41->playback_started = false;
770 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
774 mutex_lock(&cs35l41->fw_mutex);
776 mutex_unlock(&cs35l41->fw_mutex);
784 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
797 mutex_lock(&cs35l41->fw_mutex);
799 mutex_unlock(&cs35l41->fw_mutex);
802 mutex_lock(&cs35l41->fw_mutex);
804 mutex_unlock(&cs35l41->fw_mutex);
807 mutex_lock(&cs35l41->fw_mutex);
808 if (!cs35l41->cs_dsp.running && cs35l41->request_fw_load &&
809 !cs35l41->fw_request_ongoing) {
811 cs35l41->fw_request_ongoing = true;
812 schedule_work(&cs35l41->fw_load_work);
814 mutex_unlock(&cs35l41->fw_mutex);
830 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
834 mutex_lock(&cs35l41->fw_mutex);
836 mutex_unlock(&cs35l41->fw_mutex);
846 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
849 if (!cs35l41->amp_name) {
853 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
854 channel_name[*rx_slot], cs35l41->channel_index);
855 if (!cs35l41->amp_name)
859 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
863 static int cs35l41_verify_id(struct cs35l41_hda *cs35l41, unsigned int *regid, unsigned int *reg_revid)
868 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, regid);
870 dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
874 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, reg_revid);
876 dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
884 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", *regid, chipid);
891 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
893 mutex_lock(&cs35l41->fw_mutex);
894 if (cs35l41->cs_dsp.running) {
895 cs35l41->cs_dsp.running = false;
896 cs35l41->cs_dsp.booted = false;
898 regcache_mark_dirty(cs35l41->regmap);
899 mutex_unlock(&cs35l41->fw_mutex);
906 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
908 dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
910 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
911 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
915 mutex_lock(&cs35l41->fw_mutex);
916 if (cs35l41->playback_started)
918 mutex_unlock(&cs35l41->fw_mutex);
925 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
928 dev_dbg(cs35l41->dev, "System Suspend\n");
930 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
931 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
935 mutex_lock(&cs35l41->fw_mutex);
936 if (cs35l41->playback_started)
938 mutex_unlock(&cs35l41->fw_mutex);
947 ret = cs35l41_ready_for_reset(cs35l41);
951 if (cs35l41->reset_gpio) {
952 dev_info(cs35l41->dev, "Asserting Reset\n");
953 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
957 dev_dbg(cs35l41->dev, "System Suspended\n");
962 static int cs35l41_wait_boot_done(struct cs35l41_hda *cs35l41)
967 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
970 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE\n");
974 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_status);
976 dev_err(cs35l41->dev, "OTP Boot status %x error\n",
988 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
991 dev_dbg(cs35l41->dev, "System Resume\n");
993 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
994 dev_err_once(cs35l41->dev, "System Resume not supported\n");
998 if (cs35l41->reset_gpio) {
999 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1001 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1006 regcache_cache_only(cs35l41->regmap, false);
1008 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1011 ret = cs35l41_wait_boot_done(cs35l41);
1015 regcache_cache_only(cs35l41->regmap, true);
1023 mutex_lock(&cs35l41->fw_mutex);
1025 if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
1026 cs35l41->fw_request_ongoing = true;
1027 schedule_work(&cs35l41->fw_load_work);
1029 mutex_unlock(&cs35l41->fw_mutex);
1036 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1038 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
1045 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1048 dev_dbg(cs35l41->dev, "Runtime Suspend\n");
1050 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1051 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
1055 mutex_lock(&cs35l41->fw_mutex);
1057 if (cs35l41->cs_dsp.running) {
1058 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
1059 cs35l41->hw_cfg.bst_type);
1063 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
1066 regcache_cache_only(cs35l41->regmap, true);
1067 regcache_mark_dirty(cs35l41->regmap);
1070 mutex_unlock(&cs35l41->fw_mutex);
1077 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1081 dev_dbg(cs35l41->dev, "Runtime Resume\n");
1083 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
1084 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
1088 mutex_lock(&cs35l41->fw_mutex);
1090 regcache_cache_only(cs35l41->regmap, false);
1092 if (cs35l41->cs_dsp.running) {
1093 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
1095 dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
1100 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1105 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1106 ret = regcache_sync(cs35l41->regmap);
1107 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1109 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
1113 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
1114 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
1116 dev_dbg(cs35l41->dev, "CS35L41 Resumed (%x), Revision: %02X\n", regid, reg_revid);
1119 mutex_unlock(&cs35l41->fw_mutex);
1124 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
1130 if (cs35l41->bypass_fw) {
1131 dev_warn(cs35l41->dev, "Bypassing Firmware.\n");
1135 ret = cs35l41_init_dsp(cs35l41);
1137 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
1141 ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
1143 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
1147 ret = cs_dsp_run(&cs35l41->cs_dsp);
1149 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
1155 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
1160 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
1165 ret = regmap_read(cs35l41->regmap, CS35L41_DSP_MBOX_2, &fw_status);
1167 dev_err(cs35l41->dev,
1177 dev_err(cs35l41->dev, "Firmware status is invalid: %u\n",
1183 ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
1185 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
1189 dev_info(cs35l41->dev, "Firmware Loaded - Type: %s, Gain: %d\n",
1190 hda_cs_dsp_fw_ids[cs35l41->firmware_type], cs35l41->tuning_gain);
1195 cs35l41_shutdown_dsp(cs35l41);
1199 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
1201 if (cs35l41->cs_dsp.running && !load) {
1202 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
1203 cs35l41_shutdown_dsp(cs35l41);
1204 } else if (!cs35l41->cs_dsp.running && load) {
1205 dev_dbg(cs35l41->dev, "Loading Firmware\n");
1206 cs35l41_smart_amp(cs35l41);
1208 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
1215 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1217 ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
1224 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1226 ucontrol->value.integer.value[0] = cs35l41->mute_override;
1232 struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
1234 pm_runtime_get_sync(cs35l41->dev);
1236 mutex_lock(&cs35l41->fw_mutex);
1239 if (cs35l41->playback_started)
1240 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
1242 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
1244 cs35l41->fw_request_ongoing = false;
1245 mutex_unlock(&cs35l41->fw_mutex);
1247 pm_runtime_mark_last_busy(cs35l41->dev);
1248 pm_runtime_put_autosuspend(cs35l41->dev);
1254 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1256 if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
1259 if (cs35l41->fw_request_ongoing) {
1260 dev_dbg(cs35l41->dev, "Existing request not complete\n");
1265 if (cs35l41->playback_started) {
1266 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
1270 cs35l41->fw_request_ongoing = true;
1271 cs35l41->request_fw_load = ucontrol->value.integer.value[0];
1272 schedule_work(&cs35l41->fw_load_work);
1280 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1282 ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
1290 struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
1293 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
1294 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
1309 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
1338 cs35l41->amp_name);
1340 cs35l41->amp_name);
1342 cs35l41->amp_name);
1344 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
1346 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
1350 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
1352 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
1354 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
1358 dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
1360 ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&mute_override_ctl, cs35l41));
1362 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", mute_override_ctl.name,
1367 dev_dbg(cs35l41->dev, "Added Control %s\n", mute_override_ctl.name);
1381 static int cs35l41_get_acpi_mute_state(struct cs35l41_hda *cs35l41, acpi_handle handle)
1392 dev_dbg(cs35l41->dev, "CS35L41_DSM_GET_MUTE: %d\n", mute);
1395 dev_dbg(cs35l41->dev, "%s: %d\n", __func__, mute);
1402 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1408 mute = cs35l41_get_acpi_mute_state(cs35l41, handle);
1410 dev_warn(cs35l41->dev, "Unable to retrieve mute state: %d\n", mute);
1414 dev_dbg(cs35l41->dev, "Requesting mute value: %d\n", mute);
1415 cs35l41->mute_override = (mute > 0);
1416 cs35l41_mute(cs35l41->dev, cs35l41->mute_override);
1421 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1426 if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
1429 comps = &comps[cs35l41->index];
1435 mutex_lock(&cs35l41->fw_mutex);
1438 if (!cs35l41->acpi_subsystem_id)
1439 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1441 cs35l41->codec = comps->codec;
1444 cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
1447 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1448 cs35l41->request_fw_load = true;
1449 if (cs35l41_smart_amp(cs35l41) < 0)
1450 dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1452 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1455 ret = cs35l41_create_controls(cs35l41);
1461 comps->adev = cs35l41->dacpi;
1466 cs35l41->mute_override = cs35l41_get_acpi_mute_state(cs35l41,
1467 acpi_device_handle(cs35l41->dacpi)) > 0;
1469 mutex_unlock(&cs35l41->fw_mutex);
1472 if (!device_link_add(&comps->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
1479 dev_info(cs35l41->dev,
1481 cs35l41->acpi_subsystem_id, cs35l41->hw_cfg.bst_type,
1482 cs35l41->hw_cfg.gpio1.func == CS35l41_VSPK_SWITCH,
1483 cs35l41->hw_cfg.spk_pos ? 'R' : 'L',
1484 cs35l41->cs_dsp.running, cs35l41->speaker_id);
1491 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1495 if (comps[cs35l41->index].dev == dev) {
1496 memset(&comps[cs35l41->index], 0, sizeof(*comps));
1498 device_link_remove(&comps->codec->core.dev, cs35l41->dev);
1510 struct cs35l41_hda *cs35l41 = data;
1512 dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1513 set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1520 struct cs35l41_hda *cs35l41 = data;
1522 dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1523 set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1530 struct cs35l41_hda *cs35l41 = data;
1532 dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1533 set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1540 struct cs35l41_hda *cs35l41 = data;
1542 dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1543 set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1550 struct cs35l41_hda *cs35l41 = data;
1552 dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1553 set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1560 struct cs35l41_hda *cs35l41 = data;
1562 dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1563 set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1587 .name = "cs35l41 IRQ1 Controller",
1597 static void cs35l41_configure_interrupt(struct cs35l41_hda *cs35l41, int irq_pol)
1603 if (!cs35l41->irq) {
1604 dev_warn(cs35l41->dev, "No Interrupt Found");
1608 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1610 0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1612 dev_dbg(cs35l41->dev, "Unable to add IRQ Chip: %d.", ret);
1617 irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1620 dev_dbg(cs35l41->dev, "Unable to map IRQ %s: %d.", cs35l41_irqs[i].name,
1625 ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1628 cs35l41_irqs[i].name, cs35l41);
1630 dev_dbg(cs35l41->dev, "Unable to allocate IRQ %s:: %d.",
1637 dev_warn(cs35l41->dev,
1641 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1643 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1648 if (!cs35l41->hw_cfg.valid)
1651 ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1667 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1682 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1687 irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1690 cs35l41_configure_interrupt(cs35l41, irq_pol);
1692 return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos);
1749 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1751 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1763 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1767 cs35l41->dacpi = adev;
1773 cs35l41->acpi_subsystem_id = sub;
1775 ret = cs35l41_add_dsd_properties(cs35l41, physdev, id, hid);
1777 dev_info(cs35l41->dev, "Using extra _DSD properties, bypassing _DSD in ACPI\n");
1796 cs35l41->index = -1;
1799 cs35l41->index = i;
1803 if (cs35l41->index == -1) {
1804 dev_err(cs35l41->dev, "No index found in %s\n", property);
1812 cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1813 GPIOD_OUT_LOW, "cs35l41-reset");
1819 hw_cfg->spk_pos = values[cs35l41->index];
1821 cs35l41->channel_index = 0;
1822 for (i = 0; i < cs35l41->index; i++)
1824 cs35l41->channel_index++;
1830 hw_cfg->gpio1.func = values[cs35l41->index];
1837 hw_cfg->gpio2.func = values[cs35l41->index];
1843 hw_cfg->bst_ipk = values[cs35l41->index];
1850 hw_cfg->bst_ind = values[cs35l41->index];
1857 hw_cfg->bst_cap = values[cs35l41->index];
1861 cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1872 cs35l41->bypass_fw = false;
1873 if (cs35l41->control_bus == SPI) {
1874 spi = to_spi_device(cs35l41->dev);
1876 dev_warn(cs35l41->dev,
1879 cs35l41->bypass_fw = true;
1886 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1890 acpi_dev_put(cs35l41->dacpi);
1900 struct cs35l41_hda *cs35l41;
1909 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1910 if (!cs35l41)
1913 cs35l41->dev = dev;
1914 cs35l41->irq = irq;
1915 cs35l41->regmap = regmap;
1916 cs35l41->control_bus = control_bus;
1917 dev_set_drvdata(dev, cs35l41);
1919 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1921 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1923 if (IS_ERR(cs35l41->reset_gpio)) {
1924 ret = PTR_ERR(cs35l41->reset_gpio);
1925 cs35l41->reset_gpio = NULL;
1927 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1929 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1933 if (cs35l41->reset_gpio) {
1934 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1936 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1940 regmap_write(cs35l41->regmap, CS35L41_SFT_RESET, CS35L41_SOFTWARE_RESET);
1943 ret = cs35l41_wait_boot_done(cs35l41);
1947 ret = cs35l41_verify_id(cs35l41, ®id, ®_revid);
1951 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1955 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1959 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1961 dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
1965 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1969 ret = cs35l41_get_calibration(cs35l41);
1973 cs35l41_mute(cs35l41->dev, true);
1975 INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1976 mutex_init(&cs35l41->fw_mutex);
1978 pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1979 pm_runtime_use_autosuspend(cs35l41->dev);
1980 pm_runtime_mark_last_busy(cs35l41->dev);
1981 pm_runtime_set_active(cs35l41->dev);
1982 pm_runtime_get_noresume(cs35l41->dev);
1983 pm_runtime_enable(cs35l41->dev);
1985 ret = cs35l41_hda_apply_properties(cs35l41);
1989 pm_runtime_put_autosuspend(cs35l41->dev);
1991 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1993 dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
1997 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
2002 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2003 pm_runtime_disable(cs35l41->dev);
2004 pm_runtime_put_noidle(cs35l41->dev);
2007 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2008 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2009 gpiod_put(cs35l41->reset_gpio);
2010 gpiod_put(cs35l41->cs_gpio);
2011 acpi_dev_put(cs35l41->dacpi);
2012 kfree(cs35l41->acpi_subsystem_id);
2020 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
2022 pm_runtime_get_sync(cs35l41->dev);
2023 pm_runtime_dont_use_autosuspend(cs35l41->dev);
2024 pm_runtime_disable(cs35l41->dev);
2026 if (cs35l41->halo_initialized)
2027 cs35l41_remove_dsp(cs35l41);
2029 component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
2031 acpi_dev_put(cs35l41->dacpi);
2033 pm_runtime_put_noidle(cs35l41->dev);
2035 if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
2036 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
2037 gpiod_put(cs35l41->reset_gpio);
2038 gpiod_put(cs35l41->cs_gpio);
2039 kfree(cs35l41->acpi_subsystem_id);