Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // CS35l41 ALSA HDA audio driver
0004 //
0005 // Copyright 2021 Cirrus Logic, Inc.
0006 //
0007 // Author: Lucas Tanure <tanureal@opensource.cirrus.com>
0008 
0009 #include <linux/acpi.h>
0010 #include <linux/module.h>
0011 #include <linux/moduleparam.h>
0012 #include <sound/hda_codec.h>
0013 #include <sound/soc.h>
0014 #include <linux/pm_runtime.h>
0015 #include "hda_local.h"
0016 #include "hda_auto_parser.h"
0017 #include "hda_jack.h"
0018 #include "hda_generic.h"
0019 #include "hda_component.h"
0020 #include "cs35l41_hda.h"
0021 #include "hda_cs_dsp_ctl.h"
0022 
0023 #define CS35L41_FIRMWARE_ROOT "cirrus/"
0024 #define CS35L41_PART "cs35l41"
0025 
0026 #define HALO_STATE_DSP_CTL_NAME     "HALO_STATE"
0027 #define HALO_STATE_DSP_CTL_TYPE     5
0028 #define HALO_STATE_DSP_CTL_ALG      262308
0029 #define CAL_R_DSP_CTL_NAME      "CAL_R"
0030 #define CAL_STATUS_DSP_CTL_NAME     "CAL_STATUS"
0031 #define CAL_CHECKSUM_DSP_CTL_NAME   "CAL_CHECKSUM"
0032 #define CAL_AMBIENT_DSP_CTL_NAME    "CAL_AMBIENT"
0033 #define CAL_DSP_CTL_TYPE        5
0034 #define CAL_DSP_CTL_ALG         205
0035 
0036 static bool firmware_autostart = 1;
0037 module_param(firmware_autostart, bool, 0444);
0038 MODULE_PARM_DESC(firmware_autostart, "Allow automatic firmware download on boot"
0039                  "(0=Disable, 1=Enable) (default=1); ");
0040 
0041 static const struct reg_sequence cs35l41_hda_config[] = {
0042     { CS35L41_PLL_CLK_CTRL,     0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1
0043     { CS35L41_DSP_CLK_CTRL,     0x00000003 }, // DSP CLK EN
0044     { CS35L41_GLOBAL_CLK_CTRL,  0x00000003 }, // GLOBAL_FS = 48 kHz
0045     { CS35L41_SP_ENABLES,       0x00010000 }, // ASP_RX1_EN = 1
0046     { CS35L41_SP_RATE_CTRL,     0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz
0047     { CS35L41_SP_FORMAT,        0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer
0048     { CS35L41_SP_HIZ_CTRL,      0x00000002 }, // Hi-Z unused
0049     { CS35L41_SP_TX_WL,     0x00000018 }, // 24 cycles/slot
0050     { CS35L41_SP_RX_WL,     0x00000018 }, // 24 cycles/slot
0051     { CS35L41_DAC_PCM1_SRC,     0x00000008 }, // DACPCM1_SRC = ASPRX1
0052     { CS35L41_ASP_TX1_SRC,      0x00000018 }, // ASPTX1 SRC = VMON
0053     { CS35L41_ASP_TX2_SRC,      0x00000019 }, // ASPTX2 SRC = IMON
0054     { CS35L41_ASP_TX3_SRC,      0x00000032 }, // ASPTX3 SRC = ERRVOL
0055     { CS35L41_ASP_TX4_SRC,      0x00000033 }, // ASPTX4 SRC = CLASSH_TGT
0056     { CS35L41_DSP1_RX1_SRC,     0x00000008 }, // DSP1RX1 SRC = ASPRX1
0057     { CS35L41_DSP1_RX2_SRC,     0x00000009 }, // DSP1RX2 SRC = ASPRX2
0058     { CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
0059     { CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
0060     { CS35L41_DSP1_RX5_SRC,         0x00000020 }, // DSP1RX5 SRC = ERRVOL
0061     { CS35L41_AMP_DIG_VOL_CTRL, 0x00000000 }, // AMP_VOL_PCM  0.0 dB
0062     { CS35L41_AMP_GAIN_CTRL,    0x00000084 }, // AMP_GAIN_PCM 4.5 dB
0063 };
0064 
0065 static const struct reg_sequence cs35l41_hda_config_dsp[] = {
0066     { CS35L41_PLL_CLK_CTRL,     0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1
0067     { CS35L41_DSP_CLK_CTRL,     0x00000003 }, // DSP CLK EN
0068     { CS35L41_GLOBAL_CLK_CTRL,  0x00000003 }, // GLOBAL_FS = 48 kHz
0069     { CS35L41_SP_ENABLES,       0x00010001 }, // ASP_RX1_EN = 1, ASP_TX1_EN = 1
0070     { CS35L41_SP_RATE_CTRL,     0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz
0071     { CS35L41_SP_FORMAT,        0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer
0072     { CS35L41_SP_HIZ_CTRL,      0x00000003 }, // Hi-Z unused/disabled
0073     { CS35L41_SP_TX_WL,     0x00000018 }, // 24 cycles/slot
0074     { CS35L41_SP_RX_WL,     0x00000018 }, // 24 cycles/slot
0075     { CS35L41_DAC_PCM1_SRC,     0x00000032 }, // DACPCM1_SRC = ERR_VOL
0076     { CS35L41_ASP_TX1_SRC,      0x00000018 }, // ASPTX1 SRC = VMON
0077     { CS35L41_ASP_TX2_SRC,      0x00000019 }, // ASPTX2 SRC = IMON
0078     { CS35L41_ASP_TX3_SRC,      0x00000028 }, // ASPTX3 SRC = VPMON
0079     { CS35L41_ASP_TX4_SRC,      0x00000029 }, // ASPTX4 SRC = VBSTMON
0080     { CS35L41_DSP1_RX1_SRC,     0x00000008 }, // DSP1RX1 SRC = ASPRX1
0081     { CS35L41_DSP1_RX2_SRC,     0x00000008 }, // DSP1RX2 SRC = ASPRX1
0082     { CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
0083     { CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
0084     { CS35L41_DSP1_RX5_SRC,         0x00000029 }, // DSP1RX5 SRC = VBSTMON
0085     { CS35L41_AMP_DIG_VOL_CTRL, 0x00000000 }, // AMP_VOL_PCM  0.0 dB
0086     { CS35L41_AMP_GAIN_CTRL,    0x00000233 }, // AMP_GAIN_PCM = 17.5dB AMP_GAIN_PDM = 19.5dB
0087 };
0088 
0089 static const struct reg_sequence cs35l41_hda_mute[] = {
0090     { CS35L41_AMP_GAIN_CTRL,    0x00000000 }, // AMP_GAIN_PCM 0.5 dB
0091     { CS35L41_AMP_DIG_VOL_CTRL, 0x0000A678 }, // AMP_VOL_PCM Mute
0092 };
0093 
0094 static int cs35l41_control_add(struct cs_dsp_coeff_ctl *cs_ctl)
0095 {
0096     struct cs35l41_hda *cs35l41 = container_of(cs_ctl->dsp, struct cs35l41_hda, cs_dsp);
0097     struct hda_cs_dsp_ctl_info info;
0098 
0099     info.device_name = cs35l41->amp_name;
0100     info.fw_type = cs35l41->firmware_type;
0101     info.card = cs35l41->codec->card;
0102 
0103     return hda_cs_dsp_control_add(cs_ctl, &info);
0104 }
0105 
0106 static const struct cs_dsp_client_ops client_ops = {
0107     .control_add = cs35l41_control_add,
0108     .control_remove = hda_cs_dsp_control_remove,
0109 };
0110 
0111 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
0112                      const struct firmware **firmware, char **filename,
0113                      const char *dir, const char *ssid, const char *amp_name,
0114                      int spkid, const char *filetype)
0115 {
0116     const char * const dsp_name = cs35l41->cs_dsp.name;
0117     char *s, c;
0118     int ret = 0;
0119 
0120     if (spkid > -1 && ssid && amp_name)
0121         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d-%s.%s", dir, CS35L41_PART,
0122                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
0123                       ssid, spkid, amp_name, filetype);
0124     else if (spkid > -1 && ssid)
0125         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d.%s", dir, CS35L41_PART,
0126                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
0127                       ssid, spkid, filetype);
0128     else if (ssid && amp_name)
0129         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, CS35L41_PART,
0130                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
0131                       ssid, amp_name, filetype);
0132     else if (ssid)
0133         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, CS35L41_PART,
0134                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
0135                       ssid, filetype);
0136     else
0137         *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, CS35L41_PART,
0138                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
0139                       filetype);
0140 
0141     if (*filename == NULL)
0142         return -ENOMEM;
0143 
0144     /*
0145      * Make sure that filename is lower-case and any non alpha-numeric
0146      * characters except full stop and '/' are replaced with hyphens.
0147      */
0148     s = *filename;
0149     while (*s) {
0150         c = *s;
0151         if (isalnum(c))
0152             *s = tolower(c);
0153         else if (c != '.' && c != '/')
0154             *s = '-';
0155         s++;
0156     }
0157 
0158     ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
0159     if (ret != 0) {
0160         dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
0161         kfree(*filename);
0162         *filename = NULL;
0163     }
0164 
0165     return ret;
0166 }
0167 
0168 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
0169                         const struct firmware **wmfw_firmware,
0170                         char **wmfw_filename,
0171                         const struct firmware **coeff_firmware,
0172                         char **coeff_filename)
0173 {
0174     int ret;
0175 
0176     /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.wmfw */
0177     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0178                         CS35L41_FIRMWARE_ROOT,
0179                         cs35l41->acpi_subsystem_id, cs35l41->amp_name,
0180                         cs35l41->speaker_id, "wmfw");
0181     if (!ret) {
0182         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
0183         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0184                           CS35L41_FIRMWARE_ROOT,
0185                           cs35l41->acpi_subsystem_id, cs35l41->amp_name,
0186                           cs35l41->speaker_id, "bin");
0187         return 0;
0188     }
0189 
0190     /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
0191     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0192                         CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0193                         cs35l41->amp_name, -1, "wmfw");
0194     if (!ret) {
0195         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
0196         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0197                           CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0198                           cs35l41->amp_name, cs35l41->speaker_id, "bin");
0199         return 0;
0200     }
0201 
0202     /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */
0203     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0204                         CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0205                         NULL, cs35l41->speaker_id, "wmfw");
0206     if (!ret) {
0207         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
0208         ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0209                             CS35L41_FIRMWARE_ROOT,
0210                             cs35l41->acpi_subsystem_id,
0211                             cs35l41->amp_name, cs35l41->speaker_id, "bin");
0212         if (ret)
0213             /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
0214             cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0215                         CS35L41_FIRMWARE_ROOT,
0216                         cs35l41->acpi_subsystem_id,
0217                         NULL, cs35l41->speaker_id, "bin");
0218         return 0;
0219     }
0220 
0221     /* try cirrus/part-dspN-fwtype-sub.wmfw */
0222     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0223                         CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0224                         NULL, -1, "wmfw");
0225     if (!ret) {
0226         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
0227         ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0228                             CS35L41_FIRMWARE_ROOT,
0229                             cs35l41->acpi_subsystem_id,
0230                             cs35l41->amp_name, cs35l41->speaker_id, "bin");
0231         if (ret)
0232             /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
0233             cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0234                               CS35L41_FIRMWARE_ROOT,
0235                               cs35l41->acpi_subsystem_id,
0236                               NULL, cs35l41->speaker_id, "bin");
0237         return 0;
0238     }
0239 
0240     /* fallback try cirrus/part-dspN-fwtype.wmfw */
0241     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0242                         CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
0243     if (!ret) {
0244         /* fallback try cirrus/part-dspN-fwtype.bin */
0245         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0246                           CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
0247         return 0;
0248     }
0249 
0250     dev_warn(cs35l41->dev, "Failed to request firmware\n");
0251 
0252     return ret;
0253 }
0254 
0255 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
0256                       const struct firmware **wmfw_firmware,
0257                       char **wmfw_filename,
0258                       const struct firmware **coeff_firmware,
0259                       char **coeff_filename)
0260 {
0261     int ret;
0262 
0263     if (cs35l41->speaker_id > -1)
0264         return cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
0265                                 coeff_firmware, coeff_filename);
0266 
0267     /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
0268     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0269                         CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0270                         cs35l41->amp_name, -1, "wmfw");
0271     if (!ret) {
0272         /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
0273         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0274                           CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0275                           cs35l41->amp_name, -1, "bin");
0276         return 0;
0277     }
0278 
0279     /* try cirrus/part-dspN-fwtype-sub.wmfw */
0280     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0281                         CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
0282                         NULL, -1, "wmfw");
0283     if (!ret) {
0284         /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
0285         ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0286                             CS35L41_FIRMWARE_ROOT,
0287                             cs35l41->acpi_subsystem_id,
0288                             cs35l41->amp_name, -1, "bin");
0289         if (ret)
0290             /* try cirrus/part-dspN-fwtype-sub.bin */
0291             cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0292                               CS35L41_FIRMWARE_ROOT,
0293                               cs35l41->acpi_subsystem_id,
0294                               NULL, -1, "bin");
0295         return 0;
0296     }
0297 
0298     /* fallback try cirrus/part-dspN-fwtype.wmfw */
0299     ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
0300                         CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
0301     if (!ret) {
0302         /* fallback try cirrus/part-dspN-fwtype.bin */
0303         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
0304                           CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
0305         return 0;
0306     }
0307 
0308     dev_warn(cs35l41->dev, "Failed to request firmware\n");
0309 
0310     return ret;
0311 }
0312 
0313 #if IS_ENABLED(CONFIG_EFI)
0314 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, unsigned int ambient,
0315                      unsigned int r0, unsigned int status, unsigned int checksum)
0316 {
0317     int ret;
0318 
0319     ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
0320                    CAL_DSP_CTL_ALG, &ambient, 4);
0321     if (ret) {
0322         dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
0323             ret);
0324         return ret;
0325     }
0326     ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
0327                    CAL_DSP_CTL_ALG, &r0, 4);
0328     if (ret) {
0329         dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
0330         return ret;
0331     }
0332     ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
0333                    CAL_DSP_CTL_ALG, &status, 4);
0334     if (ret) {
0335         dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
0336             ret);
0337         return ret;
0338     }
0339     ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
0340                    CAL_DSP_CTL_ALG, &checksum, 4);
0341     if (ret) {
0342         dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
0343             ret);
0344         return ret;
0345     }
0346 
0347     return 0;
0348 }
0349 
0350 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
0351 {
0352     static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe,
0353                           0x5a, 0xa3, 0x5d, 0xb3);
0354     static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData";
0355     const struct cs35l41_amp_efi_data *efi_data;
0356     const struct cs35l41_amp_cal_data *cl;
0357     unsigned long data_size = 0;
0358     efi_status_t status;
0359     int ret = 0;
0360     u8 *data = NULL;
0361     u32 attr;
0362 
0363     /* Get real size of UEFI variable */
0364     status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
0365     if (status == EFI_BUFFER_TOO_SMALL) {
0366         ret = -ENODEV;
0367         /* Allocate data buffer of data_size bytes */
0368         data = vmalloc(data_size);
0369         if (!data)
0370             return -ENOMEM;
0371         /* Get variable contents into buffer */
0372         status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
0373         if (status == EFI_SUCCESS) {
0374             efi_data = (struct cs35l41_amp_efi_data *)data;
0375             dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
0376                 efi_data->size, efi_data->count);
0377             if (efi_data->count > cs35l41->index) {
0378                 cl = &efi_data->data[cs35l41->index];
0379                 dev_dbg(cs35l41->dev,
0380                     "Calibration: Ambient=%02x, Status=%02x, R0=%d\n",
0381                     cl->calAmbient, cl->calStatus, cl->calR);
0382 
0383                 /* Calibration can only be applied whilst the DSP is not running */
0384                 ret = cs35l41_apply_calibration(cs35l41,
0385                                 cpu_to_be32(cl->calAmbient),
0386                                 cpu_to_be32(cl->calR),
0387                                 cpu_to_be32(cl->calStatus),
0388                                 cpu_to_be32(cl->calR + 1));
0389             }
0390         }
0391         vfree(data);
0392     }
0393     return ret;
0394 }
0395 #else
0396 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
0397 {
0398     dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
0399     return 0;
0400 }
0401 #endif
0402 
0403 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
0404 {
0405     const struct firmware *coeff_firmware = NULL;
0406     const struct firmware *wmfw_firmware = NULL;
0407     struct cs_dsp *dsp = &cs35l41->cs_dsp;
0408     char *coeff_filename = NULL;
0409     char *wmfw_filename = NULL;
0410     int ret;
0411 
0412     if (!cs35l41->halo_initialized) {
0413         cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
0414         dsp->client_ops = &client_ops;
0415 
0416         ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
0417         if (ret)
0418             return ret;
0419         cs35l41->halo_initialized = true;
0420     }
0421 
0422     ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
0423                          &coeff_firmware, &coeff_filename);
0424     if (ret < 0)
0425         return ret;
0426 
0427     dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
0428     if (coeff_filename)
0429         dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
0430     else
0431         dev_warn(cs35l41->dev, "No Coefficient File available.\n");
0432 
0433     ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename,
0434                   hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
0435     if (ret)
0436         goto err_release;
0437 
0438     ret = cs35l41_save_calibration(cs35l41);
0439 
0440 err_release:
0441     release_firmware(wmfw_firmware);
0442     release_firmware(coeff_firmware);
0443     kfree(wmfw_filename);
0444     kfree(coeff_filename);
0445 
0446     return ret;
0447 }
0448 
0449 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
0450 {
0451     struct cs_dsp *dsp = &cs35l41->cs_dsp;
0452 
0453     cs_dsp_stop(dsp);
0454     cs_dsp_power_down(dsp);
0455     cs35l41->firmware_running = false;
0456     dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
0457 }
0458 
0459 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
0460 {
0461     struct cs_dsp *dsp = &cs35l41->cs_dsp;
0462 
0463     cancel_work_sync(&cs35l41->fw_load_work);
0464     cs35l41_shutdown_dsp(cs35l41);
0465     cs_dsp_remove(dsp);
0466     cs35l41->halo_initialized = false;
0467 }
0468 
0469 /* Protection release cycle to get the speaker out of Safe-Mode */
0470 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask)
0471 {
0472     regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0);
0473     regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
0474     regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
0475 }
0476 
0477 /* Clear all errors to release safe mode. Global Enable must be cleared first. */
0478 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
0479 {
0480     cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
0481     cs35l41->irq_errors = 0;
0482 }
0483 
0484 static void cs35l41_hda_playback_hook(struct device *dev, int action)
0485 {
0486     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0487     struct regmap *reg = cs35l41->regmap;
0488     int ret = 0;
0489 
0490     mutex_lock(&cs35l41->fw_mutex);
0491 
0492     switch (action) {
0493     case HDA_GEN_PCM_ACT_OPEN:
0494         cs35l41->playback_started = true;
0495         if (cs35l41->firmware_running) {
0496             regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
0497                            ARRAY_SIZE(cs35l41_hda_config_dsp));
0498             regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
0499                        CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
0500                        1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
0501             cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
0502                           CSPL_MBOX_CMD_RESUME);
0503         } else {
0504             regmap_multi_reg_write(reg, cs35l41_hda_config,
0505                            ARRAY_SIZE(cs35l41_hda_config));
0506         }
0507         ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
0508                      CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
0509         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
0510             regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
0511         break;
0512     case HDA_GEN_PCM_ACT_PREPARE:
0513         ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 1);
0514         break;
0515     case HDA_GEN_PCM_ACT_CLEANUP:
0516         regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
0517         ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 0);
0518         break;
0519     case HDA_GEN_PCM_ACT_CLOSE:
0520         ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
0521                      CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
0522         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
0523             regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
0524         if (cs35l41->firmware_running) {
0525             cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
0526                           CSPL_MBOX_CMD_PAUSE);
0527             regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
0528                        CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
0529                        0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
0530         }
0531         cs35l41_irq_release(cs35l41);
0532         cs35l41->playback_started = false;
0533         break;
0534     default:
0535         dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action);
0536         break;
0537     }
0538 
0539     mutex_unlock(&cs35l41->fw_mutex);
0540 
0541     if (ret)
0542         dev_err(cs35l41->dev, "Regmap access fail: %d\n", ret);
0543 }
0544 
0545 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot,
0546                     unsigned int rx_num, unsigned int *rx_slot)
0547 {
0548     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0549     static const char * const channel_name[] = { "L", "R" };
0550 
0551     if (!cs35l41->amp_name) {
0552         if (*rx_slot >= ARRAY_SIZE(channel_name))
0553             return -EINVAL;
0554 
0555         cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
0556                            channel_name[*rx_slot], cs35l41->channel_index);
0557         if (!cs35l41->amp_name)
0558             return -ENOMEM;
0559     }
0560 
0561     return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
0562                     rx_slot);
0563 }
0564 
0565 static int cs35l41_runtime_suspend(struct device *dev)
0566 {
0567     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0568 
0569     dev_dbg(cs35l41->dev, "Suspend\n");
0570 
0571     if (!cs35l41->firmware_running)
0572         return 0;
0573 
0574     if (cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type) < 0)
0575         return 0;
0576 
0577     regcache_cache_only(cs35l41->regmap, true);
0578     regcache_mark_dirty(cs35l41->regmap);
0579 
0580     return 0;
0581 }
0582 
0583 static int cs35l41_runtime_resume(struct device *dev)
0584 {
0585     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0586     int ret;
0587 
0588     dev_dbg(cs35l41->dev, "Resume.\n");
0589 
0590     if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
0591         dev_dbg(cs35l41->dev, "System does not support Resume\n");
0592         return 0;
0593     }
0594 
0595     if (!cs35l41->firmware_running)
0596         return 0;
0597 
0598     regcache_cache_only(cs35l41->regmap, false);
0599 
0600     ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
0601     if (ret) {
0602         regcache_cache_only(cs35l41->regmap, true);
0603         return ret;
0604     }
0605 
0606     /* Test key needs to be unlocked to allow the OTP settings to re-apply */
0607     cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
0608     ret = regcache_sync(cs35l41->regmap);
0609     cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
0610     if (ret) {
0611         dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
0612         return ret;
0613     }
0614 
0615     if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
0616         cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
0617 
0618     return 0;
0619 }
0620 
0621 static int cs35l41_hda_suspend_hook(struct device *dev)
0622 {
0623     dev_dbg(dev, "Request Suspend\n");
0624     pm_runtime_mark_last_busy(dev);
0625     return pm_runtime_put_autosuspend(dev);
0626 }
0627 
0628 static int cs35l41_hda_resume_hook(struct device *dev)
0629 {
0630     dev_dbg(dev, "Request Resume\n");
0631     return pm_runtime_get_sync(dev);
0632 }
0633 
0634 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
0635 {
0636     int halo_sts;
0637     int ret;
0638 
0639     ret = cs35l41_init_dsp(cs35l41);
0640     if (ret) {
0641         dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
0642         goto clean_dsp;
0643     }
0644 
0645     ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
0646     if (ret) {
0647         dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
0648         goto clean_dsp;
0649     }
0650 
0651     ret = cs_dsp_run(&cs35l41->cs_dsp);
0652     if (ret) {
0653         dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
0654         goto clean_dsp;
0655     }
0656 
0657     ret = read_poll_timeout(hda_cs_dsp_read_ctl, ret,
0658                 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN,
0659                 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
0660                 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG,
0661                 &halo_sts, sizeof(halo_sts));
0662 
0663     if (ret) {
0664         dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %d\n",
0665              halo_sts);
0666         goto clean_dsp;
0667     }
0668 
0669     cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
0670     cs35l41->firmware_running = true;
0671 
0672     return 0;
0673 
0674 clean_dsp:
0675     cs35l41_shutdown_dsp(cs35l41);
0676     return ret;
0677 }
0678 
0679 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
0680 {
0681     pm_runtime_get_sync(cs35l41->dev);
0682 
0683     if (cs35l41->firmware_running && !load) {
0684         dev_dbg(cs35l41->dev, "Unloading Firmware\n");
0685         cs35l41_shutdown_dsp(cs35l41);
0686     } else if (!cs35l41->firmware_running && load) {
0687         dev_dbg(cs35l41->dev, "Loading Firmware\n");
0688         cs35l41_smart_amp(cs35l41);
0689     } else {
0690         dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
0691     }
0692 
0693     pm_runtime_mark_last_busy(cs35l41->dev);
0694     pm_runtime_put_autosuspend(cs35l41->dev);
0695 }
0696 
0697 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
0698                    struct snd_ctl_elem_value *ucontrol)
0699 {
0700     struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
0701 
0702     ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
0703     return 0;
0704 }
0705 
0706 static void cs35l41_fw_load_work(struct work_struct *work)
0707 {
0708     struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
0709 
0710     mutex_lock(&cs35l41->fw_mutex);
0711 
0712     /* Recheck if playback is ongoing, mutex will block playback during firmware loading */
0713     if (cs35l41->playback_started)
0714         dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
0715     else
0716         cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
0717 
0718     cs35l41->fw_request_ongoing = false;
0719     mutex_unlock(&cs35l41->fw_mutex);
0720 }
0721 
0722 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
0723                    struct snd_ctl_elem_value *ucontrol)
0724 {
0725     struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
0726     unsigned int ret = 0;
0727 
0728     mutex_lock(&cs35l41->fw_mutex);
0729 
0730     if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
0731         goto err;
0732 
0733     if (cs35l41->fw_request_ongoing) {
0734         dev_dbg(cs35l41->dev, "Existing request not complete\n");
0735         ret = -EBUSY;
0736         goto err;
0737     }
0738 
0739     /* Check if playback is ongoing when initial request is made */
0740     if (cs35l41->playback_started) {
0741         dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
0742         ret = -EBUSY;
0743         goto err;
0744     }
0745 
0746     cs35l41->fw_request_ongoing = true;
0747     cs35l41->request_fw_load = ucontrol->value.integer.value[0];
0748     schedule_work(&cs35l41->fw_load_work);
0749 
0750 err:
0751     mutex_unlock(&cs35l41->fw_mutex);
0752 
0753     return ret;
0754 }
0755 
0756 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol,
0757                    struct snd_ctl_elem_value *ucontrol)
0758 {
0759     struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
0760 
0761     ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
0762 
0763     return 0;
0764 }
0765 
0766 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol,
0767                    struct snd_ctl_elem_value *ucontrol)
0768 {
0769     struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
0770 
0771     if (ucontrol->value.enumerated.item[0] < HDA_CS_DSP_NUM_FW) {
0772         cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
0773         return 0;
0774     }
0775 
0776     return -EINVAL;
0777 }
0778 
0779 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
0780 {
0781     return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(hda_cs_dsp_fw_ids), hda_cs_dsp_fw_ids);
0782 }
0783 
0784 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
0785 {
0786     char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
0787     char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
0788     struct snd_kcontrol_new fw_type_ctl = {
0789         .name = fw_type_ctl_name,
0790         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
0791         .info = cs35l41_fw_type_ctl_info,
0792         .get = cs35l41_fw_type_ctl_get,
0793         .put = cs35l41_fw_type_ctl_put,
0794     };
0795     struct snd_kcontrol_new fw_load_ctl = {
0796         .name = fw_load_ctl_name,
0797         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
0798         .info = snd_ctl_boolean_mono_info,
0799         .get = cs35l41_fw_load_ctl_get,
0800         .put = cs35l41_fw_load_ctl_put,
0801     };
0802     int ret;
0803 
0804     scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type",
0805           cs35l41->amp_name);
0806     scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load",
0807           cs35l41->amp_name);
0808 
0809     ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
0810     if (ret) {
0811         dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
0812         return ret;
0813     }
0814 
0815     dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
0816 
0817     ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
0818     if (ret) {
0819         dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
0820         return ret;
0821     }
0822 
0823     dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
0824 
0825     return 0;
0826 }
0827 
0828 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
0829 {
0830     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0831     struct hda_component *comps = master_data;
0832     int ret = 0;
0833 
0834     if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
0835         return -EINVAL;
0836 
0837     comps = &comps[cs35l41->index];
0838     if (comps->dev)
0839         return -EBUSY;
0840 
0841     pm_runtime_get_sync(dev);
0842 
0843     comps->dev = dev;
0844     if (!cs35l41->acpi_subsystem_id)
0845         cs35l41->acpi_subsystem_id = devm_kasprintf(dev, GFP_KERNEL, "%.8x",
0846                                 comps->codec->core.subsystem_id);
0847     cs35l41->codec = comps->codec;
0848     strscpy(comps->name, dev_name(dev), sizeof(comps->name));
0849 
0850     cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
0851 
0852     if (firmware_autostart) {
0853         dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
0854         cs35l41->request_fw_load = true;
0855         mutex_lock(&cs35l41->fw_mutex);
0856         if (cs35l41_smart_amp(cs35l41) < 0)
0857             dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
0858         mutex_unlock(&cs35l41->fw_mutex);
0859     } else {
0860         dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
0861     }
0862 
0863     ret = cs35l41_create_controls(cs35l41);
0864 
0865     comps->playback_hook = cs35l41_hda_playback_hook;
0866     comps->suspend_hook = cs35l41_hda_suspend_hook;
0867     comps->resume_hook = cs35l41_hda_resume_hook;
0868 
0869     pm_runtime_mark_last_busy(dev);
0870     pm_runtime_put_autosuspend(dev);
0871 
0872     return ret;
0873 }
0874 
0875 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
0876 {
0877     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
0878     struct hda_component *comps = master_data;
0879 
0880     if (comps[cs35l41->index].dev == dev)
0881         memset(&comps[cs35l41->index], 0, sizeof(*comps));
0882 }
0883 
0884 static const struct component_ops cs35l41_hda_comp_ops = {
0885     .bind = cs35l41_hda_bind,
0886     .unbind = cs35l41_hda_unbind,
0887 };
0888 
0889 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
0890 {
0891     struct cs35l41_hda *cs35l41 = data;
0892 
0893     dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
0894     set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0895 
0896     return IRQ_HANDLED;
0897 }
0898 
0899 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
0900 {
0901     struct cs35l41_hda *cs35l41 = data;
0902 
0903     dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
0904     set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0905 
0906     return IRQ_HANDLED;
0907 }
0908 
0909 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
0910 {
0911     struct cs35l41_hda *cs35l41 = data;
0912 
0913     dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
0914     set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0915 
0916     return IRQ_HANDLED;
0917 }
0918 
0919 static irqreturn_t cs35l41_temp_err(int irq, void *data)
0920 {
0921     struct cs35l41_hda *cs35l41 = data;
0922 
0923     dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
0924     set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0925 
0926     return IRQ_HANDLED;
0927 }
0928 
0929 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
0930 {
0931     struct cs35l41_hda *cs35l41 = data;
0932 
0933     dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
0934     set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0935 
0936     return IRQ_HANDLED;
0937 }
0938 
0939 static irqreturn_t cs35l41_amp_short(int irq, void *data)
0940 {
0941     struct cs35l41_hda *cs35l41 = data;
0942 
0943     dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
0944     set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
0945 
0946     return IRQ_HANDLED;
0947 }
0948 
0949 static const struct cs35l41_irq cs35l41_irqs[] = {
0950     CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
0951     CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
0952     CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
0953     CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
0954     CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
0955     CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
0956 };
0957 
0958 static const struct regmap_irq cs35l41_reg_irqs[] = {
0959     CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
0960     CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
0961     CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
0962     CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
0963     CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
0964     CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
0965 };
0966 
0967 static struct regmap_irq_chip cs35l41_regmap_irq_chip = {
0968     .name = "cs35l41 IRQ1 Controller",
0969     .status_base = CS35L41_IRQ1_STATUS1,
0970     .mask_base = CS35L41_IRQ1_MASK1,
0971     .ack_base = CS35L41_IRQ1_STATUS1,
0972     .num_regs = 4,
0973     .irqs = cs35l41_reg_irqs,
0974     .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
0975     .runtime_pm = true,
0976 };
0977 
0978 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
0979 {
0980     struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
0981     bool using_irq = false;
0982     int irq, irq_pol;
0983     int ret;
0984     int i;
0985 
0986     if (!cs35l41->hw_cfg.valid)
0987         return -EINVAL;
0988 
0989     ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
0990     if (ret)
0991         return ret;
0992 
0993     if (hw_cfg->gpio1.valid) {
0994         switch (hw_cfg->gpio1.func) {
0995         case CS35L41_NOT_USED:
0996             break;
0997         case CS35l41_VSPK_SWITCH:
0998             hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
0999             hw_cfg->gpio1.out_en = true;
1000             break;
1001         case CS35l41_SYNC:
1002             hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC;
1003             break;
1004         default:
1005             dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1006                 hw_cfg->gpio1.func);
1007             return -EINVAL;
1008         }
1009     }
1010 
1011     if (hw_cfg->gpio2.valid) {
1012         switch (hw_cfg->gpio2.func) {
1013         case CS35L41_NOT_USED:
1014             break;
1015         case CS35L41_INTERRUPT:
1016             using_irq = true;
1017             hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN;
1018             break;
1019         default:
1020             dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1021             return -EINVAL;
1022         }
1023     }
1024 
1025     irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1026 
1027     if (cs35l41->irq && using_irq) {
1028         ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1029                            IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1030                            0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1031         if (ret)
1032             return ret;
1033 
1034         for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) {
1035             irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1036             if (irq < 0)
1037                 return irq;
1038 
1039             ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1040                             cs35l41_irqs[i].handler,
1041                             IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1042                             cs35l41_irqs[i].name, cs35l41);
1043             if (ret)
1044                 return ret;
1045         }
1046     }
1047 
1048     return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos);
1049 }
1050 
1051 static int cs35l41_get_acpi_sub_string(struct device *dev, struct acpi_device *adev,
1052                        const char **subsysid)
1053 {
1054     struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1055     union acpi_object *obj;
1056     acpi_status status;
1057     int ret = 0;
1058 
1059     status = acpi_evaluate_object(adev->handle, "_SUB", NULL, &buffer);
1060     if (ACPI_SUCCESS(status)) {
1061         obj = buffer.pointer;
1062         if (obj->type == ACPI_TYPE_STRING) {
1063             *subsysid = devm_kstrdup(dev, obj->string.pointer, GFP_KERNEL);
1064             if (*subsysid == NULL) {
1065                 dev_err(dev, "Cannot allocate Subsystem ID");
1066                 ret = -ENOMEM;
1067             }
1068         } else {
1069             dev_warn(dev, "Warning ACPI _SUB did not return a string\n");
1070             ret = -ENODEV;
1071         }
1072         acpi_os_free(buffer.pointer);
1073     } else {
1074         dev_dbg(dev, "Warning ACPI _SUB failed: %#x\n", status);
1075         ret = -ENODEV;
1076     }
1077 
1078     return ret;
1079 }
1080 
1081 static int cs35l41_get_speaker_id(struct device *dev, int amp_index,
1082                   int num_amps, int fixed_gpio_id)
1083 {
1084     struct gpio_desc *speaker_id_desc;
1085     int speaker_id = -ENODEV;
1086 
1087     if (fixed_gpio_id >= 0) {
1088         dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id);
1089         speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN);
1090         if (IS_ERR(speaker_id_desc)) {
1091             speaker_id = PTR_ERR(speaker_id_desc);
1092             return speaker_id;
1093         }
1094         speaker_id = gpiod_get_value_cansleep(speaker_id_desc);
1095         gpiod_put(speaker_id_desc);
1096         dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1097     } else {
1098         int base_index;
1099         int gpios_per_amp;
1100         int count;
1101         int tmp;
1102         int i;
1103 
1104         count = gpiod_count(dev, "spk-id");
1105         if (count > 0) {
1106             speaker_id = 0;
1107             gpios_per_amp = count / num_amps;
1108             base_index = gpios_per_amp * amp_index;
1109 
1110             if (count % num_amps)
1111                 return -EINVAL;
1112 
1113             dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp);
1114 
1115             for (i = 0; i < gpios_per_amp; i++) {
1116                 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index,
1117                                   GPIOD_IN);
1118                 if (IS_ERR(speaker_id_desc)) {
1119                     speaker_id = PTR_ERR(speaker_id_desc);
1120                     break;
1121                 }
1122                 tmp = gpiod_get_value_cansleep(speaker_id_desc);
1123                 gpiod_put(speaker_id_desc);
1124                 if (tmp < 0) {
1125                     speaker_id = tmp;
1126                     break;
1127                 }
1128                 speaker_id |= tmp << i;
1129             }
1130             dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1131         }
1132     }
1133     return speaker_id;
1134 }
1135 
1136 /*
1137  * Device CLSA010(0/1) doesn't have _DSD so a gpiod_get by the label reset won't work.
1138  * And devices created by serial-multi-instantiate don't have their device struct
1139  * pointing to the correct fwnode, so acpi_dev must be used here.
1140  * And devm functions expect that the device requesting the resource has the correct
1141  * fwnode.
1142  */
1143 static int cs35l41_no_acpi_dsd(struct cs35l41_hda *cs35l41, struct device *physdev, int id,
1144                    const char *hid)
1145 {
1146     struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1147 
1148     /* check I2C address to assign the index */
1149     cs35l41->index = id == 0x40 ? 0 : 1;
1150     cs35l41->channel_index = 0;
1151     cs35l41->reset_gpio = gpiod_get_index(physdev, NULL, 0, GPIOD_OUT_HIGH);
1152     cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, 0, 0, 2);
1153     hw_cfg->spk_pos = cs35l41->index;
1154     hw_cfg->gpio2.func = CS35L41_INTERRUPT;
1155     hw_cfg->gpio2.valid = true;
1156     hw_cfg->valid = true;
1157     put_device(physdev);
1158 
1159     if (strncmp(hid, "CLSA0100", 8) == 0) {
1160         hw_cfg->bst_type = CS35L41_EXT_BOOST_NO_VSPK_SWITCH;
1161     } else if (strncmp(hid, "CLSA0101", 8) == 0) {
1162         hw_cfg->bst_type = CS35L41_EXT_BOOST;
1163         hw_cfg->gpio1.func = CS35l41_VSPK_SWITCH;
1164         hw_cfg->gpio1.valid = true;
1165     } else {
1166         /*
1167          * Note: CLSA010(0/1) are special cases which use a slightly different design.
1168          * All other HIDs e.g. CSC3551 require valid ACPI _DSD properties to be supported.
1169          */
1170         dev_err(cs35l41->dev, "Error: ACPI _DSD Properties are missing for HID %s.\n", hid);
1171         hw_cfg->valid = false;
1172         hw_cfg->gpio1.valid = false;
1173         hw_cfg->gpio2.valid = false;
1174         return -EINVAL;
1175     }
1176 
1177     return 0;
1178 }
1179 
1180 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1181 {
1182     struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1183     u32 values[HDA_MAX_COMPONENTS];
1184     struct acpi_device *adev;
1185     struct device *physdev;
1186     char *property;
1187     size_t nval;
1188     int i, ret;
1189 
1190     adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1191     if (!adev) {
1192         dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1193         return -ENODEV;
1194     }
1195 
1196     physdev = get_device(acpi_get_first_physical_node(adev));
1197     acpi_dev_put(adev);
1198 
1199     ret = cs35l41_get_acpi_sub_string(cs35l41->dev, adev, &cs35l41->acpi_subsystem_id);
1200     if (ret)
1201         dev_info(cs35l41->dev, "No Subsystem ID found in ACPI: %d", ret);
1202     else
1203         dev_dbg(cs35l41->dev, "Subsystem ID %s found", cs35l41->acpi_subsystem_id);
1204 
1205     property = "cirrus,dev-index";
1206     ret = device_property_count_u32(physdev, property);
1207     if (ret <= 0)
1208         return cs35l41_no_acpi_dsd(cs35l41, physdev, id, hid);
1209 
1210     if (ret > ARRAY_SIZE(values)) {
1211         ret = -EINVAL;
1212         goto err;
1213     }
1214     nval = ret;
1215 
1216     ret = device_property_read_u32_array(physdev, property, values, nval);
1217     if (ret)
1218         goto err;
1219 
1220     cs35l41->index = -1;
1221     for (i = 0; i < nval; i++) {
1222         if (values[i] == id) {
1223             cs35l41->index = i;
1224             break;
1225         }
1226     }
1227     if (cs35l41->index == -1) {
1228         dev_err(cs35l41->dev, "No index found in %s\n", property);
1229         ret = -ENODEV;
1230         goto err;
1231     }
1232 
1233     /* To use the same release code for all laptop variants we can't use devm_ version of
1234      * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1235      */
1236     cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1237                              GPIOD_OUT_LOW, "cs35l41-reset");
1238 
1239     property = "cirrus,speaker-position";
1240     ret = device_property_read_u32_array(physdev, property, values, nval);
1241     if (ret)
1242         goto err;
1243     hw_cfg->spk_pos = values[cs35l41->index];
1244 
1245     cs35l41->channel_index = 0;
1246     for (i = 0; i < cs35l41->index; i++)
1247         if (values[i] == hw_cfg->spk_pos)
1248             cs35l41->channel_index++;
1249 
1250     property = "cirrus,gpio1-func";
1251     ret = device_property_read_u32_array(physdev, property, values, nval);
1252     if (ret)
1253         goto err;
1254     hw_cfg->gpio1.func = values[cs35l41->index];
1255     hw_cfg->gpio1.valid = true;
1256 
1257     property = "cirrus,gpio2-func";
1258     ret = device_property_read_u32_array(physdev, property, values, nval);
1259     if (ret)
1260         goto err;
1261     hw_cfg->gpio2.func = values[cs35l41->index];
1262     hw_cfg->gpio2.valid = true;
1263 
1264     property = "cirrus,boost-peak-milliamp";
1265     ret = device_property_read_u32_array(physdev, property, values, nval);
1266     if (ret == 0)
1267         hw_cfg->bst_ipk = values[cs35l41->index];
1268     else
1269         hw_cfg->bst_ipk = -1;
1270 
1271     property = "cirrus,boost-ind-nanohenry";
1272     ret = device_property_read_u32_array(physdev, property, values, nval);
1273     if (ret == 0)
1274         hw_cfg->bst_ind = values[cs35l41->index];
1275     else
1276         hw_cfg->bst_ind = -1;
1277 
1278     property = "cirrus,boost-cap-microfarad";
1279     ret = device_property_read_u32_array(physdev, property, values, nval);
1280     if (ret == 0)
1281         hw_cfg->bst_cap = values[cs35l41->index];
1282     else
1283         hw_cfg->bst_cap = -1;
1284 
1285     cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1286 
1287     if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1288         hw_cfg->bst_type = CS35L41_INT_BOOST;
1289     else
1290         hw_cfg->bst_type = CS35L41_EXT_BOOST;
1291 
1292     hw_cfg->valid = true;
1293     put_device(physdev);
1294 
1295     return 0;
1296 
1297 err:
1298     put_device(physdev);
1299     dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1300 
1301     return ret;
1302 }
1303 
1304 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1305               struct regmap *regmap)
1306 {
1307     unsigned int int_sts, regid, reg_revid, mtl_revid, chipid, int_status;
1308     struct cs35l41_hda *cs35l41;
1309     int ret;
1310 
1311     BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1312     BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1313 
1314     if (IS_ERR(regmap))
1315         return PTR_ERR(regmap);
1316 
1317     cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1318     if (!cs35l41)
1319         return -ENOMEM;
1320 
1321     cs35l41->dev = dev;
1322     cs35l41->irq = irq;
1323     cs35l41->regmap = regmap;
1324     dev_set_drvdata(dev, cs35l41);
1325 
1326     ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1327     if (ret)
1328         return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1329 
1330     if (IS_ERR(cs35l41->reset_gpio)) {
1331         ret = PTR_ERR(cs35l41->reset_gpio);
1332         cs35l41->reset_gpio = NULL;
1333         if (ret == -EBUSY) {
1334             dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1335         } else {
1336             dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1337             goto err;
1338         }
1339     }
1340     if (cs35l41->reset_gpio) {
1341         usleep_range(2000, 2100);
1342         gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1343     }
1344 
1345     usleep_range(2000, 2100);
1346 
1347     ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
1348                        int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
1349     if (ret) {
1350         dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1351         goto err;
1352     }
1353 
1354     ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts);
1355     if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) {
1356         dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n",
1357             int_sts & CS35L41_OTP_BOOT_ERR, ret);
1358         ret = -EIO;
1359         goto err;
1360     }
1361 
1362     ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, &regid);
1363     if (ret) {
1364         dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1365         goto err;
1366     }
1367 
1368     ret = regmap_read(cs35l41->regmap, CS35L41_REVID, &reg_revid);
1369     if (ret) {
1370         dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1371         goto err;
1372     }
1373 
1374     mtl_revid = reg_revid & CS35L41_MTLREVID_MASK;
1375 
1376     chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID;
1377     if (regid != chipid) {
1378         dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid);
1379         ret = -ENODEV;
1380         goto err;
1381     }
1382 
1383     ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1384     if (ret)
1385         goto err;
1386 
1387     ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1388     if (ret)
1389         goto err;
1390 
1391     ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1392     if (ret) {
1393         dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1394         goto err;
1395     }
1396 
1397     ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1398     if (ret)
1399         goto err;
1400 
1401     INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1402     mutex_init(&cs35l41->fw_mutex);
1403 
1404     pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1405     pm_runtime_use_autosuspend(cs35l41->dev);
1406     pm_runtime_mark_last_busy(cs35l41->dev);
1407     pm_runtime_set_active(cs35l41->dev);
1408     pm_runtime_get_noresume(cs35l41->dev);
1409     pm_runtime_enable(cs35l41->dev);
1410 
1411     ret = cs35l41_hda_apply_properties(cs35l41);
1412     if (ret)
1413         goto err_pm;
1414 
1415     pm_runtime_put_autosuspend(cs35l41->dev);
1416 
1417     ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1418     if (ret) {
1419         dev_err(cs35l41->dev, "Register component failed: %d\n", ret);
1420         pm_runtime_disable(cs35l41->dev);
1421         goto err;
1422     }
1423 
1424     dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
1425 
1426     return 0;
1427 
1428 err_pm:
1429     pm_runtime_disable(cs35l41->dev);
1430     pm_runtime_put_noidle(cs35l41->dev);
1431 
1432 err:
1433     if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1434         gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1435     gpiod_put(cs35l41->reset_gpio);
1436 
1437     return ret;
1438 }
1439 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41);
1440 
1441 void cs35l41_hda_remove(struct device *dev)
1442 {
1443     struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1444 
1445     pm_runtime_get_sync(cs35l41->dev);
1446     pm_runtime_disable(cs35l41->dev);
1447 
1448     if (cs35l41->halo_initialized)
1449         cs35l41_remove_dsp(cs35l41);
1450 
1451     component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
1452 
1453     pm_runtime_put_noidle(cs35l41->dev);
1454 
1455     if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1456         gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1457     gpiod_put(cs35l41->reset_gpio);
1458 }
1459 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41);
1460 
1461 const struct dev_pm_ops cs35l41_hda_pm_ops = {
1462     RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, NULL)
1463 };
1464 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
1465 
1466 MODULE_DESCRIPTION("CS35L41 HDA Driver");
1467 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
1468 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
1469 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!