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