cs35l56_hda.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2//
   3// HDA audio driver for Cirrus Logic CS35L56 smart amp
   4//
   5// Copyright (C) 2023 Cirrus Logic, Inc. and
   6//                    Cirrus Logic International Semiconductor Ltd.
   7//
   8
   9#include <linux/acpi.h>
  10#include <linux/debugfs.h>
  11#include <linux/gpio/consumer.h>
  12#include <linux/module.h>
  13#include <linux/pm_runtime.h>
  14#include <linux/regmap.h>
  15#include <linux/slab.h>
  16#include <sound/core.h>
  17#include <sound/cs-amp-lib.h>
  18#include <sound/hda_codec.h>
  19#include <sound/tlv.h>
  20#include "cirrus_scodec.h"
  21#include "cs35l56_hda.h"
  22#include "hda_component.h"
  23#include "../generic.h"
  24
  25 /*
  26  * The cs35l56_hda_dai_config[] reg sequence configures the device as
  27  *  ASP1_BCLK_FREQ = 3.072 MHz
  28  *  ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S
  29  *  ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots
  30  *  ASP1_RX_WL = 24 bits per sample
  31  *  ASP1_TX_WL = 24 bits per sample
  32  *  ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled
  33  *
  34  * Override any Windows-specific mixer settings applied by the firmware.
  35  */
  36static const struct reg_sequence cs35l56_hda_dai_config[] = {
  37	{ CS35L56_ASP1_CONTROL1,	0x00000021 },
  38	{ CS35L56_ASP1_CONTROL2,	0x20200200 },
  39	{ CS35L56_ASP1_CONTROL3,	0x00000003 },
  40	{ CS35L56_ASP1_FRAME_CONTROL1,	0x03020100 },
  41	{ CS35L56_ASP1_FRAME_CONTROL5,	0x00020100 },
  42	{ CS35L56_ASP1_DATA_CONTROL5,	0x00000018 },
  43	{ CS35L56_ASP1_DATA_CONTROL1,	0x00000018 },
  44	{ CS35L56_ASP1_ENABLES1,	0x00000000 },
  45	{ CS35L56_ASP1TX1_INPUT,	0x00000018 },
  46	{ CS35L56_ASP1TX2_INPUT,	0x00000019 },
  47	{ CS35L56_ASP1TX3_INPUT,	0x00000020 },
  48	{ CS35L56_ASP1TX4_INPUT,	0x00000028 },
  49
  50};
  51
  52static void cs35l56_hda_wait_dsp_ready(struct cs35l56_hda *cs35l56)
  53{
  54	/* Wait for patching to complete */
  55	flush_work(&cs35l56->dsp_work);
  56}
  57
  58static void cs35l56_hda_play(struct cs35l56_hda *cs35l56)
  59{
  60	unsigned int val;
  61	int ret;
  62
  63	cs35l56_hda_wait_dsp_ready(cs35l56);
  64
  65	pm_runtime_get_sync(cs35l56->base.dev);
  66	ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY);
  67	if (ret == 0) {
  68		/* Wait for firmware to enter PS0 power state */
  69		ret = regmap_read_poll_timeout(cs35l56->base.regmap,
  70					       cs35l56->base.fw_reg->transducer_actual_ps,
  71					       val, (val == CS35L56_PS0),
  72					       CS35L56_PS0_POLL_US,
  73					       CS35L56_PS0_TIMEOUT_US);
  74		if (ret)
  75			dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
  76	}
  77	regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
  78			BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
  79			cs35l56->asp_tx_mask);
  80	cs35l56->playing = true;
  81}
  82
  83static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56)
  84{
  85	cs35l56->playing = false;
  86	cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
  87	regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
  88			  BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
  89			  BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) |
  90			  BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT));
  91
  92	pm_runtime_put_autosuspend(cs35l56->base.dev);
  93}
  94
  95static void cs35l56_hda_playback_hook(struct device *dev, int action)
  96{
  97	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
  98
  99	dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action);
 100
 101	switch (action) {
 102	case HDA_GEN_PCM_ACT_PREPARE:
 103		if (cs35l56->playing)
 104			break;
 105
 106		/* If we're suspended: flag that resume should start playback */
 107		if (cs35l56->suspended) {
 108			cs35l56->playing = true;
 109			break;
 110		}
 111
 112		cs35l56_hda_play(cs35l56);
 113		break;
 114	case HDA_GEN_PCM_ACT_CLEANUP:
 115		if (!cs35l56->playing)
 116			break;
 117
 118		cs35l56_hda_pause(cs35l56);
 119		break;
 120	default:
 121		break;
 122	}
 123}
 124
 125static int cs35l56_hda_runtime_suspend(struct device *dev)
 126{
 127	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 128
 129	if (cs35l56->cs_dsp.booted)
 130		cs_dsp_stop(&cs35l56->cs_dsp);
 131
 132	return cs35l56_runtime_suspend_common(&cs35l56->base);
 133}
 134
 135static int cs35l56_hda_runtime_resume(struct device *dev)
 136{
 137	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 138	int ret;
 139
 140	ret = cs35l56_runtime_resume_common(&cs35l56->base, false);
 141	if (ret < 0)
 142		return ret;
 143
 144	if (cs35l56->cs_dsp.booted) {
 145		ret = cs_dsp_run(&cs35l56->cs_dsp);
 146		if (ret) {
 147			dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
 148			goto err;
 149		}
 150	}
 151
 152	return 0;
 153
 154err:
 155	cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE);
 156	regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
 157		     CS35L56_MBOX_CMD_HIBERNATE_NOW);
 158
 159	regcache_cache_only(cs35l56->base.regmap, true);
 160
 161	return ret;
 162}
 163
 164static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol,
 165				  struct snd_ctl_elem_info *uinfo)
 166{
 167	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 168	uinfo->count = 1;
 169	uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC;
 170	if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC)
 171		uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1;
 172	strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item],
 173		sizeof(uinfo->value.enumerated.name));
 174
 175	return 0;
 176}
 177
 178static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol,
 179				 struct snd_ctl_elem_value *ucontrol)
 180{
 181	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 182	unsigned int reg_val;
 183	int i;
 184
 185	cs35l56_hda_wait_dsp_ready(cs35l56);
 186
 187	regmap_read(cs35l56->base.regmap, kcontrol->private_value, &reg_val);
 188	reg_val &= CS35L56_ASP_TXn_SRC_MASK;
 189
 190	for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
 191		if (cs35l56_tx_input_values[i] == reg_val) {
 192			ucontrol->value.enumerated.item[0] = i;
 193			break;
 194		}
 195	}
 196
 197	return 0;
 198}
 199
 200static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
 201				 struct snd_ctl_elem_value *ucontrol)
 202{
 203	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 204	unsigned int item = ucontrol->value.enumerated.item[0];
 205	bool changed;
 206
 207	if (item >= CS35L56_NUM_INPUT_SRC)
 208		return -EINVAL;
 209
 210	cs35l56_hda_wait_dsp_ready(cs35l56);
 211
 212	regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value,
 213				 CS35L56_INPUT_MASK, cs35l56_tx_input_values[item],
 214				 &changed);
 215
 216	return changed;
 217}
 218
 219static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
 220				    struct snd_ctl_elem_info *uinfo)
 221{
 222	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 223	uinfo->count = 1;
 224	uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
 225	uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
 226	return 0;
 227}
 228
 229static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
 230				   struct snd_ctl_elem_value *ucontrol)
 231{
 232	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 233	unsigned int pos;
 234	int ret;
 235
 236	cs35l56_hda_wait_dsp_ready(cs35l56);
 237
 238	ret = regmap_read(cs35l56->base.regmap,
 239			  cs35l56->base.fw_reg->posture_number, &pos);
 240	if (ret)
 241		return ret;
 242
 243	ucontrol->value.integer.value[0] = pos;
 244
 245	return 0;
 246}
 247
 248static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
 249				   struct snd_ctl_elem_value *ucontrol)
 250{
 251	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 252	long pos = ucontrol->value.integer.value[0];
 253	bool changed;
 254	int ret;
 255
 256	if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
 257	    (pos > CS35L56_MAIN_POSTURE_MAX))
 258		return -EINVAL;
 259
 260	cs35l56_hda_wait_dsp_ready(cs35l56);
 261
 262	ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number,
 263				       CS35L56_MAIN_POSTURE_MASK, pos, &changed);
 264	if (ret)
 265		return ret;
 266
 267	return changed;
 268}
 269
 270static const struct {
 271	const char *name;
 272	unsigned int reg;
 273} cs35l56_hda_mixer_controls[] = {
 274	{ "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
 275	{ "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
 276	{ "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
 277	{ "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
 278};
 279
 280static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
 281
 282static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
 283				struct snd_ctl_elem_info *uinfo)
 284{
 285	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 286	uinfo->count = 1;
 287	uinfo->value.integer.step = 1;
 288	uinfo->value.integer.min = 0;
 289	uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
 290				   CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
 291
 292	return 0;
 293}
 294
 295static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
 296			       struct snd_ctl_elem_value *ucontrol)
 297{
 298	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 299	unsigned int raw_vol;
 300	int vol;
 301	int ret;
 302
 303	cs35l56_hda_wait_dsp_ready(cs35l56);
 304
 305	ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol);
 306
 307	if (ret)
 308		return ret;
 309
 310	vol = (s16)(raw_vol & 0xFFFF);
 311	vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
 312
 313	if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
 314		vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
 315
 316	ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
 317
 318	return 0;
 319}
 320
 321static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
 322			       struct snd_ctl_elem_value *ucontrol)
 323{
 324	struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
 325	long vol = ucontrol->value.integer.value[0];
 326	unsigned int raw_vol;
 327	bool changed;
 328	int ret;
 329
 330	if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
 331				 CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
 332		return -EINVAL;
 333
 334	raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
 335		  CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
 336
 337	cs35l56_hda_wait_dsp_ready(cs35l56);
 338
 339	ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume,
 340				       CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed);
 341	if (ret)
 342		return ret;
 343
 344	return changed;
 345}
 346
 347static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
 348{
 349	struct snd_kcontrol_new ctl_template = {
 350		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 351		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 352		.info = cs35l56_hda_posture_info,
 353		.get = cs35l56_hda_posture_get,
 354		.put = cs35l56_hda_posture_put,
 355	};
 356	char name[64];
 357	int i;
 358
 359	snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
 360	ctl_template.name = name;
 361	cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
 362	if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl))
 363		dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
 364
 365	/* Mixer controls */
 366	ctl_template.info = cs35l56_hda_mixer_info;
 367	ctl_template.get = cs35l56_hda_mixer_get;
 368	ctl_template.put = cs35l56_hda_mixer_put;
 369
 370	BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
 371
 372	for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
 373		snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
 374			 cs35l56_hda_mixer_controls[i].name);
 375		ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
 376		cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
 377		if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
 378			dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
 379				ctl_template.name);
 380		}
 381	}
 382
 383	ctl_template.info = cs35l56_hda_vol_info;
 384	ctl_template.get = cs35l56_hda_vol_get;
 385	ctl_template.put = cs35l56_hda_vol_put;
 386	ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
 387	ctl_template.tlv.p = cs35l56_hda_vol_tlv;
 388	snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
 389	ctl_template.name = name;
 390	cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
 391	if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl))
 392		dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
 393}
 394
 395static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
 396{
 397	int i;
 398
 399	for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
 400		snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
 401
 402	snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
 403	snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
 404}
 405
 406static const struct cs_dsp_client_ops cs35l56_hda_client_ops = {
 407	/* cs_dsp requires the client to provide this even if it is empty */
 408};
 409
 410static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
 411					     const struct firmware **firmware, char **filename,
 412					     const char *base_name, const char *system_name,
 413					     const char *amp_name,
 414					     const char *filetype)
 415{
 416	char *s, c;
 417	int ret = 0;
 418
 419	if (system_name && amp_name)
 420		*filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name,
 421				      system_name, amp_name, filetype);
 422	else if (system_name)
 423		*filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name,
 424				      system_name, filetype);
 425	else
 426		*filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype);
 427
 428	if (!*filename)
 429		return -ENOMEM;
 430
 431	/*
 432	 * Make sure that filename is lower-case and any non alpha-numeric
 433	 * characters except full stop and forward slash are replaced with
 434	 * hyphens.
 435	 */
 436	s = *filename;
 437	while (*s) {
 438		c = *s;
 439		if (isalnum(c))
 440			*s = tolower(c);
 441		else if (c != '.' && c != '/')
 442			*s = '-';
 443		s++;
 444	}
 445
 446	ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
 447	if (ret) {
 448		dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
 449		kfree(*filename);
 450		*filename = NULL;
 451		return ret;
 452	}
 453
 454	dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
 455
 456	return 0;
 457}
 458
 459static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
 460					       unsigned int preloaded_fw_ver,
 461					       const struct firmware **wmfw_firmware,
 462					       char **wmfw_filename,
 463					       const struct firmware **coeff_firmware,
 464					       char **coeff_filename)
 465{
 466	const char *system_name = cs35l56->system_name;
 467	const char *amp_name = cs35l56->amp_name;
 468	char base_name[37];
 469	int ret;
 470
 471	if (preloaded_fw_ver) {
 472		snprintf(base_name, sizeof(base_name),
 473			 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc",
 474			 cs35l56->base.type,
 475			 cs35l56->base.rev,
 476			 cs35l56->base.secured ? "-s" : "",
 477			 preloaded_fw_ver & 0xffffff);
 478	} else {
 479		snprintf(base_name, sizeof(base_name),
 480			 "cirrus/cs35l%02x-%02x%s-dsp1-misc",
 481			 cs35l56->base.type,
 482			 cs35l56->base.rev,
 483			 cs35l56->base.secured ? "-s" : "");
 484	}
 485
 486	if (system_name && amp_name) {
 487		if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
 488						       base_name, system_name, amp_name, "wmfw")) {
 489			cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
 490							  base_name, system_name, amp_name, "bin");
 491			return;
 492		}
 493	}
 494
 495	if (system_name) {
 496		if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
 497						       base_name, system_name, NULL, "wmfw")) {
 498			if (amp_name)
 499				cs35l56_hda_request_firmware_file(cs35l56,
 500								  coeff_firmware, coeff_filename,
 501								  base_name, system_name,
 502								  amp_name, "bin");
 503			if (!*coeff_firmware)
 504				cs35l56_hda_request_firmware_file(cs35l56,
 505								  coeff_firmware, coeff_filename,
 506								  base_name, system_name,
 507								  NULL, "bin");
 508			return;
 509		}
 510
 511		/*
 512		 * Check for system-specific bin files without wmfw before
 513		 * falling back to generic firmware
 514		 */
 515		if (amp_name)
 516			cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
 517							  base_name, system_name, amp_name, "bin");
 518		if (!*coeff_firmware)
 519			cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
 520							  base_name, system_name, NULL, "bin");
 521
 522		if (*coeff_firmware)
 523			return;
 524	}
 525
 526	ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
 527						base_name, NULL, NULL, "wmfw");
 528	if (!ret) {
 529		cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
 530						  base_name, NULL, NULL, "bin");
 531		return;
 532	}
 533
 534	if (!*coeff_firmware)
 535		cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
 536						  base_name, NULL, NULL, "bin");
 537}
 538
 539static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware,
 540					       char *wmfw_filename,
 541					       const struct firmware *coeff_firmware,
 542					       char *coeff_filename)
 543{
 544	release_firmware(wmfw_firmware);
 545	kfree(wmfw_filename);
 546
 547	release_firmware(coeff_firmware);
 548	kfree(coeff_filename);
 549}
 550
 551static int cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56)
 552{
 553	int ret;
 554
 555	if (!cs35l56->base.cal_data_valid || cs35l56->base.secured)
 556		return -EACCES;
 557
 558	ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp,
 559				      &cs35l56_calibration_controls,
 560				      &cs35l56->base.cal_data);
 561	if (ret < 0) {
 562		dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret);
 563		return ret;
 564	}
 565
 566	dev_info(cs35l56->base.dev, "Calibration applied\n");
 567
 568	return 0;
 569}
 570
 571static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
 572{
 573	const struct firmware *coeff_firmware = NULL;
 574	const struct firmware *wmfw_firmware = NULL;
 575	char *coeff_filename = NULL;
 576	char *wmfw_filename = NULL;
 577	unsigned int preloaded_fw_ver;
 578	bool firmware_missing;
 579	int ret;
 580
 581	/*
 582	 * Prepare for a new DSP power-up. If the DSP has had firmware
 583	 * downloaded previously then it needs to be powered down so that it
 584	 * can be updated.
 585	 */
 586	if (cs35l56->base.fw_patched)
 587		cs_dsp_power_down(&cs35l56->cs_dsp);
 588
 589	cs35l56->base.fw_patched = false;
 590
 591	ret = pm_runtime_resume_and_get(cs35l56->base.dev);
 592	if (ret < 0) {
 593		dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret);
 594		return;
 595	}
 596
 597	/*
 598	 * The firmware can only be upgraded if it is currently running
 599	 * from the built-in ROM. If not, the wmfw/bin must be for the
 600	 * version of firmware that is running on the chip.
 601	 */
 602	ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver);
 603	if (ret)
 604		goto err_pm_put;
 605
 606	if (firmware_missing)
 607		preloaded_fw_ver = 0;
 608
 609	cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver,
 610					   &wmfw_firmware, &wmfw_filename,
 611					   &coeff_firmware, &coeff_filename);
 612
 613	/*
 614	 * If the BIOS didn't patch the firmware a bin file is mandatory to
 615	 * enable the ASP·
 616	 */
 617	if (!coeff_firmware && firmware_missing) {
 618		dev_err(cs35l56->base.dev, ".bin file required but not found\n");
 619		goto err_fw_release;
 620	}
 621
 622	mutex_lock(&cs35l56->base.irq_lock);
 623
 624	/*
 625	 * If the firmware hasn't been patched it must be shutdown before
 626	 * doing a full patch and reset afterwards. If it is already
 627	 * running a patched version the firmware files only contain
 628	 * tunings and we can use the lower cost reinit sequence instead.
 629	 */
 630	if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
 631		ret = cs35l56_firmware_shutdown(&cs35l56->base);
 632		if (ret)
 633			goto err;
 634	}
 635
 636	ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
 637			      coeff_firmware, coeff_filename, "misc");
 638	if (ret) {
 639		dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
 640		goto err;
 641	}
 642
 643	if (wmfw_filename)
 644		dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
 645
 646	if (coeff_filename)
 647		dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
 648
 649	/* If we downloaded firmware, reset the device and wait for it to boot */
 650	if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
 651		cs35l56_system_reset(&cs35l56->base, false);
 652		regcache_mark_dirty(cs35l56->base.regmap);
 653		ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
 654		if (ret)
 655			goto err_powered_up;
 656
 657		regcache_cache_only(cs35l56->base.regmap, false);
 658	}
 659
 660	/* Disable auto-hibernate so that runtime_pm has control */
 661	ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
 662	if (ret)
 663		goto err_powered_up;
 664
 665	regcache_sync(cs35l56->base.regmap);
 666
 667	regmap_clear_bits(cs35l56->base.regmap,
 668			  cs35l56->base.fw_reg->prot_sts,
 669			  CS35L56_FIRMWARE_MISSING);
 670	cs35l56->base.fw_patched = true;
 671
 672	ret = cs_dsp_run(&cs35l56->cs_dsp);
 673	if (ret)
 674		dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
 675
 676	/* Don't need to check return code, it's not fatal if this fails */
 677	cs35l56_hda_apply_calibration(cs35l56);
 678
 679	ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
 680	if (ret)
 681		cs_dsp_stop(&cs35l56->cs_dsp);
 682
 683	cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp);
 684
 685err_powered_up:
 686	if (!cs35l56->base.fw_patched)
 687		cs_dsp_power_down(&cs35l56->cs_dsp);
 688err:
 689	mutex_unlock(&cs35l56->base.irq_lock);
 690err_fw_release:
 691	cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename,
 692					   coeff_firmware, coeff_filename);
 693err_pm_put:
 694	pm_runtime_put(cs35l56->base.dev);
 695}
 696
 697static void cs35l56_hda_dsp_work(struct work_struct *work)
 698{
 699	struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work);
 700
 701	cs35l56_hda_fw_load(cs35l56);
 702}
 703
 704static ssize_t cs35l56_hda_debugfs_calibrate_write(struct file *file,
 705						   const char __user *from,
 706						   size_t count, loff_t *ppos)
 707{
 708	struct cs35l56_base *cs35l56_base = file->private_data;
 709	ssize_t ret;
 710
 711	ret = pm_runtime_resume_and_get(cs35l56_base->dev);
 712	if (ret)
 713		return ret;
 714
 715	ret = cs35l56_calibrate_debugfs_write(cs35l56_base, from, count, ppos);
 716	pm_runtime_autosuspend(cs35l56_base->dev);
 717
 718	return ret;
 719}
 720
 721static ssize_t cs35l56_hda_debugfs_cal_temperature_write(struct file *file,
 722							 const char __user *from,
 723							 size_t count, loff_t *ppos)
 724{
 725	struct cs35l56_base *cs35l56_base = file->private_data;
 726	ssize_t ret;
 727
 728	ret = pm_runtime_resume_and_get(cs35l56_base->dev);
 729	if (ret)
 730		return ret;
 731
 732	ret = cs35l56_cal_ambient_debugfs_write(cs35l56_base, from, count, ppos);
 733	pm_runtime_autosuspend(cs35l56_base->dev);
 734
 735	return ret;
 736}
 737
 738static ssize_t cs35l56_hda_debugfs_cal_data_read(struct file *file,
 739						 char __user *to,
 740						 size_t count, loff_t *ppos)
 741{
 742	struct cs35l56_base *cs35l56_base = file->private_data;
 743	ssize_t ret;
 744
 745	ret = pm_runtime_resume_and_get(cs35l56_base->dev);
 746	if (ret)
 747		return ret;
 748
 749	ret = cs35l56_cal_data_debugfs_read(cs35l56_base, to, count, ppos);
 750	pm_runtime_autosuspend(cs35l56_base->dev);
 751
 752	return ret;
 753}
 754
 755static ssize_t cs35l56_hda_debugfs_cal_data_write(struct file *file,
 756						  const char __user *from,
 757						  size_t count, loff_t *ppos)
 758{
 759	struct cs35l56_base *cs35l56_base = file->private_data;
 760	struct cs35l56_hda *cs35l56 = cs35l56_hda_from_base(cs35l56_base);
 761	ssize_t ret;
 762
 763	ret = cs35l56_cal_data_debugfs_write(cs35l56_base, from, count, ppos);
 764	if (ret == -ENODATA)
 765		return count;	/* Ignore writes of empty cal blobs */
 766
 767	if (ret < 0)
 768		return ret;
 769
 770	ret = pm_runtime_resume_and_get(cs35l56_base->dev);
 771	if (ret)
 772		return ret;
 773
 774	ret = cs35l56_hda_apply_calibration(cs35l56);
 775	if (ret == 0)
 776		cs35l56_mbox_send(cs35l56_base, CS35L56_MBOX_CMD_AUDIO_REINIT);
 777	else
 778		count = -EIO;
 779
 780	pm_runtime_autosuspend(cs35l56_base->dev);
 781
 782	return count;
 783}
 784
 785static const struct cs35l56_cal_debugfs_fops cs35l56_hda_cal_debugfs_fops = {
 786	.calibrate = {
 787		.write = cs35l56_hda_debugfs_calibrate_write,
 788	},
 789	.cal_temperature = {
 790		.write = cs35l56_hda_debugfs_cal_temperature_write,
 791	},
 792	.cal_data = {
 793		.read = cs35l56_hda_debugfs_cal_data_read,
 794		.write = cs35l56_hda_debugfs_cal_data_write,
 795	},
 796};
 797
 798static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
 799{
 800	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 801	struct hda_component_parent *parent = master_data;
 802	struct hda_component *comp;
 803
 804	comp = hda_component_from_index(parent, cs35l56->index);
 805	if (!comp)
 806		return -EINVAL;
 807
 808	if (comp->dev)
 809		return -EBUSY;
 810
 811	comp->dev = dev;
 812	cs35l56->codec = parent->codec;
 813	strscpy(comp->name, dev_name(dev), sizeof(comp->name));
 814	comp->playback_hook = cs35l56_hda_playback_hook;
 815
 816	queue_work(system_long_wq, &cs35l56->dsp_work);
 817
 818	cs35l56_hda_create_controls(cs35l56);
 819
 820#if IS_ENABLED(CONFIG_SND_DEBUG)
 821	cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
 822	cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
 823#endif
 824
 825	if (IS_ENABLED(CONFIG_SND_HDA_SCODEC_CS35L56_CAL_DEBUGFS))
 826		cs35l56_create_cal_debugfs(&cs35l56->base, &cs35l56_hda_cal_debugfs_fops);
 827
 828	dev_dbg(cs35l56->base.dev, "Bound\n");
 829
 830	return 0;
 831}
 832
 833static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
 834{
 835	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 836	struct hda_component_parent *parent = master_data;
 837	struct hda_component *comp;
 838
 839	cancel_work_sync(&cs35l56->dsp_work);
 840
 841	cs35l56_remove_cal_debugfs(&cs35l56->base);
 842	cs35l56_hda_remove_controls(cs35l56);
 843
 844#if IS_ENABLED(CONFIG_SND_DEBUG)
 845	cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
 846	debugfs_remove_recursive(cs35l56->debugfs_root);
 847#endif
 848
 849	if (cs35l56->base.fw_patched)
 850		cs_dsp_power_down(&cs35l56->cs_dsp);
 851
 852	comp = hda_component_from_index(parent, cs35l56->index);
 853	if (comp && (comp->dev == dev))
 854		memset(comp, 0, sizeof(*comp));
 855
 856	cs35l56->codec = NULL;
 857
 858	dev_dbg(cs35l56->base.dev, "Unbound\n");
 859}
 860
 861static const struct component_ops cs35l56_hda_comp_ops = {
 862	.bind = cs35l56_hda_bind,
 863	.unbind = cs35l56_hda_unbind,
 864};
 865
 866static int cs35l56_hda_system_suspend(struct device *dev)
 867{
 868	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 869
 870	cs35l56_hda_wait_dsp_ready(cs35l56);
 871
 872	if (cs35l56->playing)
 873		cs35l56_hda_pause(cs35l56);
 874
 875	cs35l56->suspended = true;
 876
 877	/*
 878	 * The interrupt line is normally shared, but after we start suspending
 879	 * we can't check if our device is the source of an interrupt, and can't
 880	 * clear it. Prevent this race by temporarily disabling the parent irq
 881	 * until we reach _no_irq.
 882	 */
 883	if (cs35l56->base.irq)
 884		disable_irq(cs35l56->base.irq);
 885
 886	return pm_runtime_force_suspend(dev);
 887}
 888
 889static int cs35l56_hda_system_suspend_late(struct device *dev)
 890{
 891	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 892
 893	/*
 894	 * RESET is usually shared by all amps so it must not be asserted until
 895	 * all driver instances have done their suspend() stage.
 896	 */
 897	if (cs35l56->base.reset_gpio) {
 898		gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
 899		cs35l56_wait_min_reset_pulse();
 900	}
 901
 902	return 0;
 903}
 904
 905static int cs35l56_hda_system_suspend_no_irq(struct device *dev)
 906{
 907	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 908
 909	/* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
 910	if (cs35l56->base.irq)
 911		enable_irq(cs35l56->base.irq);
 912
 913	return 0;
 914}
 915
 916static int cs35l56_hda_system_resume_no_irq(struct device *dev)
 917{
 918	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 919
 920	/*
 921	 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
 922	 * spurious interrupts, and the interrupt line is normally shared.
 923	 * We can't check if our device is the source of an interrupt, and can't
 924	 * clear it, until it has fully resumed. Prevent this race by temporarily
 925	 * disabling the parent irq until we complete resume().
 926	 */
 927	if (cs35l56->base.irq)
 928		disable_irq(cs35l56->base.irq);
 929
 930	return 0;
 931}
 932
 933static int cs35l56_hda_system_resume_early(struct device *dev)
 934{
 935	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 936
 937	/* Ensure a spec-compliant RESET pulse. */
 938	if (cs35l56->base.reset_gpio) {
 939		gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
 940		cs35l56_wait_min_reset_pulse();
 941
 942		/* Release shared RESET before drivers start resume(). */
 943		gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
 944		cs35l56_wait_control_port_ready();
 945	}
 946
 947	return 0;
 948}
 949
 950static int cs35l56_hda_system_resume(struct device *dev)
 951{
 952	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
 953	int ret;
 954
 955	/* Undo pm_runtime_force_suspend() before re-enabling the irq */
 956	ret = pm_runtime_force_resume(dev);
 957	if (cs35l56->base.irq)
 958		enable_irq(cs35l56->base.irq);
 959
 960	if (ret)
 961		return ret;
 962
 963	cs35l56->suspended = false;
 964
 965	if (!cs35l56->codec)
 966		return 0;
 967
 968	ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
 969	dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
 970	if (ret > 0)
 971		queue_work(system_long_wq, &cs35l56->dsp_work);
 972
 973	if (cs35l56->playing)
 974		cs35l56_hda_play(cs35l56);
 975
 976	return 0;
 977}
 978
 979static int cs35l56_hda_fixup_yoga9(struct cs35l56_hda *cs35l56, int *bus_addr)
 980{
 981	/* The cirrus,dev-index property has the wrong values */
 982	switch (*bus_addr) {
 983	case 0x30:
 984		cs35l56->index = 1;
 985		return 0;
 986	case 0x31:
 987		cs35l56->index = 0;
 988		return 0;
 989	default:
 990		/* There is a pseudo-address for broadcast to both amps - ignore it */
 991		dev_dbg(cs35l56->base.dev, "Ignoring I2C address %#x\n", *bus_addr);
 992		return 0;
 993	}
 994}
 995
 996static const struct {
 997	const char *sub;
 998	int (*fixup_fn)(struct cs35l56_hda *cs35l56, int *bus_addr);
 999} cs35l56_hda_fixups[] = {
1000	{
1001		.sub = "17AA390B", /* Lenovo Yoga Book 9i GenX */
1002		.fixup_fn = cs35l56_hda_fixup_yoga9,
1003	},
1004};
1005
1006static int cs35l56_hda_apply_platform_fixups(struct cs35l56_hda *cs35l56, const char *sub,
1007					     int *bus_addr)
1008{
1009	int i;
1010
1011	if (IS_ERR(sub))
1012		return 0;
1013
1014	for (i = 0; i < ARRAY_SIZE(cs35l56_hda_fixups); i++) {
1015		if (strcasecmp(cs35l56_hda_fixups[i].sub, sub) == 0) {
1016			dev_dbg(cs35l56->base.dev, "Applying fixup for %s\n",
1017				cs35l56_hda_fixups[i].sub);
1018			return (cs35l56_hda_fixups[i].fixup_fn)(cs35l56, bus_addr);
1019		}
1020	}
1021
1022	return 0;
1023}
1024
1025static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id)
1026{
1027	u32 values[HDA_MAX_COMPONENTS];
1028	char hid_string[8];
1029	struct acpi_device *adev;
1030	const char *property, *sub;
1031	size_t nval;
1032	int i, ret;
1033
1034	/*
1035	 * ACPI_COMPANION isn't available when this driver was instantiated by
1036	 * the serial-multi-instantiate driver, so lookup the node by HID
1037	 */
1038	if (!ACPI_COMPANION(cs35l56->base.dev)) {
1039		snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid);
1040		adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1);
1041		if (!adev) {
1042			dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
1043				dev_name(cs35l56->base.dev));
1044			return -ENODEV;
1045		}
1046		ACPI_COMPANION_SET(cs35l56->base.dev, adev);
1047	}
1048
1049	/* Initialize things that could be overwritten by a fixup */
1050	cs35l56->index = -1;
1051
1052	sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
1053	ret = cs35l56_hda_apply_platform_fixups(cs35l56, sub, &id);
1054	if (ret)
1055		return ret;
1056
1057	if (cs35l56->index == -1) {
1058		property = "cirrus,dev-index";
1059		ret = device_property_count_u32(cs35l56->base.dev, property);
1060		if (ret <= 0)
1061			goto err;
1062
1063		if (ret > ARRAY_SIZE(values)) {
1064			ret = -EINVAL;
1065			goto err;
1066		}
1067		nval = ret;
1068
1069		ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval);
1070		if (ret)
1071			goto err;
1072
1073		for (i = 0; i < nval; i++) {
1074			if (values[i] == id) {
1075				cs35l56->index = i;
1076				break;
1077			}
1078		}
1079
1080		/*
1081		 * It's not an error for the ID to be missing: for I2C there can be
1082		 * an alias address that is not a real device. So reject silently.
1083		 */
1084		if (cs35l56->index == -1) {
1085			dev_dbg(cs35l56->base.dev, "No index found in %s\n", property);
1086			ret = -ENODEV;
1087			goto err;
1088		}
1089	}
1090
1091	if (IS_ERR(sub)) {
1092		dev_info(cs35l56->base.dev,
1093			 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n",
1094			 PTR_ERR(sub));
1095	} else {
1096		ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index, nval, -1);
1097		if (ret == -ENOENT) {
1098			cs35l56->system_name = sub;
1099		} else if (ret >= 0) {
1100			cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret);
1101			kfree(sub);
1102			if (!cs35l56->system_name)
1103				return -ENOMEM;
1104		} else {
1105			return ret;
1106		}
1107	}
1108
1109	cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
1110								 "reset",
1111								 cs35l56->index,
1112								 GPIOD_OUT_LOW);
1113	if (IS_ERR(cs35l56->base.reset_gpio)) {
1114		ret = PTR_ERR(cs35l56->base.reset_gpio);
1115
1116		/*
1117		 * If RESET is shared the first amp to probe will grab the reset
1118		 * line and reset all the amps
1119		 */
1120		if (ret != -EBUSY)
1121			return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
1122
1123		dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
1124		cs35l56->base.reset_gpio = NULL;
1125	}
1126
1127	return 0;
1128
1129err:
1130	if (ret != -ENODEV)
1131		dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
1132
1133	return ret;
1134}
1135
1136int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id)
1137{
1138	int ret;
1139
1140	mutex_init(&cs35l56->base.irq_lock);
1141	dev_set_drvdata(cs35l56->base.dev, cs35l56);
1142
1143	INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work);
1144
1145	ret = cs35l56_hda_read_acpi(cs35l56, hid, id);
1146	if (ret)
1147		goto err;
1148
1149	cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
1150					   cs35l56->index + 1);
1151	if (!cs35l56->amp_name) {
1152		ret = -ENOMEM;
1153		goto err;
1154	}
1155
1156	cs35l56->base.type = hid & 0xff;
1157	cs35l56->base.cal_index = cs35l56->index;
1158
1159	cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
1160	cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops;
1161
1162	if (cs35l56->base.reset_gpio) {
1163		dev_dbg(cs35l56->base.dev, "Hard reset\n");
1164
1165		/*
1166		 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
1167		 * ACPI defines a different default state. So explicitly set low.
1168		 */
1169		gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1170		cs35l56_wait_min_reset_pulse();
1171		gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1172	}
1173
1174	ret = cs35l56_hw_init(&cs35l56->base);
1175	if (ret < 0)
1176		goto err;
1177
1178	/* Reset the device and wait for it to boot */
1179	cs35l56_system_reset(&cs35l56->base, false);
1180	ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
1181	if (ret)
1182		goto err;
1183
1184	regcache_cache_only(cs35l56->base.regmap, false);
1185
1186	ret = cs35l56_set_patch(&cs35l56->base);
1187	if (ret)
1188		goto err;
1189
1190	regcache_mark_dirty(cs35l56->base.regmap);
1191	regcache_sync(cs35l56->base.regmap);
1192
1193	/* Disable auto-hibernate so that runtime_pm has control */
1194	ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
1195	if (ret)
1196		goto err;
1197
1198	ret = cs35l56_get_calibration(&cs35l56->base);
1199	if (ret)
1200		goto err;
1201
1202	ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
1203	if (ret) {
1204		dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
1205		goto err;
1206	}
1207
1208	dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
1209		 cs35l56->system_name, cs35l56->amp_name);
1210
1211	regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
1212			       ARRAY_SIZE(cs35l56_hda_dai_config));
1213
1214	/*
1215	 * By default only enable one ASP1TXn, where n=amplifier index,
1216	 * This prevents multiple amps trying to drive the same slot.
1217	 */
1218	cs35l56->asp_tx_mask = BIT(cs35l56->index);
1219
1220	pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
1221	pm_runtime_use_autosuspend(cs35l56->base.dev);
1222	pm_runtime_set_active(cs35l56->base.dev);
1223	pm_runtime_mark_last_busy(cs35l56->base.dev);
1224	pm_runtime_enable(cs35l56->base.dev);
1225
1226	cs35l56->base.init_done = true;
1227
1228	ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1229	if (ret) {
1230		dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
1231		goto pm_err;
1232	}
1233
1234	return 0;
1235
1236pm_err:
1237	pm_runtime_disable(cs35l56->base.dev);
1238	cs_dsp_remove(&cs35l56->cs_dsp);
1239err:
1240	gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1241
1242	return ret;
1243}
1244EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56");
1245
1246void cs35l56_hda_remove(struct device *dev)
1247{
1248	struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
1249
1250	component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1251
1252	pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1253	pm_runtime_get_sync(cs35l56->base.dev);
1254	pm_runtime_disable(cs35l56->base.dev);
1255
1256	cs_dsp_remove(&cs35l56->cs_dsp);
1257
1258	kfree(cs35l56->system_name);
1259	pm_runtime_put_noidle(cs35l56->base.dev);
1260
1261	gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1262}
1263EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56");
1264
1265const struct dev_pm_ops cs35l56_hda_pm_ops = {
1266	RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
1267	SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
1268	LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
1269				 cs35l56_hda_system_resume_early)
1270	NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
1271				  cs35l56_hda_system_resume_no_irq)
1272};
1273EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56");
1274
1275MODULE_DESCRIPTION("CS35L56 HDA Driver");
1276MODULE_IMPORT_NS("FW_CS_DSP");
1277MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC");
1278MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
1279MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
1280MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1281MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1282MODULE_LICENSE("GPL");
1283MODULE_FIRMWARE("cirrus/cs35l54-*.wmfw");
1284MODULE_FIRMWARE("cirrus/cs35l54-*.bin");
1285MODULE_FIRMWARE("cirrus/cs35l56-*.wmfw");
1286MODULE_FIRMWARE("cirrus/cs35l56-*.bin");