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