rt711-sdca.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2//
   3// rt711-sdca.c -- rt711 SDCA ALSA SoC audio driver
   4//
   5// Copyright(c) 2021 Realtek Semiconductor Corp.
   6//
   7//
   8
   9#include <linux/module.h>
  10#include <linux/moduleparam.h>
  11#include <linux/kernel.h>
  12#include <linux/init.h>
  13#include <linux/delay.h>
  14#include <linux/pm_runtime.h>
  15#include <linux/soundwire/sdw_registers.h>
  16#include <linux/slab.h>
  17#include <linux/bitops.h>
  18#include <sound/core.h>
  19#include <sound/pcm.h>
  20#include <sound/pcm_params.h>
  21#include <sound/sdw.h>
  22#include <sound/soc-dapm.h>
  23#include <sound/initval.h>
  24#include <sound/tlv.h>
  25#include <sound/jack.h>
  26
  27#include "rt711-sdca.h"
  28
  29static int rt711_sdca_index_write(struct rt711_sdca_priv *rt711,
  30		unsigned int nid, unsigned int reg, unsigned int value)
  31{
  32	int ret;
  33	struct regmap *regmap = rt711->mbq_regmap;
  34	unsigned int addr = (nid << 20) | reg;
  35
  36	ret = regmap_write(regmap, addr, value);
  37	if (ret < 0)
  38		dev_err(&rt711->slave->dev,
  39			"%s: Failed to set private value: %06x <= %04x ret=%d\n",
  40			__func__, addr, value, ret);
  41
  42	return ret;
  43}
  44
  45static int rt711_sdca_index_read(struct rt711_sdca_priv *rt711,
  46		unsigned int nid, unsigned int reg, unsigned int *value)
  47{
  48	int ret;
  49	struct regmap *regmap = rt711->mbq_regmap;
  50	unsigned int addr = (nid << 20) | reg;
  51
  52	ret = regmap_read(regmap, addr, value);
  53	if (ret < 0)
  54		dev_err(&rt711->slave->dev,
  55			"%s: Failed to get private value: %06x => %04x ret=%d\n",
  56			__func__, addr, *value, ret);
  57
  58	return ret;
  59}
  60
  61static int rt711_sdca_index_update_bits(struct rt711_sdca_priv *rt711,
  62	unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val)
  63{
  64	unsigned int tmp;
  65	int ret;
  66
  67	ret = rt711_sdca_index_read(rt711, nid, reg, &tmp);
  68	if (ret < 0)
  69		return ret;
  70
  71	set_mask_bits(&tmp, mask, val);
  72	return rt711_sdca_index_write(rt711, nid, reg, tmp);
  73}
  74
  75static void rt711_sdca_reset(struct rt711_sdca_priv *rt711)
  76{
  77	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
  78		RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET,
  79		RT711_HIDDEN_REG_SW_RESET);
  80	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
  81		RT711_HDA_LEGACY_RESET_CTL, 0x1, 0x1);
  82}
  83
  84static void rt711_sdca_ge_force_jack_type(struct rt711_sdca_priv *rt711, unsigned int det_mode)
  85{
  86	switch (det_mode) {
  87	case 0x00:
  88		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x0000);
  89		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x10, 0x00);
  90		break;
  91	case 0x03:
  92		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8000);
  93		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x13);
  94		break;
  95	case 0x05:
  96		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8400);
  97		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x15);
  98		break;
  99	}
 100}
 101
 102static int rt711_sdca_calibration(struct rt711_sdca_priv *rt711)
 103{
 104	unsigned int val, loop_rc = 0, loop_dc = 0;
 105	struct device *dev;
 106	struct regmap *regmap = rt711->regmap;
 107	int chk_cnt = 100;
 108	int ret = 0;
 109
 110	mutex_lock(&rt711->calibrate_mutex);
 111	dev = regmap_get_device(regmap);
 112
 113	regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
 114	/* RC calibration */
 115	if (!(val & 0x40))
 116		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
 117			RT711_MISC_POWER_CTL0, 0x0010, 0x0010);
 118
 119	for (loop_rc = 0; loop_rc < chk_cnt && !(val & 0x40); loop_rc++) {
 120		usleep_range(10000, 11000);
 121		ret = regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
 122		if (ret < 0)
 123			goto _cali_fail_;
 124	}
 125	if (loop_rc == chk_cnt)
 126		dev_err(dev, "%s, RC calibration time-out!\n", __func__);
 127
 128	/* HP calibration by manual mode setting */
 129	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 130		RT711_FSM_CTL, 0x2000, 0x2000);
 131
 132	/* Calibration manual mode */
 133	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 134		RT711_FSM_CTL, 0xf, RT711_CALI_CTL);
 135
 136	/* reset HP calibration */
 137	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
 138		RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST, 0x00);
 139	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
 140		RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST,
 141		RT711_DAC_DC_FORCE_CALI_RST);
 142
 143	/* cal_clk_en_reg */
 144	if (rt711->hw_ver == RT711_VER_VD0)
 145		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
 146			RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_CLK_EN,
 147			RT711_DAC_DC_CALI_CLK_EN);
 148
 149	/* trigger */
 150	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
 151		RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER,
 152		RT711_DAC_DC_CALI_TRIGGER);
 153
 154	/* wait for calibration process */
 155	rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
 156		RT711_DAC_DC_CALI_CTL1, &val);
 157
 158	for (loop_dc = 0; loop_dc < chk_cnt &&
 159		(val & RT711_DAC_DC_CALI_TRIGGER); loop_dc++) {
 160		usleep_range(10000, 11000);
 161		ret = rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
 162			RT711_DAC_DC_CALI_CTL1, &val);
 163		if (ret < 0)
 164			goto _cali_fail_;
 165	}
 166	if (loop_dc == chk_cnt)
 167		dev_err(dev, "%s, calibration time-out!\n", __func__);
 168
 169	if (loop_dc == chk_cnt || loop_rc == chk_cnt)
 170		ret = -ETIMEDOUT;
 171
 172_cali_fail_:
 173	/* enable impedance sense */
 174	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 175		RT711_FSM_CTL, RT711_FSM_IMP_EN, RT711_FSM_IMP_EN);
 176
 177	/* release HP-JD and trigger FSM */
 178	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
 179		RT711_DIGITAL_MISC_CTRL4, 0x201b);
 180
 181	mutex_unlock(&rt711->calibrate_mutex);
 182	dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
 183	return ret;
 184}
 185
 186static unsigned int rt711_sdca_button_detect(struct rt711_sdca_priv *rt711)
 187{
 188	unsigned int btn_type = 0, offset, idx, val, owner;
 189	int ret;
 190	unsigned char buf[3];
 191
 192	/* get current UMP message owner */
 193	ret = regmap_read(rt711->regmap,
 194		SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0),
 195		&owner);
 196	if (ret < 0)
 197		return 0;
 198
 199	/* if owner is device then there is no button event from device */
 200	if (owner == 1)
 201		return 0;
 202
 203	/* read UMP message offset */
 204	ret = regmap_read(rt711->regmap,
 205		SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
 206		&offset);
 207	if (ret < 0)
 208		goto _end_btn_det_;
 209
 210	for (idx = 0; idx < sizeof(buf); idx++) {
 211		ret = regmap_read(rt711->regmap,
 212			RT711_BUF_ADDR_HID1 + offset + idx, &val);
 213		if (ret < 0)
 214			goto _end_btn_det_;
 215		buf[idx] = val & 0xff;
 216	}
 217
 218	if (buf[0] == 0x11) {
 219		switch (buf[1] & 0xf0) {
 220		case 0x10:
 221			btn_type |= SND_JACK_BTN_2;
 222			break;
 223		case 0x20:
 224			btn_type |= SND_JACK_BTN_3;
 225			break;
 226		case 0x40:
 227			btn_type |= SND_JACK_BTN_0;
 228			break;
 229		case 0x80:
 230			btn_type |= SND_JACK_BTN_1;
 231			break;
 232		}
 233		switch (buf[2]) {
 234		case 0x01:
 235		case 0x10:
 236			btn_type |= SND_JACK_BTN_2;
 237			break;
 238		case 0x02:
 239		case 0x20:
 240			btn_type |= SND_JACK_BTN_3;
 241			break;
 242		case 0x04:
 243		case 0x40:
 244			btn_type |= SND_JACK_BTN_0;
 245			break;
 246		case 0x08:
 247		case 0x80:
 248			btn_type |= SND_JACK_BTN_1;
 249			break;
 250		}
 251	}
 252
 253_end_btn_det_:
 254	/* Host is owner, so set back to device */
 255	if (owner == 0)
 256		/* set owner to device */
 257		regmap_write(rt711->regmap,
 258			SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01,
 259				RT711_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01);
 260
 261	return btn_type;
 262}
 263
 264static int rt711_sdca_headset_detect(struct rt711_sdca_priv *rt711)
 265{
 266	unsigned int det_mode;
 267	int ret;
 268
 269	rt711_sdca_ge_force_jack_type(rt711, rt711->ge_mode_override);
 270
 271	/* get detected_mode */
 272	ret = regmap_read(rt711->regmap,
 273		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
 274		&det_mode);
 275	if (ret < 0)
 276		goto io_error;
 277
 278	switch (det_mode) {
 279	case 0x00:
 280		rt711->jack_type = 0;
 281		break;
 282	case 0x03:
 283		rt711->jack_type = SND_JACK_HEADPHONE;
 284		break;
 285	case 0x05:
 286		rt711->jack_type = SND_JACK_HEADSET;
 287		break;
 288	}
 289
 290	/* write selected_mode */
 291	if (det_mode) {
 292		ret = regmap_write(rt711->regmap,
 293			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_SELECTED_MODE, 0),
 294			det_mode);
 295		if (ret < 0)
 296			goto io_error;
 297	}
 298
 299	dev_dbg(&rt711->slave->dev,
 300		"%s, detected_mode=0x%x\n", __func__, det_mode);
 301
 302	return 0;
 303
 304io_error:
 305	pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 306	return ret;
 307}
 308
 309static void rt711_sdca_jack_detect_handler(struct work_struct *work)
 310{
 311	struct rt711_sdca_priv *rt711 =
 312		container_of(work, struct rt711_sdca_priv, jack_detect_work.work);
 313	int btn_type = 0, ret;
 314
 315	if (!rt711->hs_jack)
 316		return;
 317
 318	if (!snd_soc_card_is_instantiated(rt711->component->card))
 319		return;
 320
 321	/* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */
 322	if (rt711->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
 323		ret = rt711_sdca_headset_detect(rt711);
 324		if (ret < 0)
 325			return;
 326	}
 327
 328	/* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
 329	if (rt711->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
 330		btn_type = rt711_sdca_button_detect(rt711);
 331
 332	if (rt711->jack_type == 0)
 333		btn_type = 0;
 334
 335	dev_dbg(&rt711->slave->dev,
 336		"in %s, jack_type=0x%x\n", __func__, rt711->jack_type);
 337	dev_dbg(&rt711->slave->dev,
 338		"in %s, btn_type=0x%x\n", __func__, btn_type);
 339	dev_dbg(&rt711->slave->dev,
 340		"in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
 341		rt711->scp_sdca_stat1, rt711->scp_sdca_stat2);
 342
 343	snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
 344			SND_JACK_HEADSET |
 345			SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 346			SND_JACK_BTN_2 | SND_JACK_BTN_3);
 347
 348	if (btn_type) {
 349		/* button released */
 350		snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
 351			SND_JACK_HEADSET |
 352			SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 353			SND_JACK_BTN_2 | SND_JACK_BTN_3);
 354
 355		mod_delayed_work(system_power_efficient_wq,
 356			&rt711->jack_btn_check_work, msecs_to_jiffies(200));
 357	}
 358}
 359
 360static void rt711_sdca_btn_check_handler(struct work_struct *work)
 361{
 362	struct rt711_sdca_priv *rt711 =
 363		container_of(work, struct rt711_sdca_priv, jack_btn_check_work.work);
 364	int btn_type = 0, ret, idx;
 365	unsigned int det_mode, offset, val;
 366	unsigned char buf[3];
 367
 368	ret = regmap_read(rt711->regmap,
 369		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
 370		&det_mode);
 371	if (ret < 0)
 372		goto io_error;
 373
 374	/* pin attached */
 375	if (det_mode) {
 376		/* read UMP message offset */
 377		ret = regmap_read(rt711->regmap,
 378			SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
 379			&offset);
 380		if (ret < 0)
 381			goto io_error;
 382
 383		for (idx = 0; idx < sizeof(buf); idx++) {
 384			ret = regmap_read(rt711->regmap,
 385				RT711_BUF_ADDR_HID1 + offset + idx, &val);
 386			if (ret < 0)
 387				goto io_error;
 388			buf[idx] = val & 0xff;
 389		}
 390
 391		if (buf[0] == 0x11) {
 392			switch (buf[1] & 0xf0) {
 393			case 0x10:
 394				btn_type |= SND_JACK_BTN_2;
 395				break;
 396			case 0x20:
 397				btn_type |= SND_JACK_BTN_3;
 398				break;
 399			case 0x40:
 400				btn_type |= SND_JACK_BTN_0;
 401				break;
 402			case 0x80:
 403				btn_type |= SND_JACK_BTN_1;
 404				break;
 405			}
 406			switch (buf[2]) {
 407			case 0x01:
 408			case 0x10:
 409				btn_type |= SND_JACK_BTN_2;
 410				break;
 411			case 0x02:
 412			case 0x20:
 413				btn_type |= SND_JACK_BTN_3;
 414				break;
 415			case 0x04:
 416			case 0x40:
 417				btn_type |= SND_JACK_BTN_0;
 418				break;
 419			case 0x08:
 420			case 0x80:
 421				btn_type |= SND_JACK_BTN_1;
 422				break;
 423			}
 424		}
 425	} else
 426		rt711->jack_type = 0;
 427
 428	dev_dbg(&rt711->slave->dev, "%s, btn_type=0x%x\n",	__func__, btn_type);
 429	snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
 430			SND_JACK_HEADSET |
 431			SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 432			SND_JACK_BTN_2 | SND_JACK_BTN_3);
 433
 434	if (btn_type) {
 435		/* button released */
 436		snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
 437			SND_JACK_HEADSET |
 438			SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 439			SND_JACK_BTN_2 | SND_JACK_BTN_3);
 440
 441		mod_delayed_work(system_power_efficient_wq,
 442			&rt711->jack_btn_check_work, msecs_to_jiffies(200));
 443	}
 444
 445	return;
 446
 447io_error:
 448	pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
 449}
 450
 451static void rt711_sdca_jack_init(struct rt711_sdca_priv *rt711)
 452{
 453	mutex_lock(&rt711->calibrate_mutex);
 454
 455	if (rt711->hs_jack) {
 456		/* Enable HID1 event & set button RTC mode */
 457		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 458			RT711_PUSH_BTN_INT_CTL6, 0x80f0, 0x8000);
 459		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 460			RT711_PUSH_BTN_INT_CTL2, 0x11dd, 0x11dd);
 461		rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
 462			RT711_PUSH_BTN_INT_CTL7, 0xffff);
 463		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 464			RT711_PUSH_BTN_INT_CTL9, 0xf000, 0x0000);
 465
 466		/* GE_mode_change_event_en & Hid1_push_button_event_en */
 467		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 468			RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0c00);
 469
 470		switch (rt711->jd_src) {
 471		case RT711_JD1:
 472			/* default settings was already for JD1 */
 473			break;
 474		case RT711_JD2:
 475			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 476				RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL,
 477				RT711_JD2_DIGITAL_MODE_SEL);
 478			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 479				RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2,
 480				RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2);
 481			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 482				RT711_CC_DET1,
 483				RT711_HP_JD_FINAL_RESULT_CTL_JD12,
 484				RT711_HP_JD_FINAL_RESULT_CTL_JD12);
 485			break;
 486		case RT711_JD2_100K:
 487			rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
 488				RT711_COMBO_JACK_AUTO_CTL3, 0xa47e);
 489			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 490				RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL,
 491				RT711_JD2_DIGITAL_MODE_SEL);
 492			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 493				RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP |
 494				RT711_JD2_2PORT_100K_DECODE_MASK | RT711_HP_JD_SEL_JD2,
 495				RT711_JD2_2PORT_100K_DECODE_HP | RT711_HP_JD_SEL_JD2);
 496			rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
 497				RT711_CC_DET1,
 498				RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI,
 499				RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI_OFF);
 500			break;
 501		default:
 502			dev_warn(rt711->component->dev, "Wrong JD source\n");
 503			break;
 504		}
 505
 506		/* set SCP_SDCA_IntMask1[0]=1 */
 507		sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
 508		/* set SCP_SDCA_IntMask2[0]=1 */
 509		sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
 510		dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__);
 511	} else {
 512		/* disable HID 1/2 event */
 513		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 514			RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0000);
 515
 516		dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__);
 517	}
 518
 519	mutex_unlock(&rt711->calibrate_mutex);
 520}
 521
 522static int rt711_sdca_set_jack_detect(struct snd_soc_component *component,
 523	struct snd_soc_jack *hs_jack, void *data)
 524{
 525	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 526	int ret;
 527
 528	rt711->hs_jack = hs_jack;
 529
 530	/* we can only resume if the device was initialized at least once */
 531	if (!rt711->first_hw_init)
 532		return 0;
 533
 534	ret = pm_runtime_resume_and_get(component->dev);
 535	if (ret < 0) {
 536		if (ret != -EACCES) {
 537			dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
 538			return ret;
 539		}
 540
 541		/* pm_runtime not enabled yet */
 542		dev_dbg(component->dev,	"%s: skipping jack init for now\n", __func__);
 543		return 0;
 544	}
 545
 546	rt711_sdca_jack_init(rt711);
 547
 548	pm_runtime_put_autosuspend(component->dev);
 549
 550	return 0;
 551}
 552
 553/* For SDCA control DAC/ADC Gain */
 554static int rt711_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
 555		struct snd_ctl_elem_value *ucontrol)
 556{
 557	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 558	struct soc_mixer_control *mc =
 559		(struct soc_mixer_control *)kcontrol->private_value;
 560	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 561	unsigned int read_l, read_r, gain_l_val, gain_r_val;
 562	unsigned int i, adc_vol_flag = 0, changed = 0;
 563	unsigned int lvalue, rvalue;
 564
 565	if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
 566		strstr(ucontrol->id.name, "FU0F Capture Volume"))
 567		adc_vol_flag = 1;
 568
 569	regmap_read(rt711->mbq_regmap, mc->reg, &lvalue);
 570	regmap_read(rt711->mbq_regmap, mc->rreg, &rvalue);
 571
 572	/* control value to 2's complement value */
 573	/* L Channel */
 574	gain_l_val = ucontrol->value.integer.value[0];
 575	if (gain_l_val > mc->max)
 576		gain_l_val = mc->max;
 577	read_l = gain_l_val;
 578
 579	if (mc->shift == 8) /* boost gain */
 580		gain_l_val = (gain_l_val * 10) << mc->shift;
 581	else { /* ADC/DAC gain */
 582		if (adc_vol_flag && gain_l_val > mc->shift)
 583			gain_l_val = (gain_l_val - mc->shift) * 75;
 584		else
 585			gain_l_val = (mc->shift - gain_l_val) * 75;
 586		gain_l_val <<= 8;
 587		gain_l_val /= 100;
 588		if (!(adc_vol_flag && read_l > mc->shift)) {
 589			gain_l_val = ~gain_l_val;
 590			gain_l_val += 1;
 591		}
 592		gain_l_val &= 0xffff;
 593	}
 594
 595	/* R Channel */
 596	gain_r_val = ucontrol->value.integer.value[1];
 597	if (gain_r_val > mc->max)
 598		gain_r_val = mc->max;
 599	read_r = gain_r_val;
 600
 601	if (mc->shift == 8) /* boost gain */
 602		gain_r_val = (gain_r_val * 10) << mc->shift;
 603	else { /* ADC/DAC gain */
 604		if (adc_vol_flag && gain_r_val > mc->shift)
 605			gain_r_val = (gain_r_val - mc->shift) * 75;
 606		else
 607			gain_r_val = (mc->shift - gain_r_val) * 75;
 608		gain_r_val <<= 8;
 609		gain_r_val /= 100;
 610		if (!(adc_vol_flag && read_r > mc->shift)) {
 611			gain_r_val = ~gain_r_val;
 612			gain_r_val += 1;
 613		}
 614		gain_r_val &= 0xffff;
 615	}
 616
 617	if (lvalue != gain_l_val || rvalue != gain_r_val)
 618		changed = 1;
 619	else
 620		return 0;
 621
 622	for (i = 0; i < 3; i++) { /* retry 3 times at most */
 623		/* Lch*/
 624		regmap_write(rt711->mbq_regmap, mc->reg, gain_l_val);
 625
 626		/* Rch */
 627		regmap_write(rt711->mbq_regmap, mc->rreg, gain_r_val);
 628
 629		regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
 630		regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
 631		if (read_r == gain_r_val && read_l == gain_l_val)
 632			break;
 633	}
 634
 635	return i == 3 ? -EIO : changed;
 636}
 637
 638static int rt711_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
 639		struct snd_ctl_elem_value *ucontrol)
 640{
 641	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 642	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 643	struct soc_mixer_control *mc =
 644		(struct soc_mixer_control *)kcontrol->private_value;
 645	unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
 646	unsigned int adc_vol_flag = 0, neg_flag = 0;
 647
 648	if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
 649		strstr(ucontrol->id.name, "FU0F Capture Volume"))
 650		adc_vol_flag = 1;
 651
 652	regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
 653	regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
 654
 655	/* 2's complement value to control value */
 656	if (mc->shift == 8) /* boost gain */
 657		ctl_l = (read_l >> mc->shift) / 10;
 658	else { /* ADC/DAC gain */
 659		ctl_l = read_l;
 660		if (read_l & BIT(15)) {
 661			ctl_l = 0xffff & ~(read_l - 1);
 662			neg_flag = 1;
 663		}
 664		ctl_l *= 100;
 665		ctl_l >>= 8;
 666		if (adc_vol_flag) {
 667			if (neg_flag)
 668				ctl_l = mc->shift - (ctl_l / 75);
 669			else
 670				ctl_l = mc->shift + (ctl_l / 75);
 671		} else
 672			ctl_l = mc->max - (ctl_l / 75);
 673	}
 674
 675	neg_flag = 0;
 676	if (read_l != read_r) {
 677		if (mc->shift == 8) /* boost gain */
 678			ctl_r = (read_r >> mc->shift) / 10;
 679		else { /* ADC/DAC gain */
 680			ctl_r = read_r;
 681			if (read_r & BIT(15)) {
 682				ctl_r = 0xffff & ~(read_r - 1);
 683				neg_flag = 1;
 684			}
 685			ctl_r *= 100;
 686			ctl_r >>= 8;
 687			if (adc_vol_flag) {
 688				if (neg_flag)
 689					ctl_r = mc->shift - (ctl_r / 75);
 690				else
 691					ctl_r = mc->shift + (ctl_r / 75);
 692			} else
 693				ctl_r = mc->max - (ctl_r / 75);
 694		}
 695	} else
 696		ctl_r = ctl_l;
 697
 698	ucontrol->value.integer.value[0] = ctl_l;
 699	ucontrol->value.integer.value[1] = ctl_r;
 700
 701	return 0;
 702}
 703
 704static int rt711_sdca_set_fu0f_capture_ctl(struct rt711_sdca_priv *rt711)
 705{
 706	int err;
 707	unsigned int ch_l, ch_r;
 708
 709	ch_l = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_l_mute) ? 0x01 : 0x00;
 710	ch_r = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_r_mute) ? 0x01 : 0x00;
 711
 712	err = regmap_write(rt711->regmap,
 713			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
 714			RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
 715	if (err < 0)
 716		return err;
 717
 718	err = regmap_write(rt711->regmap,
 719			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
 720			RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
 721	if (err < 0)
 722		return err;
 723
 724	return 0;
 725}
 726
 727static int rt711_sdca_set_fu1e_capture_ctl(struct rt711_sdca_priv *rt711)
 728{
 729	int err;
 730	unsigned int ch_l, ch_r;
 731
 732	ch_l = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_l_mute) ? 0x01 : 0x00;
 733	ch_r = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_r_mute) ? 0x01 : 0x00;
 734
 735	err = regmap_write(rt711->regmap,
 736			SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
 737			RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
 738	if (err < 0)
 739		return err;
 740
 741	err = regmap_write(rt711->regmap,
 742			SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
 743			RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
 744	if (err < 0)
 745		return err;
 746
 747	return 0;
 748}
 749
 750static int rt711_sdca_fu1e_capture_get(struct snd_kcontrol *kcontrol,
 751			struct snd_ctl_elem_value *ucontrol)
 752{
 753	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 754	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 755
 756	ucontrol->value.integer.value[0] = !rt711->fu1e_mixer_l_mute;
 757	ucontrol->value.integer.value[1] = !rt711->fu1e_mixer_r_mute;
 758	return 0;
 759}
 760
 761static int rt711_sdca_fu1e_capture_put(struct snd_kcontrol *kcontrol,
 762			struct snd_ctl_elem_value *ucontrol)
 763{
 764	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 765	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 766	int err, changed = 0;
 767
 768	if (rt711->fu1e_mixer_l_mute != !ucontrol->value.integer.value[0] ||
 769		rt711->fu1e_mixer_r_mute != !ucontrol->value.integer.value[1])
 770		changed = 1;
 771
 772	rt711->fu1e_mixer_l_mute = !ucontrol->value.integer.value[0];
 773	rt711->fu1e_mixer_r_mute = !ucontrol->value.integer.value[1];
 774	err = rt711_sdca_set_fu1e_capture_ctl(rt711);
 775	if (err < 0)
 776		return err;
 777
 778	return changed;
 779}
 780
 781static int rt711_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
 782			struct snd_ctl_elem_value *ucontrol)
 783{
 784	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 785	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 786
 787	ucontrol->value.integer.value[0] = !rt711->fu0f_mixer_l_mute;
 788	ucontrol->value.integer.value[1] = !rt711->fu0f_mixer_r_mute;
 789	return 0;
 790}
 791
 792static int rt711_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
 793			struct snd_ctl_elem_value *ucontrol)
 794{
 795	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 796	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 797	int err, changed = 0;
 798
 799	if (rt711->fu0f_mixer_l_mute != !ucontrol->value.integer.value[0] ||
 800		rt711->fu0f_mixer_r_mute != !ucontrol->value.integer.value[1])
 801		changed = 1;
 802
 803	rt711->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
 804	rt711->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
 805	err = rt711_sdca_set_fu0f_capture_ctl(rt711);
 806	if (err < 0)
 807		return err;
 808
 809	return changed;
 810}
 811
 812static int rt711_sdca_ge_select_get(struct snd_kcontrol *kcontrol,
 813			      struct snd_ctl_elem_value *ucontrol)
 814{
 815	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 816	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 817	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 818	unsigned int val, item;
 819
 820	val = (rt711->ge_mode_override >> e->shift_l) & e->mask;
 821	item = snd_soc_enum_val_to_item(e, val);
 822	ucontrol->value.enumerated.item[0] = item;
 823	return 0;
 824}
 825
 826static int rt711_sdca_ge_select_put(struct snd_kcontrol *kcontrol,
 827			      struct snd_ctl_elem_value *ucontrol)
 828{
 829	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 830	unsigned int *item = ucontrol->value.enumerated.item;
 831	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 832	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 833	unsigned int val, change = 0;
 834
 835	if (item[0] >= e->items)
 836		return -EINVAL;
 837
 838	val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
 839	if (rt711->ge_mode_override != val) {
 840		rt711->ge_mode_override = val;
 841		change = 1;
 842	}
 843
 844	return change;
 845}
 846
 847static const char * const rt711_sdca_ge_select[] = {
 848	"Auto",
 849	"Headphone",
 850	"Headset",
 851};
 852
 853static int rt711_sdca_ge_select_values[] = {
 854	0,
 855	3,
 856	5,
 857};
 858
 859static SOC_VALUE_ENUM_SINGLE_DECL(rt711_sdca_ge_mode_enum, SND_SOC_NOPM,
 860	0, 0x7, rt711_sdca_ge_select, rt711_sdca_ge_select_values);
 861
 862static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
 863static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
 864static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
 865
 866static const struct snd_kcontrol_new rt711_sdca_snd_controls[] = {
 867	SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
 868		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_L),
 869		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_R),
 870		0x57, 0x57, 0,
 871		rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, out_vol_tlv),
 872	SOC_DOUBLE_EXT("FU1E Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
 873		rt711_sdca_fu1e_capture_get, rt711_sdca_fu1e_capture_put),
 874	SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
 875		rt711_sdca_fu0f_capture_get, rt711_sdca_fu0f_capture_put),
 876	SOC_DOUBLE_R_EXT_TLV("FU1E Capture Volume",
 877		SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_L),
 878		SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_R),
 879		0x17, 0x3f, 0,
 880		rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
 881	SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
 882		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_L),
 883		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_R),
 884		0x17, 0x3f, 0,
 885		rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
 886	SOC_DOUBLE_R_EXT_TLV("FU44 Gain Volume",
 887		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
 888		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
 889		8, 3, 0,
 890		rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
 891	SOC_DOUBLE_R_EXT_TLV("FU15 Gain Volume",
 892		SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
 893		SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
 894		8, 3, 0,
 895		rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
 896	SOC_ENUM_EXT("GE49 Selected Mode", rt711_sdca_ge_mode_enum,
 897		rt711_sdca_ge_select_get, rt711_sdca_ge_select_put),
 898};
 899
 900static int rt711_sdca_mux_get(struct snd_kcontrol *kcontrol,
 901			struct snd_ctl_elem_value *ucontrol)
 902{
 903	struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
 904	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 905	unsigned int val = 0, mask_sft;
 906
 907	if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 908		mask_sft = 10;
 909	else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 910		mask_sft = 13;
 911	else
 912		return -EINVAL;
 913
 914	rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
 915		RT711_HDA_LEGACY_MUX_CTL1, &val);
 916
 917	ucontrol->value.enumerated.item[0] = (val >> mask_sft) & 0x7;
 918
 919	return 0;
 920}
 921
 922static int rt711_sdca_mux_put(struct snd_kcontrol *kcontrol,
 923			struct snd_ctl_elem_value *ucontrol)
 924{
 925	struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
 926	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
 927	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 928	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 929	unsigned int *item = ucontrol->value.enumerated.item;
 930	unsigned int val, val2 = 0, change, mask_sft;
 931
 932	if (item[0] >= e->items)
 933		return -EINVAL;
 934
 935	if (strstr(ucontrol->id.name, "ADC 22 Mux"))
 936		mask_sft = 10;
 937	else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
 938		mask_sft = 13;
 939	else
 940		return -EINVAL;
 941
 942	val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
 943
 944	rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
 945		RT711_HDA_LEGACY_MUX_CTL1, &val2);
 946	val2 = (val2 >> mask_sft) & 0x7;
 947
 948	if (val == val2)
 949		change = 0;
 950	else
 951		change = 1;
 952
 953	if (change)
 954		rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
 955			RT711_HDA_LEGACY_MUX_CTL1, 0x7 << mask_sft,
 956			val << mask_sft);
 957
 958	snd_soc_dapm_mux_update_power(dapm, kcontrol,
 959		item[0], e, NULL);
 960
 961	return change;
 962}
 963
 964static const char * const adc_mux_text[] = {
 965	"MIC2",
 966	"LINE1",
 967	"LINE2",
 968	"DMIC",
 969};
 970
 971static SOC_ENUM_SINGLE_DECL(
 972	rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
 973
 974static SOC_ENUM_SINGLE_DECL(
 975	rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
 976
 977static const struct snd_kcontrol_new rt711_sdca_adc22_mux =
 978	SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum,
 979			rt711_sdca_mux_get, rt711_sdca_mux_put);
 980
 981static const struct snd_kcontrol_new rt711_sdca_adc23_mux =
 982	SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum,
 983			rt711_sdca_mux_get, rt711_sdca_mux_put);
 984
 985static int rt711_sdca_fu05_event(struct snd_soc_dapm_widget *w,
 986	struct snd_kcontrol *kcontrol, int event)
 987{
 988	struct snd_soc_component *component =
 989		snd_soc_dapm_to_component(w->dapm);
 990	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
 991	unsigned char unmute = 0x0, mute = 0x1;
 992
 993	switch (event) {
 994	case SND_SOC_DAPM_POST_PMU:
 995		regmap_write(rt711->regmap,
 996			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
 997				RT711_SDCA_CTL_FU_MUTE, CH_L),
 998				unmute);
 999		regmap_write(rt711->regmap,
1000			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1001				RT711_SDCA_CTL_FU_MUTE, CH_R),
1002				unmute);
1003		break;
1004	case SND_SOC_DAPM_PRE_PMD:
1005		regmap_write(rt711->regmap,
1006			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1007				RT711_SDCA_CTL_FU_MUTE, CH_L),
1008				mute);
1009		regmap_write(rt711->regmap,
1010			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1011				RT711_SDCA_CTL_FU_MUTE, CH_R),
1012				mute);
1013		break;
1014	}
1015	return 0;
1016}
1017
1018static int rt711_sdca_fu0f_event(struct snd_soc_dapm_widget *w,
1019	struct snd_kcontrol *kcontrol, int event)
1020{
1021	struct snd_soc_component *component =
1022		snd_soc_dapm_to_component(w->dapm);
1023	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1024
1025	switch (event) {
1026	case SND_SOC_DAPM_POST_PMU:
1027		rt711->fu0f_dapm_mute = false;
1028		rt711_sdca_set_fu0f_capture_ctl(rt711);
1029		break;
1030	case SND_SOC_DAPM_PRE_PMD:
1031		rt711->fu0f_dapm_mute = true;
1032		rt711_sdca_set_fu0f_capture_ctl(rt711);
1033		break;
1034	}
1035	return 0;
1036}
1037
1038static int rt711_sdca_fu1e_event(struct snd_soc_dapm_widget *w,
1039	struct snd_kcontrol *kcontrol, int event)
1040{
1041	struct snd_soc_component *component =
1042		snd_soc_dapm_to_component(w->dapm);
1043	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1044
1045	switch (event) {
1046	case SND_SOC_DAPM_POST_PMU:
1047		rt711->fu1e_dapm_mute = false;
1048		rt711_sdca_set_fu1e_capture_ctl(rt711);
1049		break;
1050	case SND_SOC_DAPM_PRE_PMD:
1051		rt711->fu1e_dapm_mute = true;
1052		rt711_sdca_set_fu1e_capture_ctl(rt711);
1053		break;
1054	}
1055	return 0;
1056}
1057
1058static int rt711_sdca_pde28_event(struct snd_soc_dapm_widget *w,
1059	struct snd_kcontrol *kcontrol, int event)
1060{
1061	struct snd_soc_component *component =
1062		snd_soc_dapm_to_component(w->dapm);
1063	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1064	unsigned char ps0 = 0x0, ps3 = 0x3;
1065
1066	switch (event) {
1067	case SND_SOC_DAPM_POST_PMU:
1068		regmap_write(rt711->regmap,
1069			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
1070				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1071				ps0);
1072		break;
1073	case SND_SOC_DAPM_PRE_PMD:
1074		regmap_write(rt711->regmap,
1075			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
1076				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1077				ps3);
1078		break;
1079	}
1080	return 0;
1081}
1082
1083static int rt711_sdca_pde29_event(struct snd_soc_dapm_widget *w,
1084	struct snd_kcontrol *kcontrol, int event)
1085{
1086	struct snd_soc_component *component =
1087		snd_soc_dapm_to_component(w->dapm);
1088	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1089	unsigned char ps0 = 0x0, ps3 = 0x3;
1090
1091	switch (event) {
1092	case SND_SOC_DAPM_POST_PMU:
1093		regmap_write(rt711->regmap,
1094			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1095				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1096				ps0);
1097		break;
1098	case SND_SOC_DAPM_PRE_PMD:
1099		regmap_write(rt711->regmap,
1100			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1101				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1102				ps3);
1103		break;
1104	}
1105	return 0;
1106}
1107
1108static int rt711_sdca_pde2a_event(struct snd_soc_dapm_widget *w,
1109	struct snd_kcontrol *kcontrol, int event)
1110{
1111	struct snd_soc_component *component =
1112		snd_soc_dapm_to_component(w->dapm);
1113	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1114	unsigned char ps0 = 0x0, ps3 = 0x3;
1115
1116	switch (event) {
1117	case SND_SOC_DAPM_POST_PMU:
1118		regmap_write(rt711->regmap,
1119			SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1120				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1121				ps0);
1122		break;
1123	case SND_SOC_DAPM_PRE_PMD:
1124		regmap_write(rt711->regmap,
1125			SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1126				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1127				ps3);
1128		break;
1129	}
1130	return 0;
1131}
1132
1133static int rt711_sdca_line1_power_event(struct snd_soc_dapm_widget *w,
1134			struct snd_kcontrol *kcontrol, int event)
1135{
1136	struct snd_soc_component *component =
1137		snd_soc_dapm_to_component(w->dapm);
1138	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1139	static unsigned int sel_mode = 0xffff;
1140
1141	switch (event) {
1142	case SND_SOC_DAPM_POST_PMU:
1143		regmap_read(rt711->regmap,
1144			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1145				RT711_SDCA_CTL_SELECTED_MODE, 0),
1146				&sel_mode);
1147		regmap_write(rt711->regmap,
1148			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1149				RT711_SDCA_CTL_VENDOR_DEF, 0),
1150				0x1);
1151		regmap_write(rt711->regmap,
1152			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1153				RT711_SDCA_CTL_SELECTED_MODE, 0),
1154				0x7);
1155		break;
1156	case SND_SOC_DAPM_PRE_PMD:
1157		regmap_write(rt711->regmap,
1158			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1159				RT711_SDCA_CTL_VENDOR_DEF, 0),
1160				0x0);
1161		if (sel_mode != 0xffff)
1162			regmap_write(rt711->regmap,
1163				SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1164				RT711_SDCA_CTL_SELECTED_MODE, 0),
1165				sel_mode);
1166		break;
1167	}
1168
1169	return 0;
1170}
1171
1172static int rt711_sdca_line2_power_event(struct snd_soc_dapm_widget *w,
1173			struct snd_kcontrol *kcontrol, int event)
1174{
1175	struct snd_soc_component *component =
1176		snd_soc_dapm_to_component(w->dapm);
1177	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1178	unsigned char ps0 = 0x0, ps3 = 0x3;
1179
1180	switch (event) {
1181	case SND_SOC_DAPM_POST_PMU:
1182		regmap_write(rt711->regmap,
1183			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1184				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1185				ps0);
1186		regmap_write(rt711->regmap,
1187			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1188				RT711_SDCA_CTL_VENDOR_DEF, 0),
1189				0x1);
1190		break;
1191	case SND_SOC_DAPM_PRE_PMD:
1192		regmap_write(rt711->regmap,
1193			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1194				RT711_SDCA_CTL_VENDOR_DEF, 0),
1195				0x0);
1196		regmap_write(rt711->regmap,
1197			SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1198				RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1199				ps3);
1200		break;
1201	}
1202
1203	return 0;
1204}
1205
1206static const struct snd_soc_dapm_widget rt711_sdca_dapm_widgets[] = {
1207	SND_SOC_DAPM_OUTPUT("HP"),
1208	SND_SOC_DAPM_INPUT("MIC2"),
1209	SND_SOC_DAPM_INPUT("DMIC1"),
1210	SND_SOC_DAPM_INPUT("DMIC2"),
1211	SND_SOC_DAPM_INPUT("LINE1"),
1212	SND_SOC_DAPM_INPUT("LINE2"),
1213
1214	SND_SOC_DAPM_PGA_E("LINE1 Power", SND_SOC_NOPM,
1215		0, 0, NULL, 0, rt711_sdca_line1_power_event,
1216		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1217	SND_SOC_DAPM_PGA_E("LINE2 Power", SND_SOC_NOPM,
1218		0, 0, NULL, 0, rt711_sdca_line2_power_event,
1219		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1220
1221	SND_SOC_DAPM_SUPPLY("PDE 28", SND_SOC_NOPM, 0, 0,
1222		rt711_sdca_pde28_event,
1223		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1224	SND_SOC_DAPM_SUPPLY("PDE 29", SND_SOC_NOPM, 0, 0,
1225		rt711_sdca_pde29_event,
1226		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1227	SND_SOC_DAPM_SUPPLY("PDE 2A", SND_SOC_NOPM, 0, 0,
1228		rt711_sdca_pde2a_event,
1229		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1230
1231	SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0,
1232		rt711_sdca_fu05_event,
1233		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1234	SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0,
1235		rt711_sdca_fu0f_event,
1236		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1237	SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0,
1238		rt711_sdca_fu1e_event,
1239		SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1240	SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
1241		&rt711_sdca_adc22_mux),
1242	SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
1243		&rt711_sdca_adc23_mux),
1244
1245	SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
1246	SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
1247	SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
1248};
1249
1250static const struct snd_soc_dapm_route rt711_sdca_audio_map[] = {
1251	{"FU 05", NULL, "DP3RX"},
1252	{"DP2TX", NULL, "FU 0F"},
1253	{"DP4TX", NULL, "FU 1E"},
1254
1255	{"LINE1 Power", NULL, "LINE1"},
1256	{"LINE2 Power", NULL, "LINE2"},
1257	{"HP", NULL, "PDE 28"},
1258	{"FU 0F", NULL, "PDE 29"},
1259	{"FU 1E", NULL, "PDE 2A"},
1260
1261	{"FU 0F", NULL, "ADC 22 Mux"},
1262	{"FU 1E", NULL, "ADC 23 Mux"},
1263	{"ADC 22 Mux", "DMIC", "DMIC1"},
1264	{"ADC 22 Mux", "LINE1", "LINE1 Power"},
1265	{"ADC 22 Mux", "LINE2", "LINE2 Power"},
1266	{"ADC 22 Mux", "MIC2", "MIC2"},
1267	{"ADC 23 Mux", "DMIC", "DMIC2"},
1268	{"ADC 23 Mux", "LINE1", "LINE1 Power"},
1269	{"ADC 23 Mux", "LINE2", "LINE2 Power"},
1270	{"ADC 23 Mux", "MIC2", "MIC2"},
1271
1272	{"HP", NULL, "FU 05"},
1273};
1274
1275static int rt711_sdca_parse_dt(struct rt711_sdca_priv *rt711, struct device *dev)
1276{
1277	device_property_read_u32(dev, "realtek,jd-src", &rt711->jd_src);
1278
1279	return 0;
1280}
1281
1282static int rt711_sdca_probe(struct snd_soc_component *component)
1283{
1284	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1285	int ret;
1286
1287	rt711_sdca_parse_dt(rt711, &rt711->slave->dev);
1288	rt711->component = component;
1289
1290	if (!rt711->first_hw_init)
1291		return 0;
1292
1293	ret = pm_runtime_resume(component->dev);
1294	if (ret < 0 && ret != -EACCES)
1295		return ret;
1296
1297	return 0;
1298}
1299
1300static const struct snd_soc_component_driver soc_sdca_dev_rt711 = {
1301	.probe = rt711_sdca_probe,
1302	.controls = rt711_sdca_snd_controls,
1303	.num_controls = ARRAY_SIZE(rt711_sdca_snd_controls),
1304	.dapm_widgets = rt711_sdca_dapm_widgets,
1305	.num_dapm_widgets = ARRAY_SIZE(rt711_sdca_dapm_widgets),
1306	.dapm_routes = rt711_sdca_audio_map,
1307	.num_dapm_routes = ARRAY_SIZE(rt711_sdca_audio_map),
1308	.set_jack = rt711_sdca_set_jack_detect,
1309	.endianness = 1,
1310};
1311
1312static int rt711_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
1313				int direction)
1314{
1315	snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
1316
1317	return 0;
1318}
1319
1320static void rt711_sdca_shutdown(struct snd_pcm_substream *substream,
1321				struct snd_soc_dai *dai)
1322{
1323	snd_soc_dai_set_dma_data(dai, substream, NULL);
1324}
1325
1326static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1327				struct snd_pcm_hw_params *params,
1328				struct snd_soc_dai *dai)
1329{
1330	struct snd_soc_component *component = dai->component;
1331	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1332	struct sdw_stream_config stream_config = {0};
1333	struct sdw_port_config port_config = {0};
1334	struct sdw_stream_runtime *sdw_stream;
1335	int retval;
1336	unsigned int sampling_rate;
1337
1338	dev_dbg(dai->dev, "%s %s", __func__, dai->name);
1339	sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
1340
1341	if (!sdw_stream)
1342		return -EINVAL;
1343
1344	if (!rt711->slave)
1345		return -EINVAL;
1346
1347	/* SoundWire specific configuration */
1348	snd_sdw_params_to_config(substream, params, &stream_config, &port_config);
1349
1350	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1351		port_config.num = 3;
1352	} else {
1353		if (dai->id == RT711_AIF1)
1354			port_config.num = 2;
1355		else if (dai->id == RT711_AIF2)
1356			port_config.num = 4;
1357		else
1358			return -EINVAL;
1359	}
1360
1361	retval = sdw_stream_add_slave(rt711->slave, &stream_config,
1362					&port_config, 1, sdw_stream);
1363	if (retval) {
1364		dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
1365		return retval;
1366	}
1367
1368	if (params_channels(params) > 16) {
1369		dev_err(component->dev, "%s: Unsupported channels %d\n",
1370			__func__, params_channels(params));
1371		return -EINVAL;
1372	}
1373
1374	/* sampling rate configuration */
1375	switch (params_rate(params)) {
1376	case 44100:
1377		sampling_rate = RT711_SDCA_RATE_44100HZ;
1378		break;
1379	case 48000:
1380		sampling_rate = RT711_SDCA_RATE_48000HZ;
1381		break;
1382	case 96000:
1383		sampling_rate = RT711_SDCA_RATE_96000HZ;
1384		break;
1385	case 192000:
1386		sampling_rate = RT711_SDCA_RATE_192000HZ;
1387		break;
1388	default:
1389		dev_err(component->dev, "%s: Rate %d is not supported\n",
1390			__func__, params_rate(params));
1391		return -EINVAL;
1392	}
1393
1394	/* set sampling frequency */
1395	regmap_write(rt711->regmap,
1396		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS01, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1397		sampling_rate);
1398	regmap_write(rt711->regmap,
1399		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS11, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1400		sampling_rate);
1401	regmap_write(rt711->regmap,
1402		SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_CS1F, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1403		sampling_rate);
1404
1405	return 0;
1406}
1407
1408static int rt711_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1409				struct snd_soc_dai *dai)
1410{
1411	struct snd_soc_component *component = dai->component;
1412	struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1413	struct sdw_stream_runtime *sdw_stream =
1414		snd_soc_dai_get_dma_data(dai, substream);
1415
1416	if (!rt711->slave)
1417		return -EINVAL;
1418
1419	sdw_stream_remove_slave(rt711->slave, sdw_stream);
1420	return 0;
1421}
1422
1423#define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1424			SNDRV_PCM_RATE_192000)
1425#define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1426			SNDRV_PCM_FMTBIT_S24_LE)
1427
1428static const struct snd_soc_dai_ops rt711_sdca_ops = {
1429	.hw_params	= rt711_sdca_pcm_hw_params,
1430	.hw_free	= rt711_sdca_pcm_hw_free,
1431	.set_stream	= rt711_sdca_set_sdw_stream,
1432	.shutdown	= rt711_sdca_shutdown,
1433};
1434
1435static struct snd_soc_dai_driver rt711_sdca_dai[] = {
1436	{
1437		.name = "rt711-sdca-aif1",
1438		.id = RT711_AIF1,
1439		.playback = {
1440			.stream_name = "DP3 Playback",
1441			.channels_min = 1,
1442			.channels_max = 2,
1443			.rates = RT711_STEREO_RATES,
1444			.formats = RT711_FORMATS,
1445		},
1446		.capture = {
1447			.stream_name = "DP2 Capture",
1448			.channels_min = 1,
1449			.channels_max = 2,
1450			.rates = RT711_STEREO_RATES,
1451			.formats = RT711_FORMATS,
1452		},
1453		.ops = &rt711_sdca_ops,
1454	},
1455	{
1456		.name = "rt711-sdca-aif2",
1457		.id = RT711_AIF2,
1458		.capture = {
1459			.stream_name = "DP4 Capture",
1460			.channels_min = 1,
1461			.channels_max = 2,
1462			.rates = RT711_STEREO_RATES,
1463			.formats = RT711_FORMATS,
1464		},
1465		.ops = &rt711_sdca_ops,
1466	}
1467};
1468
1469int rt711_sdca_init(struct device *dev, struct regmap *regmap,
1470			struct regmap *mbq_regmap, struct sdw_slave *slave)
1471{
1472	struct rt711_sdca_priv *rt711;
1473	int ret;
1474
1475	rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL);
1476	if (!rt711)
1477		return -ENOMEM;
1478
1479	dev_set_drvdata(dev, rt711);
1480	rt711->slave = slave;
1481	rt711->regmap = regmap;
1482	rt711->mbq_regmap = mbq_regmap;
1483
1484	regcache_cache_only(rt711->regmap, true);
1485	regcache_cache_only(rt711->mbq_regmap, true);
1486
1487	mutex_init(&rt711->calibrate_mutex);
1488	mutex_init(&rt711->disable_irq_lock);
1489
1490	INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_sdca_jack_detect_handler);
1491	INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_sdca_btn_check_handler);
1492
1493	/*
1494	 * Mark hw_init to false
1495	 * HW init will be performed when device reports present
1496	 */
1497	rt711->hw_init = false;
1498	rt711->first_hw_init = false;
1499	rt711->fu0f_dapm_mute = true;
1500	rt711->fu1e_dapm_mute = true;
1501	rt711->fu0f_mixer_l_mute = rt711->fu0f_mixer_r_mute = true;
1502	rt711->fu1e_mixer_l_mute = rt711->fu1e_mixer_r_mute = true;
1503
1504	/* JD source uses JD2 in default */
1505	rt711->jd_src = RT711_JD2;
1506
1507	ret =  devm_snd_soc_register_component(dev,
1508			&soc_sdca_dev_rt711,
1509			rt711_sdca_dai,
1510			ARRAY_SIZE(rt711_sdca_dai));
1511
1512	if (ret < 0)
1513		return ret;
1514
1515	/* set autosuspend parameters */
1516	pm_runtime_set_autosuspend_delay(dev, 3000);
1517	pm_runtime_use_autosuspend(dev);
1518
1519	/* make sure the device does not suspend immediately */
1520	pm_runtime_mark_last_busy(dev);
1521
1522	pm_runtime_enable(dev);
1523
1524	/* important note: the device is NOT tagged as 'active' and will remain
1525	 * 'suspended' until the hardware is enumerated/initialized. This is required
1526	 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently
1527	 * fail with -EACCESS because of race conditions between card creation and enumeration
1528	 */
1529
1530	dev_dbg(dev, "%s\n", __func__);
1531
1532	return 0;
1533}
1534
1535static void rt711_sdca_vd0_io_init(struct rt711_sdca_priv *rt711)
1536{
1537	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1538		RT711_GPIO_TEST_MODE_CTL2, 0x0e00);
1539	rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1540		RT711_HDA_LEGACY_GPIO_CTL, 0x0008);
1541
1542	regmap_write(rt711->regmap, 0x2f5a, 0x01);
1543
1544	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1545		RT711_ADC27_VOL_SET, 0x8728);
1546
1547	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1548		RT711_COMBO_JACK_AUTO_CTL3, 0xa472);
1549
1550	regmap_write(rt711->regmap, 0x2f50, 0x02);
1551
1552	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
1553		RT711_MISC_POWER_CTL4, 0x6000, 0x6000);
1554
1555	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1556		RT711_COMBO_JACK_AUTO_CTL3, 0x000c, 0x000c);
1557
1558	rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1559		RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1560
1561	rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1562		RT711_VAD_SRAM_CTL1, 0x0050);
1563}
1564
1565static void rt711_sdca_vd1_io_init(struct rt711_sdca_priv *rt711)
1566{
1567	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1568		RT711_HDA_LEGACY_UNSOLICITED_CTL, 0x0300, 0x0000);
1569
1570	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1571		RT711_COMBO_JACK_AUTO_CTL3, 0xa43e);
1572
1573	regmap_write(rt711->regmap, 0x2f5a, 0x05);
1574
1575	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1576		RT711_JD_CTRL6, 0x0500);
1577
1578	rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1579		RT711_DMIC_CTL1, 0x6173);
1580
1581	rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1582		RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1583
1584	rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1585		RT711_VAD_SRAM_CTL1, 0x0050);
1586}
1587
1588int rt711_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1589{
1590	struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
1591	int ret = 0;
1592	unsigned int val;
1593
1594	rt711->disable_irq = false;
1595
1596	if (rt711->hw_init)
1597		return 0;
1598
1599	regcache_cache_only(rt711->regmap, false);
1600	regcache_cache_only(rt711->mbq_regmap, false);
1601
1602	if (rt711->first_hw_init) {
1603		regcache_cache_bypass(rt711->regmap, true);
1604		regcache_cache_bypass(rt711->mbq_regmap, true);
1605	} else {
1606		/*
1607		 * PM runtime status is marked as 'active' only when a Slave reports as Attached
1608		 */
1609
1610		/* update count of parent 'active' children */
1611		pm_runtime_set_active(&slave->dev);
1612	}
1613
1614	pm_runtime_get_noresume(&slave->dev);
1615
1616	rt711_sdca_reset(rt711);
1617
1618	rt711_sdca_index_read(rt711, RT711_VENDOR_REG, RT711_JD_PRODUCT_NUM, &val);
1619	rt711->hw_ver = val & 0xf;
1620
1621	if (rt711->hw_ver == RT711_VER_VD0)
1622		rt711_sdca_vd0_io_init(rt711);
1623	else
1624		rt711_sdca_vd1_io_init(rt711);
1625
1626	/* DP4 mux select from 08_filter_Out_pri */
1627	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1628		RT711_FILTER_SRC_SEL, 0x1800, 0x0800);
1629
1630	/* ge_exclusive_inbox_en disable */
1631	rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1632		RT711_PUSH_BTN_INT_CTL0, 0x20, 0x00);
1633
1634	/* calibration */
1635	ret = rt711_sdca_calibration(rt711);
1636	if (ret < 0)
1637		dev_err(dev, "%s, calibration failed!\n", __func__);
1638
1639	/* HP output enable */
1640	regmap_write(rt711->regmap,
1641		SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_OT1, RT711_SDCA_CTL_VENDOR_DEF, 0), 0x4);
1642
1643	/*
1644	 * if set_jack callback occurred early than io_init,
1645	 * we set up the jack detection function now
1646	 */
1647	if (rt711->hs_jack)
1648		rt711_sdca_jack_init(rt711);
1649
1650	if (rt711->first_hw_init) {
1651		regcache_cache_bypass(rt711->regmap, false);
1652		regcache_mark_dirty(rt711->regmap);
1653		regcache_cache_bypass(rt711->mbq_regmap, false);
1654		regcache_mark_dirty(rt711->mbq_regmap);
1655	} else
1656		rt711->first_hw_init = true;
1657
1658	/* Mark Slave initialization complete */
1659	rt711->hw_init = true;
1660
1661	pm_runtime_put_autosuspend(&slave->dev);
1662
1663	dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1664	return 0;
1665}
1666
1667MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver");
1668MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1669MODULE_LICENSE("GPL");