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,     0x00000000 }, // 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,     0x00000000 }, // 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_VOL_PCM Mute
  92 };
  93
  94 static int cs35l41_control_add(struct cs_dsp_coeff_ctl *cs_ctl)
  95 {
  96         struct cs35l41_hda *cs35l41 = container_of(cs_ctl->dsp, struct cs35l41_hda, cs_dsp);
  97         struct hda_cs_dsp_ctl_info info;
  98
  99         info.device_name = cs35l41->amp_name;
 100         info.fw_type = cs35l41->firmware_type;
 101         info.card = cs35l41->codec->card;
 102
 103         return hda_cs_dsp_control_add(cs_ctl, &info);
 104 }
 105
 106 static const struct cs_dsp_client_ops client_ops = {
 107         .control_add = cs35l41_control_add,
 108         .control_remove = hda_cs_dsp_control_remove,
 109 };
 110
 111 static int cs35l41_request_firmware_file(struct cs35l41_hda *cs35l41,
 112                                          const struct firmware **firmware, char **filename,
 113                                          const char *dir, const char *ssid, const char *amp_name,
 114                                          int spkid, const char *filetype)
 115 {
 116         const char * const dsp_name = cs35l41->cs_dsp.name;
 117         char *s, c;
 118         int ret = 0;
 119
 120         if (spkid > -1 && ssid && amp_name)
 121                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d-%s.%s", dir, CS35L41_PART,
 122                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 123                                       ssid, spkid, amp_name, filetype);
 124         else if (spkid > -1 && ssid)
 125                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-spkid%d.%s", dir, CS35L41_PART,
 126                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 127                                       ssid, spkid, filetype);
 128         else if (ssid && amp_name)
 129                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s-%s.%s", dir, CS35L41_PART,
 130                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 131                                       ssid, amp_name, filetype);
 132         else if (ssid)
 133                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s-%s.%s", dir, CS35L41_PART,
 134                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 135                                       ssid, filetype);
 136         else
 137                 *filename = kasprintf(GFP_KERNEL, "%s%s-%s-%s.%s", dir, CS35L41_PART,
 138                                       dsp_name, hda_cs_dsp_fw_ids[cs35l41->firmware_type],
 139                                       filetype);
 140
 141         if (*filename == NULL)
 142                 return -ENOMEM;
 143
 144         /*
 145          * Make sure that filename is lower-case and any non alpha-numeric
 146          * characters except full stop and '/' are replaced with hyphens.
 147          */
 148         s = *filename;
 149         while (*s) {
 150                 c = *s;
 151                 if (isalnum(c))
 152                         *s = tolower(c);
 153                 else if (c != '.' && c != '/')
 154                         *s = '-';
 155                 s++;
 156         }
 157
 158         ret = firmware_request_nowarn(firmware, *filename, cs35l41->dev);
 159         if (ret != 0) {
 160                 dev_dbg(cs35l41->dev, "Failed to request '%s'\n", *filename);
 161                 kfree(*filename);
 162                 *filename = NULL;
 163         }
 164
 165         return ret;
 166 }
 167
 168 static int cs35l41_request_firmware_files_spkid(struct cs35l41_hda *cs35l41,
 169                                                 const struct firmware **wmfw_firmware,
 170                                                 char **wmfw_filename,
 171                                                 const struct firmware **coeff_firmware,
 172                                                 char **coeff_filename)
 173 {
 174         int ret;
 175
 176         /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.wmfw */
 177         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 178                                             CS35L41_FIRMWARE_ROOT,
 179                                             cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 180                                             cs35l41->speaker_id, "wmfw");
 181         if (!ret) {
 182                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 183                 cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 184                                               CS35L41_FIRMWARE_ROOT,
 185                                               cs35l41->acpi_subsystem_id, cs35l41->amp_name,
 186                                               cs35l41->speaker_id, "bin");
 187                 return 0;
 188         }
 189
 190         /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
 191         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 192                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 193                                             cs35l41->amp_name, -1, "wmfw");
 194         if (!ret) {
 195                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 196                 cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 197                                               CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 198                                               cs35l41->amp_name, cs35l41->speaker_id, "bin");
 199                 return 0;
 200         }
 201
 202         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.wmfw */
 203         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 204                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 205                                             NULL, cs35l41->speaker_id, "wmfw");
 206         if (!ret) {
 207                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 208                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 209                                                     CS35L41_FIRMWARE_ROOT,
 210                                                     cs35l41->acpi_subsystem_id,
 211                                                     cs35l41->amp_name, cs35l41->speaker_id, "bin");
 212                 if (ret)
 213                         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
 214                         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 215                                                 CS35L41_FIRMWARE_ROOT,
 216                                                 cs35l41->acpi_subsystem_id,
 217                                                 NULL, cs35l41->speaker_id, "bin");
 218                 return 0;
 219         }
 220
 221         /* try cirrus/part-dspN-fwtype-sub.wmfw */
 222         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 223                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 224                                             NULL, -1, "wmfw");
 225         if (!ret) {
 226                 /* try cirrus/part-dspN-fwtype-sub<-spkidN><-ampname>.bin */
 227                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 228                                                     CS35L41_FIRMWARE_ROOT,
 229                                                     cs35l41->acpi_subsystem_id,
 230                                                     cs35l41->amp_name, cs35l41->speaker_id, "bin");
 231                 if (ret)
 232                         /* try cirrus/part-dspN-fwtype-sub<-spkidN>.bin */
 233                         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 234                                                       CS35L41_FIRMWARE_ROOT,
 235                                                       cs35l41->acpi_subsystem_id,
 236                                                       NULL, cs35l41->speaker_id, "bin");
 237                 return 0;
 238         }
 239
 240         /* fallback try cirrus/part-dspN-fwtype.wmfw */
 241         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 242                                             CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
 243         if (!ret) {
 244                 /* fallback try cirrus/part-dspN-fwtype.bin */
 245                 cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 246                                               CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
 247                 return 0;
 248         }
 249
 250         dev_warn(cs35l41->dev, "Failed to request firmware\n");
 251
 252         return ret;
 253 }
 254
 255 static int cs35l41_request_firmware_files(struct cs35l41_hda *cs35l41,
 256                                           const struct firmware **wmfw_firmware,
 257                                           char **wmfw_filename,
 258                                           const struct firmware **coeff_firmware,
 259                                           char **coeff_filename)
 260 {
 261         int ret;
 262
 263         if (cs35l41->speaker_id > -1)
 264                 return cs35l41_request_firmware_files_spkid(cs35l41, wmfw_firmware, wmfw_filename,
 265                                                             coeff_firmware, coeff_filename);
 266
 267         /* try cirrus/part-dspN-fwtype-sub<-ampname>.wmfw */
 268         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 269                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 270                                             cs35l41->amp_name, -1, "wmfw");
 271         if (!ret) {
 272                 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
 273                 cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 274                                               CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 275                                               cs35l41->amp_name, -1, "bin");
 276                 return 0;
 277         }
 278
 279         /* try cirrus/part-dspN-fwtype-sub.wmfw */
 280         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 281                                             CS35L41_FIRMWARE_ROOT, cs35l41->acpi_subsystem_id,
 282                                             NULL, -1, "wmfw");
 283         if (!ret) {
 284                 /* try cirrus/part-dspN-fwtype-sub<-ampname>.bin */
 285                 ret = cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 286                                                     CS35L41_FIRMWARE_ROOT,
 287                                                     cs35l41->acpi_subsystem_id,
 288                                                     cs35l41->amp_name, -1, "bin");
 289                 if (ret)
 290                         /* try cirrus/part-dspN-fwtype-sub.bin */
 291                         cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 292                                                       CS35L41_FIRMWARE_ROOT,
 293                                                       cs35l41->acpi_subsystem_id,
 294                                                       NULL, -1, "bin");
 295                 return 0;
 296         }
 297
 298         /* fallback try cirrus/part-dspN-fwtype.wmfw */
 299         ret = cs35l41_request_firmware_file(cs35l41, wmfw_firmware, wmfw_filename,
 300                                             CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "wmfw");
 301         if (!ret) {
 302                 /* fallback try cirrus/part-dspN-fwtype.bin */
 303                 cs35l41_request_firmware_file(cs35l41, coeff_firmware, coeff_filename,
 304                                               CS35L41_FIRMWARE_ROOT, NULL, NULL, -1, "bin");
 305                 return 0;
 306         }
 307
 308         dev_warn(cs35l41->dev, "Failed to request firmware\n");
 309
 310         return ret;
 311 }
 312
 313 #if IS_ENABLED(CONFIG_EFI)
 314 static int cs35l41_apply_calibration(struct cs35l41_hda *cs35l41, unsigned int ambient,
 315                                      unsigned int r0, unsigned int status, unsigned int checksum)
 316 {
 317         int ret;
 318
 319         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_AMBIENT_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 320                                    CAL_DSP_CTL_ALG, &ambient, 4);
 321         if (ret) {
 322                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_AMBIENT_DSP_CTL_NAME,
 323                         ret);
 324                 return ret;
 325         }
 326         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_R_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 327                                    CAL_DSP_CTL_ALG, &r0, 4);
 328         if (ret) {
 329                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_R_DSP_CTL_NAME, ret);
 330                 return ret;
 331         }
 332         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_STATUS_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 333                                    CAL_DSP_CTL_ALG, &status, 4);
 334         if (ret) {
 335                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_STATUS_DSP_CTL_NAME,
 336                         ret);
 337                 return ret;
 338         }
 339         ret = hda_cs_dsp_write_ctl(&cs35l41->cs_dsp, CAL_CHECKSUM_DSP_CTL_NAME, CAL_DSP_CTL_TYPE,
 340                                    CAL_DSP_CTL_ALG, &checksum, 4);
 341         if (ret) {
 342                 dev_err(cs35l41->dev, "Cannot Write Control: %s - %d\n", CAL_CHECKSUM_DSP_CTL_NAME,
 343                         ret);
 344                 return ret;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
 351 {
 352         static efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe,
 353                                               0x5a, 0xa3, 0x5d, 0xb3);
 354         static efi_char16_t efi_name[] = L"CirrusSmartAmpCalibrationData";
 355         const struct cs35l41_amp_efi_data *efi_data;
 356         const struct cs35l41_amp_cal_data *cl;
 357         unsigned long data_size = 0;
 358         efi_status_t status;
 359         int ret = 0;
 360         u8 *data = NULL;
 361         u32 attr;
 362
 363         /* Get real size of UEFI variable */
 364         status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
 365         if (status == EFI_BUFFER_TOO_SMALL) {
 366                 ret = -ENODEV;
 367                 /* Allocate data buffer of data_size bytes */
 368                 data = vmalloc(data_size);
 369                 if (!data)
 370                         return -ENOMEM;
 371                 /* Get variable contents into buffer */
 372                 status = efi.get_variable(efi_name, &efi_guid, &attr, &data_size, data);
 373                 if (status == EFI_SUCCESS) {
 374                         efi_data = (struct cs35l41_amp_efi_data *)data;
 375                         dev_dbg(cs35l41->dev, "Calibration: Size=%d, Amp Count=%d\n",
 376                                 efi_data->size, efi_data->count);
 377                         if (efi_data->count > cs35l41->index) {
 378                                 cl = &efi_data->data[cs35l41->index];
 379                                 dev_dbg(cs35l41->dev,
 380                                         "Calibration: Ambient=%02x, Status=%02x, R0=%d\n",
 381                                         cl->calAmbient, cl->calStatus, cl->calR);
 382
 383                                 /* Calibration can only be applied whilst the DSP is not running */
 384                                 ret = cs35l41_apply_calibration(cs35l41,
 385                                                                 cpu_to_be32(cl->calAmbient),
 386                                                                 cpu_to_be32(cl->calR),
 387                                                                 cpu_to_be32(cl->calStatus),
 388                                                                 cpu_to_be32(cl->calR + 1));
 389                         }
 390                 }
 391                 vfree(data);
 392         }
 393         return ret;
 394 }
 395 #else
 396 static int cs35l41_save_calibration(struct cs35l41_hda *cs35l41)
 397 {
 398         dev_warn(cs35l41->dev, "Calibration not supported without EFI support.\n");
 399         return 0;
 400 }
 401 #endif
 402
 403 static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)
 404 {
 405         const struct firmware *coeff_firmware = NULL;
 406         const struct firmware *wmfw_firmware = NULL;
 407         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 408         char *coeff_filename = NULL;
 409         char *wmfw_filename = NULL;
 410         int ret;
 411
 412         if (!cs35l41->halo_initialized) {
 413                 cs35l41_configure_cs_dsp(cs35l41->dev, cs35l41->regmap, dsp);
 414                 dsp->client_ops = &client_ops;
 415
 416                 ret = cs_dsp_halo_init(&cs35l41->cs_dsp);
 417                 if (ret)
 418                         return ret;
 419                 cs35l41->halo_initialized = true;
 420         }
 421
 422         ret = cs35l41_request_firmware_files(cs35l41, &wmfw_firmware, &wmfw_filename,
 423                                              &coeff_firmware, &coeff_filename);
 424         if (ret < 0)
 425                 return ret;
 426
 427         dev_dbg(cs35l41->dev, "Loading WMFW Firmware: %s\n", wmfw_filename);
 428         if (coeff_filename)
 429                 dev_dbg(cs35l41->dev, "Loading Coefficient File: %s\n", coeff_filename);
 430         else
 431                 dev_warn(cs35l41->dev, "No Coefficient File available.\n");
 432
 433         ret = cs_dsp_power_up(dsp, wmfw_firmware, wmfw_filename, coeff_firmware, coeff_filename,
 434                               hda_cs_dsp_fw_ids[cs35l41->firmware_type]);
 435         if (ret)
 436                 goto err_release;
 437
 438         ret = cs35l41_save_calibration(cs35l41);
 439
 440 err_release:
 441         release_firmware(wmfw_firmware);
 442         release_firmware(coeff_firmware);
 443         kfree(wmfw_filename);
 444         kfree(coeff_filename);
 445
 446         return ret;
 447 }
 448
 449 static void cs35l41_shutdown_dsp(struct cs35l41_hda *cs35l41)
 450 {
 451         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 452
 453         cs_dsp_stop(dsp);
 454         cs_dsp_power_down(dsp);
 455         cs35l41->firmware_running = false;
 456         dev_dbg(cs35l41->dev, "Unloaded Firmware\n");
 457 }
 458
 459 static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)
 460 {
 461         struct cs_dsp *dsp = &cs35l41->cs_dsp;
 462
 463         cancel_work_sync(&cs35l41->fw_load_work);
 464         cs35l41_shutdown_dsp(cs35l41);
 465         cs_dsp_remove(dsp);
 466         cs35l41->halo_initialized = false;
 467 }
 468
 469 /* Protection release cycle to get the speaker out of Safe-Mode */
 470 static void cs35l41_error_release(struct device *dev, struct regmap *regmap, unsigned int mask)
 471 {
 472         regmap_write(regmap, CS35L41_PROTECT_REL_ERR_IGN, 0);
 473         regmap_set_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
 474         regmap_clear_bits(regmap, CS35L41_PROTECT_REL_ERR_IGN, mask);
 475 }
 476
 477 /* Clear all errors to release safe mode. Global Enable must be cleared first. */
 478 static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
 479 {
 480         cs35l41_error_release(cs35l41->dev, cs35l41->regmap, cs35l41->irq_errors);
 481         cs35l41->irq_errors = 0;
 482 }
 483
 484 static void cs35l41_hda_playback_hook(struct device *dev, int action)
 485 {
 486         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 487         struct regmap *reg = cs35l41->regmap;
 488         int ret = 0;
 489
 490         mutex_lock(&cs35l41->fw_mutex);
 491
 492         switch (action) {
 493         case HDA_GEN_PCM_ACT_OPEN:
 494                 cs35l41->playback_started = true;
 495                 if (cs35l41->firmware_running) {
 496                         regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
 497                                                ARRAY_SIZE(cs35l41_hda_config_dsp));
 498                         regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
 499                                            CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
 500                                            1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
 501                         cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
 502                                                   CSPL_MBOX_CMD_RESUME);
 503                 } else {
 504                         regmap_multi_reg_write(reg, cs35l41_hda_config,
 505                                                ARRAY_SIZE(cs35l41_hda_config));
 506                 }
 507                 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
 508                                          CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
 509                 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 510                         regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
 511                 break;
 512         case HDA_GEN_PCM_ACT_PREPARE:
 513                 ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 1);
 514                 break;
 515         case HDA_GEN_PCM_ACT_CLEANUP:
 516                 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
 517                 ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 0);
 518                 break;
 519         case HDA_GEN_PCM_ACT_CLOSE:
 520                 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
 521                                          CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
 522                 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 523                         regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
 524                 if (cs35l41->firmware_running) {
 525                         cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
 526                                                   CSPL_MBOX_CMD_PAUSE);
 527                         regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
 528                                            CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
 529                                            0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
 530                 }
 531                 cs35l41_irq_release(cs35l41);
 532                 cs35l41->playback_started = false;
 533                 break;
 534         default:
 535                 dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action);
 536                 break;
 537         }
 538
 539         mutex_unlock(&cs35l41->fw_mutex);
 540
 541         if (ret)
 542                 dev_err(cs35l41->dev, "Regmap access fail: %d\n", ret);
 543 }
 544
 545 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot,
 546                                     unsigned int rx_num, unsigned int *rx_slot)
 547 {
 548         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 549         static const char * const channel_name[] = { "L", "R" };
 550
 551         if (!cs35l41->amp_name) {
 552                 if (*rx_slot >= ARRAY_SIZE(channel_name))
 553                         return -EINVAL;
 554
 555                 cs35l41->amp_name = devm_kasprintf(cs35l41->dev, GFP_KERNEL, "%s%d",
 556                                                    channel_name[*rx_slot], cs35l41->channel_index);
 557                 if (!cs35l41->amp_name)
 558                         return -ENOMEM;
 559         }
 560
 561         return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num,
 562                                     rx_slot);
 563 }
 564
 565 static int cs35l41_runtime_suspend(struct device *dev)
 566 {
 567         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 568
 569         dev_dbg(cs35l41->dev, "Suspend\n");
 570
 571         if (!cs35l41->firmware_running)
 572                 return 0;
 573
 574         if (cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type) < 0)
 575                 return 0;
 576
 577         regcache_cache_only(cs35l41->regmap, true);
 578         regcache_mark_dirty(cs35l41->regmap);
 579
 580         return 0;
 581 }
 582
 583 static int cs35l41_runtime_resume(struct device *dev)
 584 {
 585         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 586         int ret;
 587
 588         dev_dbg(cs35l41->dev, "Resume.\n");
 589
 590         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
 591                 dev_dbg(cs35l41->dev, "System does not support Resume\n");
 592                 return 0;
 593         }
 594
 595         if (!cs35l41->firmware_running)
 596                 return 0;
 597
 598         regcache_cache_only(cs35l41->regmap, false);
 599
 600         ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
 601         if (ret) {
 602                 regcache_cache_only(cs35l41->regmap, true);
 603                 return ret;
 604         }
 605
 606         /* Test key needs to be unlocked to allow the OTP settings to re-apply */
 607         cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
 608         ret = regcache_sync(cs35l41->regmap);
 609         cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
 610         if (ret) {
 611                 dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
 612                 return ret;
 613         }
 614
 615         if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
 616                 cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
 617
 618         return 0;
 619 }
 620
 621 static int cs35l41_hda_suspend_hook(struct device *dev)
 622 {
 623         dev_dbg(dev, "Request Suspend\n");
 624         pm_runtime_mark_last_busy(dev);
 625         return pm_runtime_put_autosuspend(dev);
 626 }
 627
 628 static int cs35l41_hda_resume_hook(struct device *dev)
 629 {
 630         dev_dbg(dev, "Request Resume\n");
 631         return pm_runtime_get_sync(dev);
 632 }
 633
 634 static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
 635 {
 636         int halo_sts;
 637         int ret;
 638
 639         ret = cs35l41_init_dsp(cs35l41);
 640         if (ret) {
 641                 dev_warn(cs35l41->dev, "Cannot Initialize Firmware. Error: %d\n", ret);
 642                 goto clean_dsp;
 643         }
 644
 645         ret = cs35l41_write_fs_errata(cs35l41->dev, cs35l41->regmap);
 646         if (ret) {
 647                 dev_err(cs35l41->dev, "Cannot Write FS Errata: %d\n", ret);
 648                 goto clean_dsp;
 649         }
 650
 651         ret = cs_dsp_run(&cs35l41->cs_dsp);
 652         if (ret) {
 653                 dev_err(cs35l41->dev, "Fail to start dsp: %d\n", ret);
 654                 goto clean_dsp;
 655         }
 656
 657         ret = read_poll_timeout(hda_cs_dsp_read_ctl, ret,
 658                                 be32_to_cpu(halo_sts) == HALO_STATE_CODE_RUN,
 659                                 1000, 15000, false, &cs35l41->cs_dsp, HALO_STATE_DSP_CTL_NAME,
 660                                 HALO_STATE_DSP_CTL_TYPE, HALO_STATE_DSP_CTL_ALG,
 661                                 &halo_sts, sizeof(halo_sts));
 662
 663         if (ret) {
 664                 dev_err(cs35l41->dev, "Timeout waiting for HALO Core to start. State: %d\n",
 665                          halo_sts);
 666                 goto clean_dsp;
 667         }
 668
 669         cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
 670         cs35l41->firmware_running = true;
 671
 672         return 0;
 673
 674 clean_dsp:
 675         cs35l41_shutdown_dsp(cs35l41);
 676         return ret;
 677 }
 678
 679 static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load)
 680 {
 681         pm_runtime_get_sync(cs35l41->dev);
 682
 683         if (cs35l41->firmware_running && !load) {
 684                 dev_dbg(cs35l41->dev, "Unloading Firmware\n");
 685                 cs35l41_shutdown_dsp(cs35l41);
 686         } else if (!cs35l41->firmware_running && load) {
 687                 dev_dbg(cs35l41->dev, "Loading Firmware\n");
 688                 cs35l41_smart_amp(cs35l41);
 689         } else {
 690                 dev_dbg(cs35l41->dev, "Unable to Load firmware.\n");
 691         }
 692
 693         pm_runtime_mark_last_busy(cs35l41->dev);
 694         pm_runtime_put_autosuspend(cs35l41->dev);
 695 }
 696
 697 static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
 698                                    struct snd_ctl_elem_value *ucontrol)
 699 {
 700         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 701
 702         ucontrol->value.integer.value[0] = cs35l41->request_fw_load;
 703         return 0;
 704 }
 705
 706 static void cs35l41_fw_load_work(struct work_struct *work)
 707 {
 708         struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work);
 709
 710         mutex_lock(&cs35l41->fw_mutex);
 711
 712         /* Recheck if playback is ongoing, mutex will block playback during firmware loading */
 713         if (cs35l41->playback_started)
 714                 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
 715         else
 716                 cs35l41_load_firmware(cs35l41, cs35l41->request_fw_load);
 717
 718         cs35l41->fw_request_ongoing = false;
 719         mutex_unlock(&cs35l41->fw_mutex);
 720 }
 721
 722 static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
 723                                    struct snd_ctl_elem_value *ucontrol)
 724 {
 725         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 726         unsigned int ret = 0;
 727
 728         mutex_lock(&cs35l41->fw_mutex);
 729
 730         if (cs35l41->request_fw_load == ucontrol->value.integer.value[0])
 731                 goto err;
 732
 733         if (cs35l41->fw_request_ongoing) {
 734                 dev_dbg(cs35l41->dev, "Existing request not complete\n");
 735                 ret = -EBUSY;
 736                 goto err;
 737         }
 738
 739         /* Check if playback is ongoing when initial request is made */
 740         if (cs35l41->playback_started) {
 741                 dev_err(cs35l41->dev, "Cannot Load/Unload firmware during Playback\n");
 742                 ret = -EBUSY;
 743                 goto err;
 744         }
 745
 746         cs35l41->fw_request_ongoing = true;
 747         cs35l41->request_fw_load = ucontrol->value.integer.value[0];
 748         schedule_work(&cs35l41->fw_load_work);
 749
 750 err:
 751         mutex_unlock(&cs35l41->fw_mutex);
 752
 753         return ret;
 754 }
 755
 756 static int cs35l41_fw_type_ctl_get(struct snd_kcontrol *kcontrol,
 757                                    struct snd_ctl_elem_value *ucontrol)
 758 {
 759         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 760
 761         ucontrol->value.enumerated.item[0] = cs35l41->firmware_type;
 762
 763         return 0;
 764 }
 765
 766 static int cs35l41_fw_type_ctl_put(struct snd_kcontrol *kcontrol,
 767                                    struct snd_ctl_elem_value *ucontrol)
 768 {
 769         struct cs35l41_hda *cs35l41 = snd_kcontrol_chip(kcontrol);
 770
 771         if (ucontrol->value.enumerated.item[0] < HDA_CS_DSP_NUM_FW) {
 772                 cs35l41->firmware_type = ucontrol->value.enumerated.item[0];
 773                 return 0;
 774         }
 775
 776         return -EINVAL;
 777 }
 778
 779 static int cs35l41_fw_type_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 780 {
 781         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(hda_cs_dsp_fw_ids), hda_cs_dsp_fw_ids);
 782 }
 783
 784 static int cs35l41_create_controls(struct cs35l41_hda *cs35l41)
 785 {
 786         char fw_type_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 787         char fw_load_ctl_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 788         struct snd_kcontrol_new fw_type_ctl = {
 789                 .name = fw_type_ctl_name,
 790                 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 791                 .info = cs35l41_fw_type_ctl_info,
 792                 .get = cs35l41_fw_type_ctl_get,
 793                 .put = cs35l41_fw_type_ctl_put,
 794         };
 795         struct snd_kcontrol_new fw_load_ctl = {
 796                 .name = fw_load_ctl_name,
 797                 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 798                 .info = snd_ctl_boolean_mono_info,
 799                 .get = cs35l41_fw_load_ctl_get,
 800                 .put = cs35l41_fw_load_ctl_put,
 801         };
 802         int ret;
 803
 804         scnprintf(fw_type_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Type",
 805                   cs35l41->amp_name);
 806         scnprintf(fw_load_ctl_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, "%s DSP1 Firmware Load",
 807                   cs35l41->amp_name);
 808
 809         ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_type_ctl, cs35l41));
 810         if (ret) {
 811                 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_type_ctl.name, ret);
 812                 return ret;
 813         }
 814
 815         dev_dbg(cs35l41->dev, "Added Control %s\n", fw_type_ctl.name);
 816
 817         ret = snd_ctl_add(cs35l41->codec->card, snd_ctl_new1(&fw_load_ctl, cs35l41));
 818         if (ret) {
 819                 dev_err(cs35l41->dev, "Failed to add KControl %s = %d\n", fw_load_ctl.name, ret);
 820                 return ret;
 821         }
 822
 823         dev_dbg(cs35l41->dev, "Added Control %s\n", fw_load_ctl.name);
 824
 825         return 0;
 826 }
 827
 828 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data)
 829 {
 830         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 831         struct hda_component *comps = master_data;
 832         int ret = 0;
 833
 834         if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
 835                 return -EINVAL;
 836
 837         comps = &comps[cs35l41->index];
 838         if (comps->dev)
 839                 return -EBUSY;
 840
 841         pm_runtime_get_sync(dev);
 842
 843         comps->dev = dev;
 844         if (!cs35l41->acpi_subsystem_id)
 845                 cs35l41->acpi_subsystem_id = devm_kasprintf(dev, GFP_KERNEL, "%.8x",
 846                                                             comps->codec->core.subsystem_id);
 847         cs35l41->codec = comps->codec;
 848         strscpy(comps->name, dev_name(dev), sizeof(comps->name));
 849
 850         cs35l41->firmware_type = HDA_CS_DSP_FW_SPK_PROT;
 851
 852         if (firmware_autostart) {
 853                 dev_dbg(cs35l41->dev, "Firmware Autostart.\n");
 854                 cs35l41->request_fw_load = true;
 855                 mutex_lock(&cs35l41->fw_mutex);
 856                 if (cs35l41_smart_amp(cs35l41) < 0)
 857                         dev_warn(cs35l41->dev, "Cannot Run Firmware, reverting to dsp bypass...\n");
 858                 mutex_unlock(&cs35l41->fw_mutex);
 859         } else {
 860                 dev_dbg(cs35l41->dev, "Firmware Autostart is disabled.\n");
 861         }
 862
 863         ret = cs35l41_create_controls(cs35l41);
 864
 865         comps->playback_hook = cs35l41_hda_playback_hook;
 866         comps->suspend_hook = cs35l41_hda_suspend_hook;
 867         comps->resume_hook = cs35l41_hda_resume_hook;
 868
 869         pm_runtime_mark_last_busy(dev);
 870         pm_runtime_put_autosuspend(dev);
 871
 872         return ret;
 873 }
 874
 875 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data)
 876 {
 877         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
 878         struct hda_component *comps = master_data;
 879
 880         if (comps[cs35l41->index].dev == dev)
 881                 memset(&comps[cs35l41->index], 0, sizeof(*comps));
 882 }
 883
 884 static const struct component_ops cs35l41_hda_comp_ops = {
 885         .bind = cs35l41_hda_bind,
 886         .unbind = cs35l41_hda_unbind,
 887 };
 888
 889 static irqreturn_t cs35l41_bst_short_err(int irq, void *data)
 890 {
 891         struct cs35l41_hda *cs35l41 = data;
 892
 893         dev_crit_ratelimited(cs35l41->dev, "LBST Error\n");
 894         set_bit(CS35L41_BST_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 895
 896         return IRQ_HANDLED;
 897 }
 898
 899 static irqreturn_t cs35l41_bst_dcm_uvp_err(int irq, void *data)
 900 {
 901         struct cs35l41_hda *cs35l41 = data;
 902
 903         dev_crit_ratelimited(cs35l41->dev, "DCM VBST Under Voltage Error\n");
 904         set_bit(CS35L41_BST_UVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 905
 906         return IRQ_HANDLED;
 907 }
 908
 909 static irqreturn_t cs35l41_bst_ovp_err(int irq, void *data)
 910 {
 911         struct cs35l41_hda *cs35l41 = data;
 912
 913         dev_crit_ratelimited(cs35l41->dev, "VBST Over Voltage error\n");
 914         set_bit(CS35L41_BST_OVP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 915
 916         return IRQ_HANDLED;
 917 }
 918
 919 static irqreturn_t cs35l41_temp_err(int irq, void *data)
 920 {
 921         struct cs35l41_hda *cs35l41 = data;
 922
 923         dev_crit_ratelimited(cs35l41->dev, "Over temperature error\n");
 924         set_bit(CS35L41_TEMP_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 925
 926         return IRQ_HANDLED;
 927 }
 928
 929 static irqreturn_t cs35l41_temp_warn(int irq, void *data)
 930 {
 931         struct cs35l41_hda *cs35l41 = data;
 932
 933         dev_crit_ratelimited(cs35l41->dev, "Over temperature warning\n");
 934         set_bit(CS35L41_TEMP_WARN_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 935
 936         return IRQ_HANDLED;
 937 }
 938
 939 static irqreturn_t cs35l41_amp_short(int irq, void *data)
 940 {
 941         struct cs35l41_hda *cs35l41 = data;
 942
 943         dev_crit_ratelimited(cs35l41->dev, "Amp short error\n");
 944         set_bit(CS35L41_AMP_SHORT_ERR_RLS_SHIFT, &cs35l41->irq_errors);
 945
 946         return IRQ_HANDLED;
 947 }
 948
 949 static const struct cs35l41_irq cs35l41_irqs[] = {
 950         CS35L41_IRQ(BST_OVP_ERR, "Boost Overvoltage Error", cs35l41_bst_ovp_err),
 951         CS35L41_IRQ(BST_DCM_UVP_ERR, "Boost Undervoltage Error", cs35l41_bst_dcm_uvp_err),
 952         CS35L41_IRQ(BST_SHORT_ERR, "Boost Inductor Short Error", cs35l41_bst_short_err),
 953         CS35L41_IRQ(TEMP_WARN, "Temperature Warning", cs35l41_temp_warn),
 954         CS35L41_IRQ(TEMP_ERR, "Temperature Error", cs35l41_temp_err),
 955         CS35L41_IRQ(AMP_SHORT_ERR, "Amp Short", cs35l41_amp_short),
 956 };
 957
 958 static const struct regmap_irq cs35l41_reg_irqs[] = {
 959         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_OVP_ERR),
 960         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_DCM_UVP_ERR),
 961         CS35L41_REG_IRQ(IRQ1_STATUS1, BST_SHORT_ERR),
 962         CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_WARN),
 963         CS35L41_REG_IRQ(IRQ1_STATUS1, TEMP_ERR),
 964         CS35L41_REG_IRQ(IRQ1_STATUS1, AMP_SHORT_ERR),
 965 };
 966
 967 static struct regmap_irq_chip cs35l41_regmap_irq_chip = {
 968         .name = "cs35l41 IRQ1 Controller",
 969         .status_base = CS35L41_IRQ1_STATUS1,
 970         .mask_base = CS35L41_IRQ1_MASK1,
 971         .ack_base = CS35L41_IRQ1_STATUS1,
 972         .num_regs = 4,
 973         .irqs = cs35l41_reg_irqs,
 974         .num_irqs = ARRAY_SIZE(cs35l41_reg_irqs),
 975         .runtime_pm = true,
 976 };
 977
 978 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41)
 979 {
 980         struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
 981         bool using_irq = false;
 982         int irq, irq_pol;
 983         int ret;
 984         int i;
 985
 986         if (!cs35l41->hw_cfg.valid)
 987                 return -EINVAL;
 988
 989         ret = cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, hw_cfg);
 990         if (ret)
 991                 return ret;
 992
 993         if (hw_cfg->gpio1.valid) {
 994                 switch (hw_cfg->gpio1.func) {
 995                 case CS35L41_NOT_USED:
 996                         break;
 997                 case CS35l41_VSPK_SWITCH:
 998                         hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO;
 999                         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                 hw_cfg->valid = false;
1167                 hw_cfg->gpio1.valid = false;
1168                 hw_cfg->gpio2.valid = false;
1169                 return -EINVAL;
1170         }
1171
1172         return 0;
1173 }
1174
1175 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id)
1176 {
1177         struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg;
1178         u32 values[HDA_MAX_COMPONENTS];
1179         struct acpi_device *adev;
1180         struct device *physdev;
1181         char *property;
1182         size_t nval;
1183         int i, ret;
1184
1185         adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1186         if (!adev) {
1187                 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid);
1188                 return -ENODEV;
1189         }
1190
1191         physdev = get_device(acpi_get_first_physical_node(adev));
1192         acpi_dev_put(adev);
1193
1194         ret = cs35l41_get_acpi_sub_string(cs35l41->dev, adev, &cs35l41->acpi_subsystem_id);
1195         if (ret)
1196                 dev_info(cs35l41->dev, "No Subsystem ID found in ACPI: %d", ret);
1197         else
1198                 dev_dbg(cs35l41->dev, "Subsystem ID %s found", cs35l41->acpi_subsystem_id);
1199
1200         property = "cirrus,dev-index";
1201         ret = device_property_count_u32(physdev, property);
1202         if (ret <= 0)
1203                 return cs35l41_no_acpi_dsd(cs35l41, physdev, id, hid);
1204
1205         if (ret > ARRAY_SIZE(values)) {
1206                 ret = -EINVAL;
1207                 goto err;
1208         }
1209         nval = ret;
1210
1211         ret = device_property_read_u32_array(physdev, property, values, nval);
1212         if (ret)
1213                 goto err;
1214
1215         cs35l41->index = -1;
1216         for (i = 0; i < nval; i++) {
1217                 if (values[i] == id) {
1218                         cs35l41->index = i;
1219                         break;
1220                 }
1221         }
1222         if (cs35l41->index == -1) {
1223                 dev_err(cs35l41->dev, "No index found in %s\n", property);
1224                 ret = -ENODEV;
1225                 goto err;
1226         }
1227
1228         /* To use the same release code for all laptop variants we can't use devm_ version of
1229          * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node
1230          */
1231         cs35l41->reset_gpio = fwnode_gpiod_get_index(acpi_fwnode_handle(adev), "reset", cs35l41->index,
1232                                                      GPIOD_OUT_LOW, "cs35l41-reset");
1233
1234         property = "cirrus,speaker-position";
1235         ret = device_property_read_u32_array(physdev, property, values, nval);
1236         if (ret)
1237                 goto err;
1238         hw_cfg->spk_pos = values[cs35l41->index];
1239
1240         cs35l41->channel_index = 0;
1241         for (i = 0; i < cs35l41->index; i++)
1242                 if (values[i] == hw_cfg->spk_pos)
1243                         cs35l41->channel_index++;
1244
1245         property = "cirrus,gpio1-func";
1246         ret = device_property_read_u32_array(physdev, property, values, nval);
1247         if (ret)
1248                 goto err;
1249         hw_cfg->gpio1.func = values[cs35l41->index];
1250         hw_cfg->gpio1.valid = true;
1251
1252         property = "cirrus,gpio2-func";
1253         ret = device_property_read_u32_array(physdev, property, values, nval);
1254         if (ret)
1255                 goto err;
1256         hw_cfg->gpio2.func = values[cs35l41->index];
1257         hw_cfg->gpio2.valid = true;
1258
1259         property = "cirrus,boost-peak-milliamp";
1260         ret = device_property_read_u32_array(physdev, property, values, nval);
1261         if (ret == 0)
1262                 hw_cfg->bst_ipk = values[cs35l41->index];
1263         else
1264                 hw_cfg->bst_ipk = -1;
1265
1266         property = "cirrus,boost-ind-nanohenry";
1267         ret = device_property_read_u32_array(physdev, property, values, nval);
1268         if (ret == 0)
1269                 hw_cfg->bst_ind = values[cs35l41->index];
1270         else
1271                 hw_cfg->bst_ind = -1;
1272
1273         property = "cirrus,boost-cap-microfarad";
1274         ret = device_property_read_u32_array(physdev, property, values, nval);
1275         if (ret == 0)
1276                 hw_cfg->bst_cap = values[cs35l41->index];
1277         else
1278                 hw_cfg->bst_cap = -1;
1279
1280         cs35l41->speaker_id = cs35l41_get_speaker_id(physdev, cs35l41->index, nval, -1);
1281
1282         if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0)
1283                 hw_cfg->bst_type = CS35L41_INT_BOOST;
1284         else
1285                 hw_cfg->bst_type = CS35L41_EXT_BOOST;
1286
1287         hw_cfg->valid = true;
1288         put_device(physdev);
1289
1290         return 0;
1291
1292 err:
1293         put_device(physdev);
1294         dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret);
1295
1296         return ret;
1297 }
1298
1299 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq,
1300                       struct regmap *regmap)
1301 {
1302         unsigned int int_sts, regid, reg_revid, mtl_revid, chipid, int_status;
1303         struct cs35l41_hda *cs35l41;
1304         int ret;
1305
1306         BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != ARRAY_SIZE(cs35l41_reg_irqs));
1307         BUILD_BUG_ON(ARRAY_SIZE(cs35l41_irqs) != CS35L41_NUM_IRQ);
1308
1309         if (IS_ERR(regmap))
1310                 return PTR_ERR(regmap);
1311
1312         cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL);
1313         if (!cs35l41)
1314                 return -ENOMEM;
1315
1316         cs35l41->dev = dev;
1317         cs35l41->irq = irq;
1318         cs35l41->regmap = regmap;
1319         dev_set_drvdata(dev, cs35l41);
1320
1321         ret = cs35l41_hda_read_acpi(cs35l41, device_name, id);
1322         if (ret)
1323                 return dev_err_probe(cs35l41->dev, ret, "Platform not supported\n");
1324
1325         if (IS_ERR(cs35l41->reset_gpio)) {
1326                 ret = PTR_ERR(cs35l41->reset_gpio);
1327                 cs35l41->reset_gpio = NULL;
1328                 if (ret == -EBUSY) {
1329                         dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n");
1330                 } else {
1331                         dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO\n");
1332                         goto err;
1333                 }
1334         }
1335         if (cs35l41->reset_gpio) {
1336                 usleep_range(2000, 2100);
1337                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1);
1338         }
1339
1340         usleep_range(2000, 2100);
1341
1342         ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
1343                                        int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
1344         if (ret) {
1345                 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1346                 goto err;
1347         }
1348
1349         ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts);
1350         if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) {
1351                 dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n",
1352                         int_sts & CS35L41_OTP_BOOT_ERR, ret);
1353                 ret = -EIO;
1354                 goto err;
1355         }
1356
1357         ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, &regid);
1358         if (ret) {
1359                 dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1360                 goto err;
1361         }
1362
1363         ret = regmap_read(cs35l41->regmap, CS35L41_REVID, &reg_revid);
1364         if (ret) {
1365                 dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1366                 goto err;
1367         }
1368
1369         mtl_revid = reg_revid & CS35L41_MTLREVID_MASK;
1370
1371         chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID;
1372         if (regid != chipid) {
1373                 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid);
1374                 ret = -ENODEV;
1375                 goto err;
1376         }
1377
1378         ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
1379         if (ret)
1380                 goto err;
1381
1382         ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid);
1383         if (ret)
1384                 goto err;
1385
1386         ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1387         if (ret) {
1388                 dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1389                 goto err;
1390         }
1391
1392         ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
1393         if (ret)
1394                 goto err;
1395
1396         INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
1397         mutex_init(&cs35l41->fw_mutex);
1398
1399         pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1400         pm_runtime_use_autosuspend(cs35l41->dev);
1401         pm_runtime_mark_last_busy(cs35l41->dev);
1402         pm_runtime_set_active(cs35l41->dev);
1403         pm_runtime_get_noresume(cs35l41->dev);
1404         pm_runtime_enable(cs35l41->dev);
1405
1406         ret = cs35l41_hda_apply_properties(cs35l41);
1407         if (ret)
1408                 goto err_pm;
1409
1410         pm_runtime_put_autosuspend(cs35l41->dev);
1411
1412         ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1413         if (ret) {
1414                 dev_err(cs35l41->dev, "Register component failed: %d\n", ret);
1415                 pm_runtime_disable(cs35l41->dev);
1416                 goto err;
1417         }
1418
1419         dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
1420
1421         return 0;
1422
1423 err_pm:
1424         pm_runtime_disable(cs35l41->dev);
1425         pm_runtime_put_noidle(cs35l41->dev);
1426
1427 err:
1428         if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1429                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1430         gpiod_put(cs35l41->reset_gpio);
1431
1432         return ret;
1433 }
1434 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41);
1435
1436 void cs35l41_hda_remove(struct device *dev)
1437 {
1438         struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1439
1440         pm_runtime_get_sync(cs35l41->dev);
1441         pm_runtime_disable(cs35l41->dev);
1442
1443         if (cs35l41->halo_initialized)
1444                 cs35l41_remove_dsp(cs35l41);
1445
1446         component_del(cs35l41->dev, &cs35l41_hda_comp_ops);
1447
1448         pm_runtime_put_noidle(cs35l41->dev);
1449
1450         if (cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type))
1451                 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0);
1452         gpiod_put(cs35l41->reset_gpio);
1453 }
1454 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41);
1455
1456 const struct dev_pm_ops cs35l41_hda_pm_ops = {
1457         RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, NULL)
1458 };
1459 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
1460
1461 MODULE_DESCRIPTION("CS35L41 HDA Driver");
1462 MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
1463 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");
1464 MODULE_LICENSE("GPL");