sound/pci/hda/cs35l41_hda.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // CS35l41 ALSA HDA audio driver
   4 //
   5 // Copyright 2021 Cirrus Logic, Inc.
   6 //
   7 // Author: Lucas Tanure <tanureal@opensource.cirrus.com>
   8
   9 #include <linux/acpi.h>
  10 #include <linux/module.h>
  11 #include <linux/moduleparam.h>
  12 #include <sound/hda_codec.h>
  13 #include <sound/soc.h>
  14 #include <linux/pm_runtime.h>
  15 #include "hda_local.h"
  16 #include "hda_auto_parser.h"
  17 #include "hda_jack.h"
  18 #include "hda_generic.h"
  19 #include "hda_component.h"
  20 #include "cs35l41_hda.h"
  21 #include "hda_cs_dsp_ctl.h"
  22
  23 #define CS35L41_FIRMWARE_ROOT "cirrus/"
  24 #define CS35L41_PART "cs35l41"
  25
  26 #define HALO_STATE_DSP_CTL_NAME         "HALO_STATE"
  27 #define HALO_STATE_DSP_CTL_TYPE         5
  28 #define HALO_STATE_DSP_CTL_ALG          262308
  29 #define CAL_R_DSP_CTL_NAME              "CAL_R"
  30 #define CAL_STATUS_DSP_CTL_NAME         "CAL_STATUS"
  31 #define CAL_CHECKSUM_DSP_CTL_NAME       "CAL_CHECKSUM"
  32 #define CAL_AMBIENT_DSP_CTL_NAME        "CAL_AMBIENT"
  33 #define CAL_DSP_CTL_TYPE                5
  34 #define CAL_DSP_CTL_ALG                 205
  35
  36 static bool firmware_autostart = 1;
  37 module_param(firmware_autostart, bool, 0444);
  38 MODULE_PARM_DESC(firmware_autostart, "Allow automatic firmware download on boot"
  39                              "(0=Disable, 1=Enable) (default=1); ");
  40
  41 static const struct reg_sequence cs35l41_hda_config[] = {
  42         { CS35L41_PLL_CLK_CTRL,         0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1
  43         { CS35L41_DSP_CLK_CTRL,         0x00000003 }, // DSP CLK EN
  44         { CS35L41_GLOBAL_CLK_CTRL,      0x00000003 }, // GLOBAL_FS = 48 kHz
  45         { CS35L41_SP_ENABLES,           0x00010000 }, // ASP_RX1_EN = 1
  46         { CS35L41_SP_RATE_CTRL,         0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz
  47         { CS35L41_SP_FORMAT,            0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer
  48         { CS35L41_SP_HIZ_CTRL,          0x00000002 }, // Hi-Z unused
  49         { CS35L41_SP_TX_WL,             0x00000018 }, // 24 cycles/slot
  50         { CS35L41_SP_RX_WL,             0x00000018 }, // 24 cycles/slot
  51         { CS35L41_DAC_PCM1_SRC,         0x00000008 }, // DACPCM1_SRC = ASPRX1
  52         { CS35L41_ASP_TX1_SRC,          0x00000018 }, // ASPTX1 SRC = VMON
  53         { CS35L41_ASP_TX2_SRC,          0x00000019 }, // ASPTX2 SRC = IMON
  54         { CS35L41_ASP_TX3_SRC,          0x00000032 }, // ASPTX3 SRC = ERRVOL
  55         { CS35L41_ASP_TX4_SRC,          0x00000033 }, // ASPTX4 SRC = CLASSH_TGT
  56         { CS35L41_DSP1_RX1_SRC,         0x00000008 }, // DSP1RX1 SRC = ASPRX1
  57         { CS35L41_DSP1_RX2_SRC,         0x00000009 }, // DSP1RX2 SRC = ASPRX2
  58         { CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
  59         { CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
  60         { CS35L41_DSP1_RX5_SRC,         0x00000020 }, // DSP1RX5 SRC = ERRVOL
  61         { CS35L41_AMP_DIG_VOL_CTRL,     0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM  0.0 dB
  62         { CS35L41_AMP_GAIN_CTRL,        0x00000084 }, // AMP_GAIN_PCM 4.5 dB
  63 };
  64
  65 static const struct reg_sequence cs35l41_hda_config_dsp[] = {
  66         { CS35L41_PLL_CLK_CTRL,         0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1
  67         { CS35L41_DSP_CLK_CTRL,         0x00000003 }, // DSP CLK EN
  68         { CS35L41_GLOBAL_CLK_CTRL,      0x00000003 }, // GLOBAL_FS = 48 kHz
  69         { CS35L41_SP_ENABLES,           0x00010001 }, // ASP_RX1_EN = 1, ASP_TX1_EN = 1
  70         { CS35L41_SP_RATE_CTRL,         0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz
  71         { CS35L41_SP_FORMAT,            0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer
  72         { CS35L41_SP_HIZ_CTRL,          0x00000003 }, // Hi-Z unused/disabled
  73         { CS35L41_SP_TX_WL,             0x00000018 }, // 24 cycles/slot
  74         { CS35L41_SP_RX_WL,             0x00000018 }, // 24 cycles/slot
  75         { CS35L41_DAC_PCM1_SRC,         0x00000032 }, // DACPCM1_SRC = ERR_VOL
  76         { CS35L41_ASP_TX1_SRC,          0x00000018 }, // ASPTX1 SRC = VMON
  77         { CS35L41_ASP_TX2_SRC,          0x00000019 }, // ASPTX2 SRC = IMON
  78         { CS35L41_ASP_TX3_SRC,          0x00000028 }, // ASPTX3 SRC = VPMON
  79         { CS35L41_ASP_TX4_SRC,          0x00000029 }, // ASPTX4 SRC = VBSTMON
  80         { CS35L41_DSP1_RX1_SRC,         0x00000008 }, // DSP1RX1 SRC = ASPRX1
  81         { CS35L41_DSP1_RX2_SRC,         0x00000008 }, // DSP1RX2 SRC = ASPRX1
  82         { CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
  83         { CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
  84         { CS35L41_DSP1_RX5_SRC,         0x00000029 }, // DSP1RX5 SRC = VBSTMON
  85         { CS35L41_AMP_DIG_VOL_CTRL,     0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM  0.0 dB
  86         { CS35L41_AMP_GAIN_CTRL,        0x00000233 }, // AMP_GAIN_PCM = 17.5dB AMP_GAIN_PDM = 19.5dB
  87 };
  88
  89 static const struct reg_sequence cs35l41_hda_mute[] = {
  90         { CS35L41_AMP_GAIN_CTRL,        0x00000000 }, // AMP_GAIN_PCM 0.5 dB
  91         { CS35L41_AMP_DIG_VOL_CTRL,     0x0000A678 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM Mute
  92 };
  93
  94 static void cs35l41_add_controls(struct cs35l41_hda *cs35l41)
  95 {
  96         struct hda_cs_dsp_ctl_info info;
  97
  98         info.device_name = cs35l41->amp_name;
  99         info.fw_type = cs35l41->firmware_type;
 100         info.card = cs35l41->codec->card;
 101
 102         hda_cs_dsp_add_controls(&cs35l41->cs_dsp, &info);
 103 }
 104
 105 static const struct cs_dsp_client_ops client_ops = {
 106         .control_remove = hda_cs_dsp_control_remove,
 107 };
 108
 109 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
 110                                          const struct firmware **firmware, char **filename,
 111                                          const char *dir, const char *ssid, const char *amp_name,
 112                                          int spkid, const char *filetype)
 113 {
 114         const char * const dsp_name = cs35l41->cs_dsp.name;
 115         char *s, c;
 116         int ret = 0;
 117
 118         if (spkid > -1 && ssid && amp_name)
 119                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d-%s.%s", dir, CS35L41_PART,
 120                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 121                                       ssid, spkid, amp_name, filetype);
 122         else if (spkid > -1 && ssid)
 123                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d.%s", dir, CS35L41_PART,
 124                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 125                                       ssid, spkid, filetype);
 126         else if (ssid && amp_name)
 127                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, CS35L41_PART,
 128                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 129                                       ssid, amp_name, filetype);
 130         else if (ssid)
 131                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, CS35L41_PART,
 132                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 133                                       ssid, filetype);
 134         else
 135                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, CS35L41_PART,
 136                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 137                                       filetype);
 138
 139         if (*filename == NULL)
 140                 return -ENOMEM;
 141
 142         /*
 143          * Make sure that filename is lower-case and any non alpha-numeric
 144          * characters except full stop and '/' are replaced with hyphens.
 145          */
 146         s = *filename;
 147         while (*s) {
 148                 c = *s;
 149                 if (isalnum(c))
 150                         *s = tolower(c);
 151                 else if (c != '.' && c != '/')
 152                         *s = '-';
 153                 s++;
 154         }
 155
 156         ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
 157         if (ret != 0) {
 158                 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
 159                 kfree(*filename);
 160                 *filename = NULL;
 161         }
 162
 163         return ret;
 164 }
 165
 166 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
 167                                                 const struct firmware **wmfw_firmware,
 168                                                 char **wmfw_filename,
 169                                                 const struct firmware **coeff_firmware,
 170                                                 char **coeff_filename)
 171 {
 172         int ret;
 173
 174         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.wmfw */
 175         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 176                                             CS35L41_FIRMWARE_ROOT,
 177                                             cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 178                                             cs35l41->speaker_id, "wmfw");
 179         if (!ret) {
 180                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 181                 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 182                                                      CS35L41_FIRMWARE_ROOT,
 183                                                      cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 184                                                      cs35l41->speaker_id, "bin");
 185         }
 186
 187         /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
 188         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 189                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 190                                             cs35l41->amp_name, -1, "wmfw");
 191         if (!ret) {
 192                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 193                 return cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 194                                                      CS35L41_FIRMWARE_ROOT,
 195                                                      cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 196                                                      cs35l41->speaker_id, "bin");
 197         }
 198
 199         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */
 200         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 201                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 202                                             NULL, cs35l41->speaker_id, "wmfw");
 203         if (!ret) {
 204                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 205                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 206                                                     CS35L41_FIRMWARE_ROOT,
 207                                                     cs35l41->acpi_subsystem_id,
 208                                                     cs35l41->amp_name, cs35l41->speaker_id, "bin");
 209                 if (ret)
 210                         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
 211                         return cs35l41_request_firmware_file(cs35l41, coeff_firmware,
 212                                                              coeff_filename, CS35L41_FIRMWARE_ROOT,
 213                                                              cs35l41->acpi_subsystem_id, NULL,
 214                                                              cs35l41->speaker_id, "bin");
 215         }
 216
 217         /* try cirrus/part-dspN-fwtype-sub.wmfw */
 218         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 219                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 220                                             NULL, -1, "wmfw");
 221         if (!ret) {
 222                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 223                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 224                                                     CS35L41_FIRMWARE_ROOT,
 225                                                     cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 226                                                     cs35l41->speaker_id, "bin");
 227                 if (ret)
 228                         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
 229                         return cs35l41_request_firmware_file(cs35l41, coeff_firmware,
 230                                                              coeff_filename, CS35L41_FIRMWARE_ROOT,
 231                                                              cs35l41->acpi_subsystem_id, NULL,
 232                                                              cs35l41->speaker_id, "bin");
 233         }
 234
 235         return ret;
 236 }
 237
 238 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
 239                                           const struct firmware **wmfw_firmware,
 240                                           char **wmfw_filename,
 241                                           const struct firmware **coeff_firmware,
 242                                           char **coeff_filename)
 243 {
 244         int ret;
 245
 246         if (cs35l41->speaker_id > -1) {
 247                 ret = cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
 248                                                            coeff_firmware, coeff_filename);
 249                 goto out;
 250
 251         }
 252
 253         /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
 254         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 255                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 256                                             cs35l41->amp_name, -1, "wmfw");
 257         if (!ret) {
 258                 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
 259                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 260                                                     CS35L41_FIRMWARE_ROOT,
 261                                                     cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 262                                                     -1, "bin");
 263                 goto out;
 264         }
 265
 266         /* try cirrus/part-dspN-fwtype-sub.wmfw */
 267         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 268                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 269                                             NULL, -1, "wmfw");
 270         if (!ret) {
 271                 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
 272                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 273                                                     CS35L41_FIRMWARE_ROOT,
 274                                                     cs35l41->acpi_subsystem_id,
 275                                                     cs35l41->amp_name, -1, "bin");
 276                 if (ret)
 277                         /* try cirrus/part-dspN-fwtype-sub.bin */
 278                         ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 279                                                             CS35L41_FIRMWARE_ROOT,
 280                                                             cs35l41->acpi_subsystem_id, NULL, -1,
 281                                                             "bin");
 282         }
 283
 284 out:
 285         if (!ret)
 286                 return 0;
 287
 288         /* Handle fallback */
 289         dev_warn(cs35l41->dev, "Falling back to default firmware.\n");
 290
 291         release_firmware(*wmfw_firmware);
 292         kfree(*wmfw_filename);
 293
 294         /* fallback try cirrus/part-dspN-fwtype.wmfw */
 295         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 296                                             CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
 297         if (!ret)
 298                 /* fallback try cirrus/part-dspN-fwtype.bin */
 299                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 300                                                     CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
 301
 302         if (ret) {
 303                 release_firmware(*wmfw_firmware);
 304                 kfree(*wmfw_filename);
 305                 dev_warn(cs35l41->dev, "Unable to find firmware and tuning\n");
 306         }
 307         return ret;
 308 }
 309
 310 #if IS_ENABLED(CONFIG_EFI)
 311 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, __be32 ambient, __be32 r0,
 312                                      __be32 status, __be32 checksum)
 313 {
 314         int ret;
 315
 316         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 317                                    CAL_DSP_CTL_ALG, &ambient, 4);
 318         if (ret) {
 319                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
 320                         ret);
 321                 return ret;
 322         }
 323         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 324                                    CAL_DSP_CTL_ALG, &r0, 4);
 325         if (ret) {
 326                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
 327                 return ret;
 328         }
 329         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 330                                    CAL_DSP_CTL_ALG, &status, 4);
 331         if (ret) {
 332                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
 333                         ret);
 334                 return ret;
 335         }
 336         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 337                                    CAL_DSP_CTL_ALG, &checksum, 4);
 338         if (ret) {
 339                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
 340                         ret);
 341                 return ret;
 342         }
 343
 344         return 0;
 345 }
 346
 347 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
 348 {
 349         static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe,
 350                                               0x5a, 0xa3, 0x5d, 0xb3);
 351         static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData";
 352         const struct cs35l41_amp_efi_data *efi_data;
 353         const struct cs35l41_amp_cal_data *cl;
 354         unsigned long data_size = 0;
 355         efi_status_t status;
 356         int ret = 0;
 357         u8 *data = NULL;
 358         u32 attr;
 359
 360         /* Get real size of UEFI variable */
 361         status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
 362         if (status == EFI_BUFFER_TOO_SMALL) {
 363                 ret = -ENODEV;
 364                 /* Allocate data buffer of data_size bytes */
 365                 data = vmalloc(data_size);
 366                 if (!data)
 367                         return -ENOMEM;
 368                 /* Get variable contents into buffer */
 369                 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
 370                 if (status == EFI_SUCCESS) {
 371                         efi_data = (struct cs35l41_amp_efi_data *)data;
 372                         dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
 373                                 efi_data->size, efi_data->count);
 374                         if (efi_data->count > cs35l41->index) {
 375                                 cl = &efi_data->data[cs35l41->index];
 376                                 dev_dbg(cs35l41->dev,
 377                                         "Calibration: Ambient=%02x, Status=%02x, R0=%d\n",
 378                                         cl->calAmbient, cl->calStatus, cl->calR);
 379
 380                                 /* Calibration can only be applied whilst the DSP is not running */
 381                                 ret = cs35l41_apply_calibration(cs35l41,
 382                                                                 cpu_to_be32(cl->calAmbient),
 383                                                                 cpu_to_be32(cl->calR),
 384                                                                 cpu_to_be32(cl->calStatus),
 385                                                                 cpu_to_be32(cl->calR + 1));
 386                         }
 387                 }
 388                 vfree(data);
 389         }
 390         return ret;
 391 }
 392 #else
 393 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
 394 {
 395         dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
 396         return 0;
 397 }
 398 #endif
 399
 400 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
 401 {
 402         const struct firmware *coeff_firmware = NULL;
 403         const struct firmware *wmfw_firmware = NULL;
 404         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 405         char *coeff_filename = NULL;
 406         char *wmfw_filename = NULL;
 407         int ret;
 408
 409         if (!cs35l41->halo_initialized) {
 410                 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
 411                 dsp->client_ops = &client_ops;
 412
 413                 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
 414                 if (ret)
 415                         return ret;
 416                 cs35l41->halo_initialized = true;
 417         }
 418
 419         ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
 420                                              &coeff_firmware, &coeff_filename);
 421         if (ret < 0)
 422                 return ret;
 423
 424         dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
 425         if (coeff_filename)
 426                 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
 427         else
 428                 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
 429
 430         ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename,
 431                               hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
 432         if (ret)
 433                 goto err_release;
 434
 435         cs35l41_add_controls(cs35l41);
 436
 437         ret = cs35l41_save_calibration(cs35l41);
 438
 439 err_release:
 440         release_firmware(wmfw_firmware);
 441         release_firmware(coeff_firmware);
 442         kfree(wmfw_filename);
 443         kfree(coeff_filename);
 444
 445         return ret;
 446 }
 447
 448 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
 449 {
 450         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 451
 452         cs_dsp_stop(dsp);
 453         cs_dsp_power_down(dsp);
 454         cs35l41->firmware_running = false;
 455         dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
 456 }
 457
 458 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
 459 {
 460         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 461
 462         cancel_work_sync(&cs35l41->fw_load_work);
 463
 464         mutex_lock(&cs35l41->fw_mutex);
 465         cs35l41_shutdown_dsp(cs35l41);
 466         cs_dsp_remove(dsp);
 467         cs35l41->halo_initialized = false;
 468         mutex_unlock(&cs35l41->fw_mutex);
 469 }
 470
 471 /* Protection release cycle to get the speaker out of Safe-Mode */
 472 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask)
 473 {
 474         regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0);
 475         regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
 476         regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
 477 }
 478
 479 /* Clear all errors to release safe mode. Global Enable must be cleared first. */
 480 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
 481 {
 482         cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
 483         cs35l41->irq_errors = 0;
 484 }
 485
 486 static void cs35l41_hda_play_start(struct device *dev)
 487 {
 488         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 489         struct regmap *reg = cs35l41->regmap;
 490
 491         dev_dbg(dev, "Play (Start)\n");
 492
 493         if (cs35l41->playback_started) {
 494                 dev_dbg(dev, "Playback already started.");
 495                 return;
 496         }
 497
 498         cs35l41->playback_started = true;
 499
 500         if (cs35l41->firmware_running) {
 501                 regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
 502                                        ARRAY_SIZE(cs35l41_hda_config_dsp));
 503                 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
 504                                    CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
 505                                    1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
 506                 cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
 507         } else {
 508                 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config));
 509         }
 510         regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
 511         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 512                 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
 513
 514 }
 515
 516 static void cs35l41_hda_play_done(struct device *dev)
 517 {
 518         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 519         struct regmap *reg = cs35l41->regmap;
 520
 521         dev_dbg(dev, "Play (Complete)\n");
 522
 523         cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
 524                               cs35l41->firmware_running);
 525 }
 526
 527 static void cs35l41_hda_pause_start(struct device *dev)
 528 {
 529         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 530         struct regmap *reg = cs35l41->regmap;
 531
 532         dev_dbg(dev, "Pause (Start)\n");
 533
 534         regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
 535         cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL,
 536                               cs35l41->firmware_running);
 537 }
 538
 539 static void cs35l41_hda_pause_done(struct device *dev)
 540 {
 541         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 542         struct regmap *reg = cs35l41->regmap;
 543
 544         dev_dbg(dev, "Pause (Complete)\n");
 545
 546         regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
 547         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 548                 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
 549         if (cs35l41->firmware_running) {
 550                 cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE);
 551                 regmap_update_bits(reg, CS35L41_PWR_CTRL2,
 552                                    CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
 553                                    0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
 554         }
 555         cs35l41_irq_release(cs35l41);
 556         cs35l41->playback_started = false;
 557 }
 558
 559 static void cs35l41_hda_playback_hook(struct device *dev, int action)
 560 {
 561         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 562
 563         switch (action) {
 564         case HDA_GEN_PCM_ACT_OPEN:
 565                 pm_runtime_get_sync(dev);
 566                 mutex_lock(&cs35l41->fw_mutex);
 567                 cs35l41_hda_play_start(dev);
 568                 mutex_unlock(&cs35l41->fw_mutex);
 569                 break;
 570         case HDA_GEN_PCM_ACT_PREPARE:
 571                 mutex_lock(&cs35l41->fw_mutex);
 572                 cs35l41_hda_play_done(dev);
 573                 mutex_unlock(&cs35l41->fw_mutex);
 574                 break;
 575         case HDA_GEN_PCM_ACT_CLEANUP:
 576                 mutex_lock(&cs35l41->fw_mutex);
 577                 cs35l41_hda_pause_start(dev);
 578                 mutex_unlock(&cs35l41->fw_mutex);
 579                 break;
 580         case HDA_GEN_PCM_ACT_CLOSE:
 581                 mutex_lock(&cs35l41->fw_mutex);
 582                 cs35l41_hda_pause_done(dev);
 583                 mutex_unlock(&cs35l41->fw_mutex);
 584
 585                 pm_runtime_mark_last_busy(dev);
 586                 pm_runtime_put_autosuspend(dev);
 587                 break;
 588         default:
 589                 dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action);
 590                 break;
 591         }
 592 }
 593
 594 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot,
 595                                     unsigned int rx_num, unsigned int *rx_slot)
 596 {
 597         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 598         static const char * const channel_name[] = { "L", "R" };
 599
 600         if (!cs35l41->amp_name) {
 601                 if (*rx_slot >= ARRAY_SIZE(channel_name))
 602                         return -EINVAL;
 603
 604                 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
 605                                                    channel_name[*rx_slot], cs35l41->channel_index);
 606                 if (!cs35l41->amp_name)
 607                         return -ENOMEM;
 608         }
 609
 610         return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
 611                                     rx_slot);
 612 }
 613
 614 static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
 615 {
 616         int ret = 0;
 617
 618         mutex_lock(&cs35l41->fw_mutex);
 619         if (cs35l41->firmware_running) {
 620
 621                 regcache_cache_only(cs35l41->regmap, false);
 622
 623                 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
 624                 if (ret) {
 625                         dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
 626                         goto err;
 627                 }
 628
 629                 /* Test key needs to be unlocked to allow the OTP settings to re-apply */
 630                 cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
 631                 ret = regcache_sync(cs35l41->regmap);
 632                 cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
 633                 if (ret) {
 634                         dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
 635                         goto err;
 636                 }
 637
 638                 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 639                         cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
 640
 641                 cs35l41_shutdown_dsp(cs35l41);
 642                 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
 643         }
 644 err:
 645         regcache_cache_only(cs35l41->regmap, true);
 646         regcache_mark_dirty(cs35l41->regmap);
 647
 648         mutex_unlock(&cs35l41->fw_mutex);
 649
 650         return ret;
 651 }
 652
 653 static int cs35l41_system_suspend(struct device *dev)
 654 {
 655         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 656         int ret;
 657
 658         dev_dbg(cs35l41->dev, "System Suspend\n");
 659
 660         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
 661                 dev_err_once(cs35l41->dev, "System Suspend not supported\n");
 662                 return 0; /* don't block the whole system suspend */
 663         }
 664
 665         ret = pm_runtime_force_suspend(dev);
 666         if (ret) {
 667                 dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret);
 668                 return ret;
 669         }
 670
 671         /* Shutdown DSP before system suspend */
 672         ret = cs35l41_ready_for_reset(cs35l41);
 673
 674         if (ret)
 675                 dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret);
 676
 677         /*
 678          * Reset GPIO may be shared, so cannot reset here.
 679          * However beyond this point, amps may be powered down.
 680          */
 681         return ret;
 682 }
 683
 684 static int cs35l41_system_resume(struct device *dev)
 685 {
 686         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 687         int ret;
 688
 689         dev_dbg(cs35l41->dev, "System Resume\n");
 690
 691         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
 692                 dev_err_once(cs35l41->dev, "System Resume not supported\n");
 693                 return 0; /* don't block the whole system resume */
 694         }
 695
 696         if (cs35l41->reset_gpio) {
 697                 usleep_range(2000, 2100);
 698                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
 699         }
 700
 701         usleep_range(2000, 2100);
 702
 703         ret = pm_runtime_force_resume(dev);
 704         if (ret) {
 705                 dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret);
 706                 return ret;
 707         }
 708
 709         mutex_lock(&cs35l41->fw_mutex);
 710         if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
 711                 cs35l41->fw_request_ongoing = true;
 712                 schedule_work(&cs35l41->fw_load_work);
 713         }
 714         mutex_unlock(&cs35l41->fw_mutex);
 715
 716         return ret;
 717 }
 718
 719 static int cs35l41_runtime_idle(struct device *dev)
 720 {
 721         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 722
 723         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH)
 724                 return -EBUSY; /* suspend not supported yet on this model */
 725         return 0;
 726 }
 727
 728 static int cs35l41_runtime_suspend(struct device *dev)
 729 {
 730         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 731         int ret = 0;
 732
 733         dev_dbg(cs35l41->dev, "Runtime Suspend\n");
 734
 735         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
 736                 dev_dbg(cs35l41->dev, "Runtime Suspend not supported\n");
 737                 return 0;
 738         }
 739
 740         mutex_lock(&cs35l41->fw_mutex);
 741
 742         if (cs35l41->playback_started) {
 743                 cs35l41_hda_pause_start(dev);
 744                 cs35l41_hda_pause_done(dev);
 745         }
 746
 747         if (cs35l41->firmware_running) {
 748                 ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
 749                                               cs35l41->hw_cfg.bst_type);
 750                 if (ret)
 751                         goto err;
 752         } else {
 753                 cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
 754         }
 755
 756         regcache_cache_only(cs35l41->regmap, true);
 757         regcache_mark_dirty(cs35l41->regmap);
 758
 759 err:
 760         mutex_unlock(&cs35l41->fw_mutex);
 761
 762         return ret;
 763 }
 764
 765 static int cs35l41_runtime_resume(struct device *dev)
 766 {
 767         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 768         int ret = 0;
 769
 770         dev_dbg(cs35l41->dev, "Runtime Resume\n");
 771
 772         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
 773                 dev_dbg(cs35l41->dev, "Runtime Resume not supported\n");
 774                 return 0;
 775         }
 776
 777         mutex_lock(&cs35l41->fw_mutex);
 778
 779         regcache_cache_only(cs35l41->regmap, false);
 780
 781         if (cs35l41->firmware_running)  {
 782                 ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
 783                 if (ret) {
 784                         dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
 785                         goto err;
 786                 }
 787         }
 788
 789         /* Test key needs to be unlocked to allow the OTP settings to re-apply */
 790         cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
 791         ret = regcache_sync(cs35l41->regmap);
 792         cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
 793         if (ret) {
 794                 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
 795                 goto err;
 796         }
 797
 798         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 799                 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
 800
 801 err:
 802         mutex_unlock(&cs35l41->fw_mutex);
 803
 804         return ret;
 805 }
 806
 807 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
 808 {
 809         __be32 halo_sts;
 810         int ret;
 811
 812         ret = cs35l41_init_dsp(cs35l41);
 813         if (ret) {
 814                 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
 815                 goto clean_dsp;
 816         }
 817
 818         ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
 819         if (ret) {
 820                 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
 821                 goto clean_dsp;
 822         }
 823
 824         ret = cs_dsp_run(&cs35l41->cs_dsp);
 825         if (ret) {
 826                 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
 827                 goto clean_dsp;
 828         }
 829
 830         ret = read_poll_timeout(hda_cs_dsp_read_ctl, ret,
 831                                 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN,
 832                                 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
 833                                 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG,
 834                                 &halo_sts, sizeof(halo_sts));
 835
 836         if (ret) {
 837                 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %u\n",
 838                          halo_sts);
 839                 goto clean_dsp;
 840         }
 841
 842         ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
 843         if (ret) {
 844                 dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
 845                 goto clean_dsp;
 846         }
 847
 848         cs35l41->firmware_running = true;
 849
 850         return 0;
 851
 852 clean_dsp:
 853         cs35l41_shutdown_dsp(cs35l41);
 854         return ret;
 855 }
 856
 857 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
 858 {
 859         if (cs35l41->firmware_running && !load) {
 860                 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
 861                 cs35l41_shutdown_dsp(cs35l41);
 862         } else if (!cs35l41->firmware_running && load) {
 863                 dev_dbg(cs35l41->dev, "Loading Firmware\n");
 864                 cs35l41_smart_amp(cs35l41);
 865         } else {
 866                 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
 867         }
 868 }
 869
 870 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
 871                                    struct snd_ctl_elem_value *ucontrol)
 872 {
 873         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 874
 875         ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
 876         return 0;
 877 }
 878
 879 static void cs35l41_fw_load_work(struct work_struct *work)
 880 {
 881         struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
 882
 883         pm_runtime_get_sync(cs35l41->dev);
 884
 885         mutex_lock(&cs35l41->fw_mutex);
 886
 887         /* Recheck if playback is ongoing, mutex will block playback during firmware loading */
 888         if (cs35l41->playback_started)
 889                 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback. Retrying...\n");
 890         else
 891                 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
 892
 893         cs35l41->fw_request_ongoing = false;
 894         mutex_unlock(&cs35l41->fw_mutex);
 895
 896         pm_runtime_mark_last_busy(cs35l41->dev);
 897         pm_runtime_put_autosuspend(cs35l41->dev);
 898 }
 899
 900 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
 901                                    struct snd_ctl_elem_value *ucontrol)
 902 {
 903         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 904
 905         if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
 906                 return 0;
 907
 908         if (cs35l41->fw_request_ongoing) {
 909                 dev_dbg(cs35l41->dev, "Existing request not complete\n");
 910                 return -EBUSY;
 911         }
 912
 913         /* Check if playback is ongoing when initial request is made */
 914         if (cs35l41->playback_started) {
 915                 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
 916                 return -EBUSY;
 917         }
 918
 919         cs35l41->fw_request_ongoing = true;
 920         cs35l41->request_fw_load = ucontrol->value.integer.value[0];
 921         schedule_work(&cs35l41->fw_load_work);
 922
 923         return 1;
 924 }
 925
 926 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol,
 927                                    struct snd_ctl_elem_value *ucontrol)
 928 {
 929         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 930
 931         ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
 932
 933         return 0;
 934 }
 935
 936 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol,
 937                                    struct snd_ctl_elem_value *ucontrol)
 938 {
 939         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 940
 941         if (ucontrol->value.enumerated.item[0] < HDA_CS_DSP_NUM_FW) {
 942                 if (cs35l41->firmware_type != ucontrol->value.enumerated.item[0]) {
 943                         cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
 944                         return 1;
 945                 } else {
 946                         return 0;
 947                 }
 948         }
 949
 950         return -EINVAL;
 951 }
 952
 953 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 954 {
 955         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(hda_cs_dsp_fw_ids), hda_cs_dsp_fw_ids);
 956 }
 957
 958 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
 959 {
 960         char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 961         char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 962         struct snd_kcontrol_new fw_type_ctl = {
 963                 .name = fw_type_ctl_name,
 964                 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 965                 .info = cs35l41_fw_type_ctl_info,
 966                 .get = cs35l41_fw_type_ctl_get,
 967                 .put = cs35l41_fw_type_ctl_put,
 968         };
 969         struct snd_kcontrol_new fw_load_ctl = {
 970                 .name = fw_load_ctl_name,
 971                 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 972                 .info = snd_ctl_boolean_mono_info,
 973                 .get = cs35l41_fw_load_ctl_get,
 974                 .put = cs35l41_fw_load_ctl_put,
 975         };
 976         int ret;
 977
 978         scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type",
 979                   cs35l41->amp_name);
 980         scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load",
 981                   cs35l41->amp_name);
 982
 983         ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
 984         if (ret) {
 985                 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
 986                 return ret;
 987         }
 988
 989         dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
 990
 991         ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
 992         if (ret) {
 993                 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
 994                 return ret;
 995         }
 996
 997         dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
 998
 999         return 0;
1000 }
1001
1002 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
1003 {
1004         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1005         struct hda_component *comps = master_data;
1006         int ret = 0;
1007
1008         if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
1009                 return -EINVAL;
1010
1011         comps = &comps[cs35l41->index];
1012         if (comps->dev)
1013                 return -EBUSY;
1014
1015         pm_runtime_get_sync(dev);
1016
1017         mutex_lock(&cs35l41->fw_mutex);
1018
1019         comps->dev = dev;
1020         if (!cs35l41->acpi_subsystem_id)
1021                 cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
1022                                                        comps->codec->core.subsystem_id);
1023         cs35l41->codec = comps->codec;
1024         strscpy(comps->name, dev_name(dev), sizeof(comps->name));
1025
1026         cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
1027
1028         if (firmware_autostart) {
1029                 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
1030                 cs35l41->request_fw_load = true;
1031                 if (cs35l41_smart_amp(cs35l41) < 0)
1032                         dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
1033         } else {
1034                 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
1035         }
1036
1037         ret = cs35l41_create_controls(cs35l41);
1038
1039         comps->playback_hook = cs35l41_hda_playback_hook;
1040
1041         mutex_unlock(&cs35l41->fw_mutex);
1042
1043         pm_runtime_mark_last_busy(dev);
1044         pm_runtime_put_autosuspend(dev);
1045
1046         return ret;
1047 }
1048
1049 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
1050 {
1051         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1052         struct hda_component *comps = master_data;
1053
1054         if (comps[cs35l41->index].dev == dev)
1055                 memset(&comps[cs35l41->index], 0, sizeof(*comps));
1056 }
1057
1058 static const struct component_ops cs35l41_hda_comp_ops = {
1059         .bind = cs35l41_hda_bind,
1060         .unbind = cs35l41_hda_unbind,
1061 };
1062
1063 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
1064 {
1065         struct cs35l41_hda *cs35l41 = data;
1066
1067         dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
1068         set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1069
1070         return IRQ_HANDLED;
1071 }
1072
1073 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
1074 {
1075         struct cs35l41_hda *cs35l41 = data;
1076
1077         dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
1078         set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1079
1080         return IRQ_HANDLED;
1081 }
1082
1083 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
1084 {
1085         struct cs35l41_hda *cs35l41 = data;
1086
1087         dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
1088         set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1089
1090         return IRQ_HANDLED;
1091 }
1092
1093 static irqreturn_t cs35l41_temp_err(int irq, void *data)
1094 {
1095         struct cs35l41_hda *cs35l41 = data;
1096
1097         dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
1098         set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1099
1100         return IRQ_HANDLED;
1101 }
1102
1103 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
1104 {
1105         struct cs35l41_hda *cs35l41 = data;
1106
1107         dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
1108         set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1109
1110         return IRQ_HANDLED;
1111 }
1112
1113 static irqreturn_t cs35l41_amp_short(int irq, void *data)
1114 {
1115         struct cs35l41_hda *cs35l41 = data;
1116
1117         dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
1118         set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
1119
1120         return IRQ_HANDLED;
1121 }
1122
1123 static const struct cs35l41_irq cs35l41_irqs[] = {
1124         CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
1125         CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
1126         CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
1127         CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
1128         CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
1129         CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
1130 };
1131
1132 static const struct regmap_irq cs35l41_reg_irqs[] = {
1133         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
1134         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
1135         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
1136         CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
1137         CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
1138         CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
1139 };
1140
1141 static struct regmap_irq_chip cs35l41_regmap_irq_chip = {
1142         .name = "cs35l41 IRQ1 Controller",
1143         .status_base = CS35L41_IRQ1_STATUS1,
1144         .mask_base = CS35L41_IRQ1_MASK1,
1145         .ack_base = CS35L41_IRQ1_STATUS1,
1146         .num_regs = 4,
1147         .irqs = cs35l41_reg_irqs,
1148         .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
1149         .runtime_pm = true,
1150 };
1151
1152 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
1153 {
1154         struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1155         bool using_irq = false;
1156         int irq, irq_pol;
1157         int ret;
1158         int i;
1159
1160         if (!cs35l41->hw_cfg.valid)
1161                 return -EINVAL;
1162
1163         ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
1164         if (ret)
1165                 return ret;
1166
1167         if (hw_cfg->gpio1.valid) {
1168                 switch (hw_cfg->gpio1.func) {
1169                 case CS35L41_NOT_USED:
1170                         break;
1171                 case CS35l41_VSPK_SWITCH:
1172                         hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
1173                         hw_cfg->gpio1.out_en = true;
1174                         break;
1175                 case CS35l41_SYNC:
1176                         hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC;
1177                         break;
1178                 default:
1179                         dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n",
1180                                 hw_cfg->gpio1.func);
1181                         return -EINVAL;
1182                 }
1183         }
1184
1185         if (hw_cfg->gpio2.valid) {
1186                 switch (hw_cfg->gpio2.func) {
1187                 case CS35L41_NOT_USED:
1188                         break;
1189                 case CS35L41_INTERRUPT:
1190                         using_irq = true;
1191                         hw_cfg->gpio2.func = CS35L41_GPIO2_INT_OPEN_DRAIN;
1192                         break;
1193                 default:
1194                         dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func);
1195                         return -EINVAL;
1196                 }
1197         }
1198
1199         irq_pol = cs35l41_gpio_config(cs35l41->regmap, hw_cfg);
1200
1201         if (cs35l41->irq && using_irq) {
1202                 ret = devm_regmap_add_irq_chip(cs35l41->dev, cs35l41->regmap, cs35l41->irq,
1203                                                IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1204                                                0, &cs35l41_regmap_irq_chip, &cs35l41->irq_data);
1205                 if (ret)
1206                         return ret;
1207
1208                 for (i = 0; i < ARRAY_SIZE(cs35l41_irqs); i++) {
1209                         irq = regmap_irq_get_virq(cs35l41->irq_data, cs35l41_irqs[i].irq);
1210                         if (irq < 0)
1211                                 return irq;
1212
1213                         ret = devm_request_threaded_irq(cs35l41->dev, irq, NULL,
1214                                                         cs35l41_irqs[i].handler,
1215                                                         IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1216                                                         cs35l41_irqs[i].name, cs35l41);
1217                         if (ret)
1218                                 return ret;
1219                 }
1220         }
1221
1222         return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos);
1223 }
1224
1225 static int cs35l41_get_speaker_id(struct device *dev, int amp_index,
1226                                   int num_amps, int fixed_gpio_id)
1227 {
1228         struct gpio_desc *speaker_id_desc;
1229         int speaker_id = -ENODEV;
1230
1231         if (fixed_gpio_id >= 0) {
1232                 dev_dbg(dev, "Found Fixed Speaker ID GPIO (index = %d)\n", fixed_gpio_id);
1233                 speaker_id_desc = gpiod_get_index(dev, NULL, fixed_gpio_id, GPIOD_IN);
1234                 if (IS_ERR(speaker_id_desc)) {
1235                         speaker_id = PTR_ERR(speaker_id_desc);
1236                         return speaker_id;
1237                 }
1238                 speaker_id = gpiod_get_value_cansleep(speaker_id_desc);
1239                 gpiod_put(speaker_id_desc);
1240                 dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1241         } else {
1242                 int base_index;
1243                 int gpios_per_amp;
1244                 int count;
1245                 int tmp;
1246                 int i;
1247
1248                 count = gpiod_count(dev, "spk-id");
1249                 if (count > 0) {
1250                         speaker_id = 0;
1251                         gpios_per_amp = count / num_amps;
1252                         base_index = gpios_per_amp * amp_index;
1253
1254                         if (count % num_amps)
1255                                 return -EINVAL;
1256
1257                         dev_dbg(dev, "Found %d Speaker ID GPIOs per Amp\n", gpios_per_amp);
1258
1259                         for (i = 0; i < gpios_per_amp; i++) {
1260                                 speaker_id_desc = gpiod_get_index(dev, "spk-id", i + base_index,
1261                                                                   GPIOD_IN);
1262                                 if (IS_ERR(speaker_id_desc)) {
1263                                         speaker_id = PTR_ERR(speaker_id_desc);
1264                                         break;
1265                                 }
1266                                 tmp = gpiod_get_value_cansleep(speaker_id_desc);
1267                                 gpiod_put(speaker_id_desc);
1268                                 if (tmp < 0) {
1269                                         speaker_id = tmp;
1270                                         break;
1271                                 }
1272                                 speaker_id |= tmp << i;
1273                         }
1274                         dev_dbg(dev, "Speaker ID = %d\n", speaker_id);
1275                 }
1276         }
1277         return speaker_id;
1278 }
1279
1280 /*
1281  * Device CLSA010(0/1) doesn't have _DSD so a gpiod_get by the label reset won't work.
1282  * And devices created by serial-multi-instantiate don't have their device struct
1283  * pointing to the correct fwnode, so acpi_dev must be used here.
1284  * And devm functions expect that the device requesting the resource has the correct
1285  * fwnode.
1286  */
1287 static int cs35l41_no_acpi_dsd(struct cs35l41_hda *cs35l41, struct device *physdev, int id,
1288                                const char *hid)
1289 {
1290         struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1291
1292         /* check I2C address to assign the index */
1293         cs35l41->index = id == 0x40 ? 0 : 1;
1294         cs35l41->channel_index = 0;
1295         cs35l41->reset_gpio = gpiod_get_index(physdev, NULL, 0, GPIOD_OUT_HIGH);
1296         cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, 0, 0, 2);
1297         hw_cfg->spk_pos = cs35l41->index;
1298         hw_cfg->gpio2.func = CS35L41_INTERRUPT;
1299         hw_cfg->gpio2.valid = true;
1300         hw_cfg->valid = true;
1301
1302         if (strncmp(hid, "CLSA0100", 8) == 0) {
1303                 hw_cfg->bst_type = CS35L41_EXT_BOOST_NO_VSPK_SWITCH;
1304         } else if (strncmp(hid, "CLSA0101", 8) == 0) {
1305                 hw_cfg->bst_type = CS35L41_EXT_BOOST;
1306                 hw_cfg->gpio1.func = CS35l41_VSPK_SWITCH;
1307                 hw_cfg->gpio1.valid = true;
1308         } else {
1309                 /*
1310                  * Note: CLSA010(0/1) are special cases which use a slightly different design.
1311                  * All other HIDs e.g. CSC3551 require valid ACPI _DSD properties to be supported.
1312                  */
1313                 dev_err(cs35l41->dev, "Error: ACPI _DSD Properties are missing for HID %s.\n", hid);
1314                 hw_cfg->valid = false;
1315                 hw_cfg->gpio1.valid = false;
1316                 hw_cfg->gpio2.valid = false;
1317                 return -EINVAL;
1318         }
1319
1320         return 0;
1321 }
1322
1323 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1324 {
1325         struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1326         u32 values[HDA_MAX_COMPONENTS];
1327         struct acpi_device *adev;
1328         struct device *physdev;
1329         const char *sub;
1330         char *property;
1331         size_t nval;
1332         int i, ret;
1333
1334         adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1335         if (!adev) {
1336                 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1337                 return -ENODEV;
1338         }
1339
1340         physdev = get_device(acpi_get_first_physical_node(adev));
1341         acpi_dev_put(adev);
1342
1343         sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
1344         if (IS_ERR(sub))
1345                 sub = NULL;
1346         cs35l41->acpi_subsystem_id = sub;
1347
1348         property = "cirrus,dev-index";
1349         ret = device_property_count_u32(physdev, property);
1350         if (ret <= 0) {
1351                 ret = cs35l41_no_acpi_dsd(cs35l41, physdev, id, hid);
1352                 goto err_put_physdev;
1353         }
1354         if (ret > ARRAY_SIZE(values)) {
1355                 ret = -EINVAL;
1356                 goto err;
1357         }
1358         nval = ret;
1359
1360         ret = device_property_read_u32_array(physdev, property, values, nval);
1361         if (ret)
1362                 goto err;
1363
1364         cs35l41->index = -1;
1365         for (i = 0; i < nval; i++) {
1366                 if (values[i] == id) {
1367                         cs35l41->index = i;
1368                         break;
1369                 }
1370         }
1371         if (cs35l41->index == -1) {
1372                 dev_err(cs35l41->dev, "No index found in %s\n", property);
1373                 ret = -ENODEV;
1374                 goto err;
1375         }
1376
1377         /* To use the same release code for all laptop variants we can't use devm_ version of
1378          * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1379          */
1380         cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1381                                                      GPIOD_OUT_LOW, "cs35l41-reset");
1382
1383         property = "cirrus,speaker-position";
1384         ret = device_property_read_u32_array(physdev, property, values, nval);
1385         if (ret)
1386                 goto err;
1387         hw_cfg->spk_pos = values[cs35l41->index];
1388
1389         cs35l41->channel_index = 0;
1390         for (i = 0; i < cs35l41->index; i++)
1391                 if (values[i] == hw_cfg->spk_pos)
1392                         cs35l41->channel_index++;
1393
1394         property = "cirrus,gpio1-func";
1395         ret = device_property_read_u32_array(physdev, property, values, nval);
1396         if (ret)
1397                 goto err;
1398         hw_cfg->gpio1.func = values[cs35l41->index];
1399         hw_cfg->gpio1.valid = true;
1400
1401         property = "cirrus,gpio2-func";
1402         ret = device_property_read_u32_array(physdev, property, values, nval);
1403         if (ret)
1404                 goto err;
1405         hw_cfg->gpio2.func = values[cs35l41->index];
1406         hw_cfg->gpio2.valid = true;
1407
1408         property = "cirrus,boost-peak-milliamp";
1409         ret = device_property_read_u32_array(physdev, property, values, nval);
1410         if (ret == 0)
1411                 hw_cfg->bst_ipk = values[cs35l41->index];
1412         else
1413                 hw_cfg->bst_ipk = -1;
1414
1415         property = "cirrus,boost-ind-nanohenry";
1416         ret = device_property_read_u32_array(physdev, property, values, nval);
1417         if (ret == 0)
1418                 hw_cfg->bst_ind = values[cs35l41->index];
1419         else
1420                 hw_cfg->bst_ind = -1;
1421
1422         property = "cirrus,boost-cap-microfarad";
1423         ret = device_property_read_u32_array(physdev, property, values, nval);
1424         if (ret == 0)
1425                 hw_cfg->bst_cap = values[cs35l41->index];
1426         else
1427                 hw_cfg->bst_cap = -1;
1428
1429         cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1430
1431         if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1432                 hw_cfg->bst_type = CS35L41_INT_BOOST;
1433         else
1434                 hw_cfg->bst_type = CS35L41_EXT_BOOST;
1435
1436         hw_cfg->valid = true;
1437         put_device(physdev);
1438
1439         return 0;
1440
1441 err:
1442         dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1443 err_put_physdev:
1444         put_device(physdev);
1445
1446         return ret;
1447 }
1448
1449 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1450                       struct regmap *regmap)
1451 {
1452         unsigned int int_sts, regid, reg_revid, mtl_revid, chipid, int_status;
1453         struct cs35l41_hda *cs35l41;
1454         int ret;
1455
1456         BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1457         BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1458
1459         if (IS_ERR(regmap))
1460                 return PTR_ERR(regmap);
1461
1462         cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1463         if (!cs35l41)
1464                 return -ENOMEM;
1465
1466         cs35l41->dev = dev;
1467         cs35l41->irq = irq;
1468         cs35l41->regmap = regmap;
1469         dev_set_drvdata(dev, cs35l41);
1470
1471         ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1472         if (ret)
1473                 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1474
1475         if (IS_ERR(cs35l41->reset_gpio)) {
1476                 ret = PTR_ERR(cs35l41->reset_gpio);
1477                 cs35l41->reset_gpio = NULL;
1478                 if (ret == -EBUSY) {
1479                         dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1480                 } else {
1481                         dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1482                         goto err;
1483                 }
1484         }
1485         if (cs35l41->reset_gpio) {
1486                 usleep_range(2000, 2100);
1487                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1488         }
1489
1490         usleep_range(2000, 2100);
1491
1492         ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
1493                                        int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
1494         if (ret) {
1495                 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1496                 goto err;
1497         }
1498
1499         ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts);
1500         if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) {
1501                 dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n",
1502                         int_sts & CS35L41_OTP_BOOT_ERR, ret);
1503                 ret = -EIO;
1504                 goto err;
1505         }
1506
1507         ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, &regid);
1508         if (ret) {
1509                 dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1510                 goto err;
1511         }
1512
1513         ret = regmap_read(cs35l41->regmap, CS35L41_REVID, &reg_revid);
1514         if (ret) {
1515                 dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1516                 goto err;
1517         }
1518
1519         mtl_revid = reg_revid & CS35L41_MTLREVID_MASK;
1520
1521         chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID;
1522         if (regid != chipid) {
1523                 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid);
1524                 ret = -ENODEV;
1525                 goto err;
1526         }
1527
1528         ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1529         if (ret)
1530                 goto err;
1531
1532         ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1533         if (ret)
1534                 goto err;
1535
1536         ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1537         if (ret) {
1538                 dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1539                 goto err;
1540         }
1541
1542         ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1543         if (ret)
1544                 goto err;
1545
1546         INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1547         mutex_init(&cs35l41->fw_mutex);
1548
1549         pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1550         pm_runtime_use_autosuspend(cs35l41->dev);
1551         pm_runtime_mark_last_busy(cs35l41->dev);
1552         pm_runtime_set_active(cs35l41->dev);
1553         pm_runtime_get_noresume(cs35l41->dev);
1554         pm_runtime_enable(cs35l41->dev);
1555
1556         ret = cs35l41_hda_apply_properties(cs35l41);
1557         if (ret)
1558                 goto err_pm;
1559
1560         pm_runtime_put_autosuspend(cs35l41->dev);
1561
1562         ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1563         if (ret) {
1564                 dev_err(cs35l41->dev, "Register component failed: %d\n", ret);
1565                 pm_runtime_disable(cs35l41->dev);
1566                 goto err;
1567         }
1568
1569         dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
1570
1571         return 0;
1572
1573 err_pm:
1574         pm_runtime_disable(cs35l41->dev);
1575         pm_runtime_put_noidle(cs35l41->dev);
1576
1577 err:
1578         if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1579                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1580         gpiod_put(cs35l41->reset_gpio);
1581         kfree(cs35l41->acpi_subsystem_id);
1582
1583         return ret;
1584 }
1585 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41);
1586
1587 void cs35l41_hda_remove(struct device *dev)
1588 {
1589         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1590
1591         pm_runtime_get_sync(cs35l41->dev);
1592         pm_runtime_disable(cs35l41->dev);
1593
1594         if (cs35l41->halo_initialized)
1595                 cs35l41_remove_dsp(cs35l41);
1596
1597         component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
1598
1599         pm_runtime_put_noidle(cs35l41->dev);
1600
1601         if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1602                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1603         gpiod_put(cs35l41->reset_gpio);
1604         kfree(cs35l41->acpi_subsystem_id);
1605 }
1606 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41);
1607
1608 const struct dev_pm_ops cs35l41_hda_pm_ops = {
1609         RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume,
1610                        cs35l41_runtime_idle)
1611         SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume)
1612 };
1613 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
1614
1615 MODULE_DESCRIPTION("CS35L41 HDA Driver");
1616 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
1617 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
1618 MODULE_LICENSE("GPL");
1619 MODULE_IMPORT_NS(FW_CS_DSP);