rt700.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // rt700.c -- rt700 ALSA SoC audio driver
  4. //
  5. // Copyright(c) 2019 Realtek Semiconductor Corp.
  6. //
  7. //
  8. #include <linux/module.h>
  9. #include <linux/moduleparam.h>
  10. #include <linux/kernel.h>
  11. #include <linux/init.h>
  12. #include <linux/delay.h>
  13. #include <linux/pm_runtime.h>
  14. #include <linux/pm.h>
  15. #include <linux/soundwire/sdw.h>
  16. #include <linux/regmap.h>
  17. #include <linux/slab.h>
  18. #include <sound/core.h>
  19. #include <sound/pcm.h>
  20. #include <sound/pcm_params.h>
  21. #include <sound/soc.h>
  22. #include <sound/soc-dapm.h>
  23. #include <sound/initval.h>
  24. #include <sound/tlv.h>
  25. #include <sound/hda_verbs.h>
  26. #include <sound/jack.h>
  27. #include "rt700.h"
  28. static int rt700_index_write(struct regmap *regmap,
  29. unsigned int reg, unsigned int value)
  30. {
  31. int ret;
  32. unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
  33. ret = regmap_write(regmap, addr, value);
  34. if (ret < 0)
  35. pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
  36. addr, value, ret);
  37. return ret;
  38. }
  39. static int rt700_index_read(struct regmap *regmap,
  40. unsigned int reg, unsigned int *value)
  41. {
  42. int ret;
  43. unsigned int addr = (RT700_PRIV_INDEX_W_H << 8) | reg;
  44. *value = 0;
  45. ret = regmap_read(regmap, addr, value);
  46. if (ret < 0)
  47. pr_err("Failed to get private value: %06x => %04x ret=%d\n",
  48. addr, *value, ret);
  49. return ret;
  50. }
  51. static unsigned int rt700_button_detect(struct rt700_priv *rt700)
  52. {
  53. unsigned int btn_type = 0, val80, val81;
  54. int ret;
  55. ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE1, &val80);
  56. if (ret < 0)
  57. goto read_error;
  58. ret = rt700_index_read(rt700->regmap, RT700_IRQ_FLAG_TABLE2, &val81);
  59. if (ret < 0)
  60. goto read_error;
  61. val80 &= 0x0381;
  62. val81 &= 0xff00;
  63. switch (val80) {
  64. case 0x0200:
  65. case 0x0100:
  66. case 0x0080:
  67. btn_type |= SND_JACK_BTN_0;
  68. break;
  69. case 0x0001:
  70. btn_type |= SND_JACK_BTN_3;
  71. break;
  72. }
  73. switch (val81) {
  74. case 0x8000:
  75. case 0x4000:
  76. case 0x2000:
  77. btn_type |= SND_JACK_BTN_1;
  78. break;
  79. case 0x1000:
  80. case 0x0800:
  81. case 0x0400:
  82. btn_type |= SND_JACK_BTN_2;
  83. break;
  84. case 0x0200:
  85. case 0x0100:
  86. btn_type |= SND_JACK_BTN_3;
  87. break;
  88. }
  89. read_error:
  90. return btn_type;
  91. }
  92. static int rt700_headset_detect(struct rt700_priv *rt700)
  93. {
  94. unsigned int buf, loop = 0;
  95. int ret;
  96. unsigned int jack_status = 0, reg;
  97. ret = rt700_index_read(rt700->regmap,
  98. RT700_COMBO_JACK_AUTO_CTL2, &buf);
  99. if (ret < 0)
  100. goto io_error;
  101. while (loop < 500 &&
  102. (buf & RT700_COMBOJACK_AUTO_DET_STATUS) == 0) {
  103. loop++;
  104. usleep_range(9000, 10000);
  105. ret = rt700_index_read(rt700->regmap,
  106. RT700_COMBO_JACK_AUTO_CTL2, &buf);
  107. if (ret < 0)
  108. goto io_error;
  109. reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
  110. ret = regmap_read(rt700->regmap, reg, &jack_status);
  111. if ((jack_status & (1 << 31)) == 0)
  112. goto remove_error;
  113. }
  114. if (loop >= 500)
  115. goto to_error;
  116. if (buf & RT700_COMBOJACK_AUTO_DET_TRS)
  117. rt700->jack_type = SND_JACK_HEADPHONE;
  118. else if ((buf & RT700_COMBOJACK_AUTO_DET_CTIA) ||
  119. (buf & RT700_COMBOJACK_AUTO_DET_OMTP))
  120. rt700->jack_type = SND_JACK_HEADSET;
  121. return 0;
  122. to_error:
  123. ret = -ETIMEDOUT;
  124. pr_err_ratelimited("Time-out error in %s\n", __func__);
  125. return ret;
  126. io_error:
  127. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  128. return ret;
  129. remove_error:
  130. pr_err_ratelimited("Jack removal in %s\n", __func__);
  131. return -ENODEV;
  132. }
  133. static void rt700_jack_detect_handler(struct work_struct *work)
  134. {
  135. struct rt700_priv *rt700 =
  136. container_of(work, struct rt700_priv, jack_detect_work.work);
  137. int btn_type = 0, ret;
  138. unsigned int jack_status = 0, reg;
  139. if (!rt700->hs_jack)
  140. return;
  141. if (!rt700->component->card->instantiated)
  142. return;
  143. reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
  144. ret = regmap_read(rt700->regmap, reg, &jack_status);
  145. if (ret < 0)
  146. goto io_error;
  147. /* pin attached */
  148. if (jack_status & (1 << 31)) {
  149. /* jack in */
  150. if (rt700->jack_type == 0) {
  151. ret = rt700_headset_detect(rt700);
  152. if (ret < 0)
  153. return;
  154. if (rt700->jack_type == SND_JACK_HEADSET)
  155. btn_type = rt700_button_detect(rt700);
  156. } else if (rt700->jack_type == SND_JACK_HEADSET) {
  157. /* jack is already in, report button event */
  158. btn_type = rt700_button_detect(rt700);
  159. }
  160. } else {
  161. /* jack out */
  162. rt700->jack_type = 0;
  163. }
  164. dev_dbg(&rt700->slave->dev,
  165. "in %s, jack_type=0x%x\n", __func__, rt700->jack_type);
  166. dev_dbg(&rt700->slave->dev,
  167. "in %s, btn_type=0x%x\n", __func__, btn_type);
  168. snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
  169. SND_JACK_HEADSET |
  170. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  171. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  172. if (btn_type) {
  173. /* button released */
  174. snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
  175. SND_JACK_HEADSET |
  176. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  177. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  178. mod_delayed_work(system_power_efficient_wq,
  179. &rt700->jack_btn_check_work, msecs_to_jiffies(200));
  180. }
  181. return;
  182. io_error:
  183. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  184. }
  185. static void rt700_btn_check_handler(struct work_struct *work)
  186. {
  187. struct rt700_priv *rt700 = container_of(work, struct rt700_priv,
  188. jack_btn_check_work.work);
  189. int btn_type = 0, ret;
  190. unsigned int jack_status = 0, reg;
  191. reg = RT700_VERB_GET_PIN_SENSE | RT700_HP_OUT;
  192. ret = regmap_read(rt700->regmap, reg, &jack_status);
  193. if (ret < 0)
  194. goto io_error;
  195. /* pin attached */
  196. if (jack_status & (1 << 31)) {
  197. if (rt700->jack_type == SND_JACK_HEADSET) {
  198. /* jack is already in, report button event */
  199. btn_type = rt700_button_detect(rt700);
  200. }
  201. } else {
  202. rt700->jack_type = 0;
  203. }
  204. /* cbj comparator */
  205. ret = rt700_index_read(rt700->regmap, RT700_COMBO_JACK_AUTO_CTL2, &reg);
  206. if (ret < 0)
  207. goto io_error;
  208. if ((reg & 0xf0) == 0xf0)
  209. btn_type = 0;
  210. dev_dbg(&rt700->slave->dev,
  211. "%s, btn_type=0x%x\n", __func__, btn_type);
  212. snd_soc_jack_report(rt700->hs_jack, rt700->jack_type | btn_type,
  213. SND_JACK_HEADSET |
  214. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  215. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  216. if (btn_type) {
  217. /* button released */
  218. snd_soc_jack_report(rt700->hs_jack, rt700->jack_type,
  219. SND_JACK_HEADSET |
  220. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  221. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  222. mod_delayed_work(system_power_efficient_wq,
  223. &rt700->jack_btn_check_work, msecs_to_jiffies(200));
  224. }
  225. return;
  226. io_error:
  227. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  228. }
  229. static void rt700_jack_init(struct rt700_priv *rt700)
  230. {
  231. struct snd_soc_dapm_context *dapm =
  232. snd_soc_component_get_dapm(rt700->component);
  233. /* power on */
  234. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  235. regmap_write(rt700->regmap,
  236. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  237. if (rt700->hs_jack) {
  238. /* Enable Jack Detection */
  239. regmap_write(rt700->regmap,
  240. RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x82);
  241. regmap_write(rt700->regmap,
  242. RT700_SET_HP_UNSOLICITED_ENABLE, 0x81);
  243. regmap_write(rt700->regmap,
  244. RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x83);
  245. rt700_index_write(rt700->regmap, 0x10, 0x2420);
  246. rt700_index_write(rt700->regmap, 0x19, 0x2e11);
  247. dev_dbg(&rt700->slave->dev, "in %s enable\n", __func__);
  248. mod_delayed_work(system_power_efficient_wq,
  249. &rt700->jack_detect_work, msecs_to_jiffies(250));
  250. } else {
  251. regmap_write(rt700->regmap,
  252. RT700_SET_MIC2_UNSOLICITED_ENABLE, 0x00);
  253. regmap_write(rt700->regmap,
  254. RT700_SET_HP_UNSOLICITED_ENABLE, 0x00);
  255. regmap_write(rt700->regmap,
  256. RT700_SET_INLINE_UNSOLICITED_ENABLE, 0x00);
  257. dev_dbg(&rt700->slave->dev, "in %s disable\n", __func__);
  258. }
  259. /* power off */
  260. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  261. regmap_write(rt700->regmap,
  262. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  263. }
  264. static int rt700_set_jack_detect(struct snd_soc_component *component,
  265. struct snd_soc_jack *hs_jack, void *data)
  266. {
  267. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  268. rt700->hs_jack = hs_jack;
  269. if (!rt700->hw_init) {
  270. dev_dbg(&rt700->slave->dev,
  271. "%s hw_init not ready yet\n", __func__);
  272. return 0;
  273. }
  274. rt700_jack_init(rt700);
  275. return 0;
  276. }
  277. static void rt700_get_gain(struct rt700_priv *rt700, unsigned int addr_h,
  278. unsigned int addr_l, unsigned int val_h,
  279. unsigned int *r_val, unsigned int *l_val)
  280. {
  281. /* R Channel */
  282. *r_val = (val_h << 8);
  283. regmap_read(rt700->regmap, addr_l, r_val);
  284. /* L Channel */
  285. val_h |= 0x20;
  286. *l_val = (val_h << 8);
  287. regmap_read(rt700->regmap, addr_h, l_val);
  288. }
  289. /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
  290. static int rt700_set_amp_gain_put(struct snd_kcontrol *kcontrol,
  291. struct snd_ctl_elem_value *ucontrol)
  292. {
  293. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  294. struct snd_soc_dapm_context *dapm =
  295. snd_soc_component_get_dapm(component);
  296. struct soc_mixer_control *mc =
  297. (struct soc_mixer_control *)kcontrol->private_value;
  298. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  299. unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
  300. unsigned int read_ll, read_rl;
  301. int i;
  302. /* Can't use update bit function, so read the original value first */
  303. addr_h = mc->reg;
  304. addr_l = mc->rreg;
  305. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  306. val_h = 0x80;
  307. else /* input */
  308. val_h = 0x0;
  309. rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
  310. /* L Channel */
  311. if (mc->invert) {
  312. /* for mute */
  313. val_ll = (mc->max - ucontrol->value.integer.value[0]) << 7;
  314. /* keep gain */
  315. read_ll = read_ll & 0x7f;
  316. val_ll |= read_ll;
  317. } else {
  318. /* for gain */
  319. val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
  320. if (val_ll > mc->max)
  321. val_ll = mc->max;
  322. /* keep mute status */
  323. read_ll = read_ll & 0x80;
  324. val_ll |= read_ll;
  325. }
  326. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  327. regmap_write(rt700->regmap,
  328. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  329. /* R Channel */
  330. if (mc->invert) {
  331. /* for mute */
  332. val_lr = (mc->max - ucontrol->value.integer.value[1]) << 7;
  333. /* keep gain */
  334. read_rl = read_rl & 0x7f;
  335. val_lr |= read_rl;
  336. } else {
  337. /* for gain */
  338. val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
  339. if (val_lr > mc->max)
  340. val_lr = mc->max;
  341. /* keep mute status */
  342. read_rl = read_rl & 0x80;
  343. val_lr |= read_rl;
  344. }
  345. for (i = 0; i < 3; i++) { /* retry 3 times at most */
  346. if (val_ll == val_lr) {
  347. /* Set both L/R channels at the same time */
  348. val_h = (1 << mc->shift) | (3 << 4);
  349. regmap_write(rt700->regmap,
  350. addr_h, (val_h << 8 | val_ll));
  351. regmap_write(rt700->regmap,
  352. addr_l, (val_h << 8 | val_ll));
  353. } else {
  354. /* Lch*/
  355. val_h = (1 << mc->shift) | (1 << 5);
  356. regmap_write(rt700->regmap,
  357. addr_h, (val_h << 8 | val_ll));
  358. /* Rch */
  359. val_h = (1 << mc->shift) | (1 << 4);
  360. regmap_write(rt700->regmap,
  361. addr_l, (val_h << 8 | val_lr));
  362. }
  363. /* check result */
  364. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  365. val_h = 0x80;
  366. else /* input */
  367. val_h = 0x0;
  368. rt700_get_gain(rt700, addr_h, addr_l, val_h,
  369. &read_rl, &read_ll);
  370. if (read_rl == val_lr && read_ll == val_ll)
  371. break;
  372. }
  373. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  374. regmap_write(rt700->regmap,
  375. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  376. return 0;
  377. }
  378. static int rt700_set_amp_gain_get(struct snd_kcontrol *kcontrol,
  379. struct snd_ctl_elem_value *ucontrol)
  380. {
  381. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  382. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  383. struct soc_mixer_control *mc =
  384. (struct soc_mixer_control *)kcontrol->private_value;
  385. unsigned int addr_h, addr_l, val_h;
  386. unsigned int read_ll, read_rl;
  387. addr_h = mc->reg;
  388. addr_l = mc->rreg;
  389. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  390. val_h = 0x80;
  391. else /* input */
  392. val_h = 0x0;
  393. rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
  394. if (mc->invert) {
  395. /* for mute status */
  396. read_ll = !((read_ll & 0x80) >> RT700_MUTE_SFT);
  397. read_rl = !((read_rl & 0x80) >> RT700_MUTE_SFT);
  398. } else {
  399. /* for gain */
  400. read_ll = read_ll & 0x7f;
  401. read_rl = read_rl & 0x7f;
  402. }
  403. ucontrol->value.integer.value[0] = read_ll;
  404. ucontrol->value.integer.value[1] = read_rl;
  405. return 0;
  406. }
  407. static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
  408. static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
  409. static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
  410. static const struct snd_kcontrol_new rt700_snd_controls[] = {
  411. SOC_DOUBLE_R_EXT_TLV("DAC Front Playback Volume",
  412. RT700_SET_GAIN_DAC1_H, RT700_SET_GAIN_DAC1_L,
  413. RT700_DIR_OUT_SFT, 0x57, 0,
  414. rt700_set_amp_gain_get, rt700_set_amp_gain_put, out_vol_tlv),
  415. SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
  416. RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
  417. RT700_DIR_IN_SFT, 1, 1,
  418. rt700_set_amp_gain_get, rt700_set_amp_gain_put),
  419. SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
  420. RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
  421. RT700_DIR_IN_SFT, 1, 1,
  422. rt700_set_amp_gain_get, rt700_set_amp_gain_put),
  423. SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
  424. RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
  425. RT700_DIR_IN_SFT, 0x3f, 0,
  426. rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
  427. SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
  428. RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
  429. RT700_DIR_IN_SFT, 0x3f, 0,
  430. rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
  431. SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
  432. RT700_SET_GAIN_AMIC_H, RT700_SET_GAIN_AMIC_L,
  433. RT700_DIR_IN_SFT, 3, 0,
  434. rt700_set_amp_gain_get, rt700_set_amp_gain_put, mic_vol_tlv),
  435. };
  436. static int rt700_mux_get(struct snd_kcontrol *kcontrol,
  437. struct snd_ctl_elem_value *ucontrol)
  438. {
  439. struct snd_soc_component *component =
  440. snd_soc_dapm_kcontrol_component(kcontrol);
  441. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  442. unsigned int reg, val = 0, nid;
  443. int ret;
  444. if (strstr(ucontrol->id.name, "HPO Mux"))
  445. nid = RT700_HP_OUT;
  446. else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  447. nid = RT700_MIXER_IN1;
  448. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  449. nid = RT700_MIXER_IN2;
  450. else
  451. return -EINVAL;
  452. /* vid = 0xf01 */
  453. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  454. ret = regmap_read(rt700->regmap, reg, &val);
  455. if (ret < 0)
  456. return ret;
  457. ucontrol->value.enumerated.item[0] = val;
  458. return 0;
  459. }
  460. static int rt700_mux_put(struct snd_kcontrol *kcontrol,
  461. struct snd_ctl_elem_value *ucontrol)
  462. {
  463. struct snd_soc_component *component =
  464. snd_soc_dapm_kcontrol_component(kcontrol);
  465. struct snd_soc_dapm_context *dapm =
  466. snd_soc_dapm_kcontrol_dapm(kcontrol);
  467. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  468. struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
  469. unsigned int *item = ucontrol->value.enumerated.item;
  470. unsigned int val, val2 = 0, change, reg, nid;
  471. int ret;
  472. if (item[0] >= e->items)
  473. return -EINVAL;
  474. if (strstr(ucontrol->id.name, "HPO Mux"))
  475. nid = RT700_HP_OUT;
  476. else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  477. nid = RT700_MIXER_IN1;
  478. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  479. nid = RT700_MIXER_IN2;
  480. else
  481. return -EINVAL;
  482. /* Verb ID = 0x701h */
  483. val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
  484. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  485. ret = regmap_read(rt700->regmap, reg, &val2);
  486. if (ret < 0)
  487. return ret;
  488. if (val == val2)
  489. change = 0;
  490. else
  491. change = 1;
  492. if (change) {
  493. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  494. regmap_write(rt700->regmap, reg, val);
  495. }
  496. snd_soc_dapm_mux_update_power(dapm, kcontrol,
  497. item[0], e, NULL);
  498. return change;
  499. }
  500. static const char * const adc_mux_text[] = {
  501. "MIC2",
  502. "LINE1",
  503. "LINE2",
  504. "DMIC",
  505. };
  506. static SOC_ENUM_SINGLE_DECL(
  507. rt700_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
  508. static SOC_ENUM_SINGLE_DECL(
  509. rt700_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
  510. static const struct snd_kcontrol_new rt700_adc22_mux =
  511. SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt700_adc22_enum,
  512. rt700_mux_get, rt700_mux_put);
  513. static const struct snd_kcontrol_new rt700_adc23_mux =
  514. SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt700_adc23_enum,
  515. rt700_mux_get, rt700_mux_put);
  516. static const char * const out_mux_text[] = {
  517. "Front",
  518. "Surround",
  519. };
  520. static SOC_ENUM_SINGLE_DECL(
  521. rt700_hp_enum, SND_SOC_NOPM, 0, out_mux_text);
  522. static const struct snd_kcontrol_new rt700_hp_mux =
  523. SOC_DAPM_ENUM_EXT("HP Mux", rt700_hp_enum,
  524. rt700_mux_get, rt700_mux_put);
  525. static int rt700_dac_front_event(struct snd_soc_dapm_widget *w,
  526. struct snd_kcontrol *kcontrol, int event)
  527. {
  528. struct snd_soc_component *component =
  529. snd_soc_dapm_to_component(w->dapm);
  530. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  531. switch (event) {
  532. case SND_SOC_DAPM_POST_PMU:
  533. regmap_write(rt700->regmap,
  534. RT700_SET_STREAMID_DAC1, 0x10);
  535. break;
  536. case SND_SOC_DAPM_PRE_PMD:
  537. regmap_write(rt700->regmap,
  538. RT700_SET_STREAMID_DAC1, 0x00);
  539. break;
  540. }
  541. return 0;
  542. }
  543. static int rt700_dac_surround_event(struct snd_soc_dapm_widget *w,
  544. struct snd_kcontrol *kcontrol, int event)
  545. {
  546. struct snd_soc_component *component =
  547. snd_soc_dapm_to_component(w->dapm);
  548. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  549. switch (event) {
  550. case SND_SOC_DAPM_POST_PMU:
  551. regmap_write(rt700->regmap,
  552. RT700_SET_STREAMID_DAC2, 0x10);
  553. break;
  554. case SND_SOC_DAPM_PRE_PMD:
  555. regmap_write(rt700->regmap,
  556. RT700_SET_STREAMID_DAC2, 0x00);
  557. break;
  558. }
  559. return 0;
  560. }
  561. static int rt700_adc_09_event(struct snd_soc_dapm_widget *w,
  562. struct snd_kcontrol *kcontrol, int event)
  563. {
  564. struct snd_soc_component *component =
  565. snd_soc_dapm_to_component(w->dapm);
  566. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  567. switch (event) {
  568. case SND_SOC_DAPM_POST_PMU:
  569. regmap_write(rt700->regmap,
  570. RT700_SET_STREAMID_ADC1, 0x10);
  571. break;
  572. case SND_SOC_DAPM_PRE_PMD:
  573. regmap_write(rt700->regmap,
  574. RT700_SET_STREAMID_ADC1, 0x00);
  575. break;
  576. }
  577. return 0;
  578. }
  579. static int rt700_adc_08_event(struct snd_soc_dapm_widget *w,
  580. struct snd_kcontrol *kcontrol, int event)
  581. {
  582. struct snd_soc_component *component =
  583. snd_soc_dapm_to_component(w->dapm);
  584. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  585. switch (event) {
  586. case SND_SOC_DAPM_POST_PMU:
  587. regmap_write(rt700->regmap,
  588. RT700_SET_STREAMID_ADC2, 0x10);
  589. break;
  590. case SND_SOC_DAPM_PRE_PMD:
  591. regmap_write(rt700->regmap,
  592. RT700_SET_STREAMID_ADC2, 0x00);
  593. break;
  594. }
  595. return 0;
  596. }
  597. static int rt700_hpo_mux_event(struct snd_soc_dapm_widget *w,
  598. struct snd_kcontrol *kcontrol, int event)
  599. {
  600. struct snd_soc_component *component =
  601. snd_soc_dapm_to_component(w->dapm);
  602. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  603. unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
  604. unsigned int val_l;
  605. switch (event) {
  606. case SND_SOC_DAPM_POST_PMU:
  607. val_l = 0x00;
  608. regmap_write(rt700->regmap,
  609. RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
  610. break;
  611. case SND_SOC_DAPM_PRE_PMD:
  612. val_l = (1 << RT700_MUTE_SFT);
  613. regmap_write(rt700->regmap,
  614. RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
  615. usleep_range(50000, 55000);
  616. break;
  617. }
  618. return 0;
  619. }
  620. static int rt700_spk_pga_event(struct snd_soc_dapm_widget *w,
  621. struct snd_kcontrol *kcontrol, int event)
  622. {
  623. struct snd_soc_component *component =
  624. snd_soc_dapm_to_component(w->dapm);
  625. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  626. unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
  627. unsigned int val_l;
  628. switch (event) {
  629. case SND_SOC_DAPM_POST_PMU:
  630. val_l = 0x00;
  631. regmap_write(rt700->regmap,
  632. RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
  633. break;
  634. case SND_SOC_DAPM_PRE_PMD:
  635. val_l = (1 << RT700_MUTE_SFT);
  636. regmap_write(rt700->regmap,
  637. RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
  638. break;
  639. }
  640. return 0;
  641. }
  642. static const struct snd_soc_dapm_widget rt700_dapm_widgets[] = {
  643. SND_SOC_DAPM_OUTPUT("HP"),
  644. SND_SOC_DAPM_OUTPUT("SPK"),
  645. SND_SOC_DAPM_INPUT("DMIC1"),
  646. SND_SOC_DAPM_INPUT("DMIC2"),
  647. SND_SOC_DAPM_INPUT("MIC2"),
  648. SND_SOC_DAPM_INPUT("LINE1"),
  649. SND_SOC_DAPM_INPUT("LINE2"),
  650. SND_SOC_DAPM_DAC_E("DAC Front", NULL, SND_SOC_NOPM, 0, 0,
  651. rt700_dac_front_event,
  652. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  653. SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
  654. rt700_dac_surround_event,
  655. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  656. SND_SOC_DAPM_MUX_E("HPO Mux", SND_SOC_NOPM, 0, 0, &rt700_hp_mux,
  657. rt700_hpo_mux_event,
  658. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  659. SND_SOC_DAPM_PGA_E("SPK PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
  660. rt700_spk_pga_event,
  661. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  662. SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
  663. rt700_adc_09_event,
  664. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  665. SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
  666. rt700_adc_08_event,
  667. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  668. SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
  669. &rt700_adc22_mux),
  670. SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
  671. &rt700_adc23_mux),
  672. SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
  673. SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
  674. SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
  675. SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
  676. };
  677. static const struct snd_soc_dapm_route rt700_audio_map[] = {
  678. {"DAC Front", NULL, "DP1RX"},
  679. {"DAC Surround", NULL, "DP3RX"},
  680. {"DP2TX", NULL, "ADC 09"},
  681. {"DP4TX", NULL, "ADC 08"},
  682. {"ADC 09", NULL, "ADC 22 Mux"},
  683. {"ADC 08", NULL, "ADC 23 Mux"},
  684. {"ADC 22 Mux", "DMIC", "DMIC1"},
  685. {"ADC 22 Mux", "LINE1", "LINE1"},
  686. {"ADC 22 Mux", "LINE2", "LINE2"},
  687. {"ADC 22 Mux", "MIC2", "MIC2"},
  688. {"ADC 23 Mux", "DMIC", "DMIC2"},
  689. {"ADC 23 Mux", "LINE1", "LINE1"},
  690. {"ADC 23 Mux", "LINE2", "LINE2"},
  691. {"ADC 23 Mux", "MIC2", "MIC2"},
  692. {"HPO Mux", "Front", "DAC Front"},
  693. {"HPO Mux", "Surround", "DAC Surround"},
  694. {"HP", NULL, "HPO Mux"},
  695. {"SPK PGA", NULL, "DAC Front"},
  696. {"SPK", NULL, "SPK PGA"},
  697. };
  698. static int rt700_probe(struct snd_soc_component *component)
  699. {
  700. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  701. rt700->component = component;
  702. return 0;
  703. }
  704. static int rt700_set_bias_level(struct snd_soc_component *component,
  705. enum snd_soc_bias_level level)
  706. {
  707. struct snd_soc_dapm_context *dapm =
  708. snd_soc_component_get_dapm(component);
  709. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  710. switch (level) {
  711. case SND_SOC_BIAS_PREPARE:
  712. if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
  713. regmap_write(rt700->regmap,
  714. RT700_SET_AUDIO_POWER_STATE,
  715. AC_PWRST_D0);
  716. }
  717. break;
  718. case SND_SOC_BIAS_STANDBY:
  719. regmap_write(rt700->regmap,
  720. RT700_SET_AUDIO_POWER_STATE,
  721. AC_PWRST_D3);
  722. break;
  723. default:
  724. break;
  725. }
  726. dapm->bias_level = level;
  727. return 0;
  728. }
  729. static const struct snd_soc_component_driver soc_codec_dev_rt700 = {
  730. .probe = rt700_probe,
  731. .set_bias_level = rt700_set_bias_level,
  732. .controls = rt700_snd_controls,
  733. .num_controls = ARRAY_SIZE(rt700_snd_controls),
  734. .dapm_widgets = rt700_dapm_widgets,
  735. .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets),
  736. .dapm_routes = rt700_audio_map,
  737. .num_dapm_routes = ARRAY_SIZE(rt700_audio_map),
  738. .set_jack = rt700_set_jack_detect,
  739. };
  740. static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
  741. int direction)
  742. {
  743. struct sdw_stream_data *stream;
  744. if (!sdw_stream)
  745. return 0;
  746. stream = kzalloc(sizeof(*stream), GFP_KERNEL);
  747. if (!stream)
  748. return -ENOMEM;
  749. stream->sdw_stream = (struct sdw_stream_runtime *)sdw_stream;
  750. /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
  751. if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  752. dai->playback_dma_data = stream;
  753. else
  754. dai->capture_dma_data = stream;
  755. return 0;
  756. }
  757. static void rt700_shutdown(struct snd_pcm_substream *substream,
  758. struct snd_soc_dai *dai)
  759. {
  760. struct sdw_stream_data *stream;
  761. stream = snd_soc_dai_get_dma_data(dai, substream);
  762. snd_soc_dai_set_dma_data(dai, substream, NULL);
  763. kfree(stream);
  764. }
  765. static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
  766. struct snd_pcm_hw_params *params,
  767. struct snd_soc_dai *dai)
  768. {
  769. struct snd_soc_component *component = dai->component;
  770. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  771. struct sdw_stream_config stream_config;
  772. struct sdw_port_config port_config;
  773. enum sdw_data_direction direction;
  774. struct sdw_stream_data *stream;
  775. int retval, port, num_channels;
  776. unsigned int val = 0;
  777. dev_dbg(dai->dev, "%s %s", __func__, dai->name);
  778. stream = snd_soc_dai_get_dma_data(dai, substream);
  779. if (!stream)
  780. return -EINVAL;
  781. if (!rt700->slave)
  782. return -EINVAL;
  783. /* SoundWire specific configuration */
  784. /* This code assumes port 1 for playback and port 2 for capture */
  785. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  786. direction = SDW_DATA_DIR_RX;
  787. port = 1;
  788. } else {
  789. direction = SDW_DATA_DIR_TX;
  790. port = 2;
  791. }
  792. switch (dai->id) {
  793. case RT700_AIF1:
  794. break;
  795. case RT700_AIF2:
  796. port += 2;
  797. break;
  798. default:
  799. dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
  800. return -EINVAL;
  801. }
  802. stream_config.frame_rate = params_rate(params);
  803. stream_config.ch_count = params_channels(params);
  804. stream_config.bps = snd_pcm_format_width(params_format(params));
  805. stream_config.direction = direction;
  806. num_channels = params_channels(params);
  807. port_config.ch_mask = (1 << (num_channels)) - 1;
  808. port_config.num = port;
  809. retval = sdw_stream_add_slave(rt700->slave, &stream_config,
  810. &port_config, 1, stream->sdw_stream);
  811. if (retval) {
  812. dev_err(dai->dev, "Unable to configure port\n");
  813. return retval;
  814. }
  815. if (params_channels(params) <= 16) {
  816. /* bit 3:0 Number of Channel */
  817. val |= (params_channels(params) - 1);
  818. } else {
  819. dev_err(component->dev, "Unsupported channels %d\n",
  820. params_channels(params));
  821. return -EINVAL;
  822. }
  823. switch (params_width(params)) {
  824. /* bit 6:4 Bits per Sample */
  825. case 8:
  826. break;
  827. case 16:
  828. val |= (0x1 << 4);
  829. break;
  830. case 20:
  831. val |= (0x2 << 4);
  832. break;
  833. case 24:
  834. val |= (0x3 << 4);
  835. break;
  836. case 32:
  837. val |= (0x4 << 4);
  838. break;
  839. default:
  840. return -EINVAL;
  841. }
  842. /* 48Khz */
  843. regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val);
  844. regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val);
  845. return retval;
  846. }
  847. static int rt700_pcm_hw_free(struct snd_pcm_substream *substream,
  848. struct snd_soc_dai *dai)
  849. {
  850. struct snd_soc_component *component = dai->component;
  851. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  852. struct sdw_stream_data *stream =
  853. snd_soc_dai_get_dma_data(dai, substream);
  854. if (!rt700->slave)
  855. return -EINVAL;
  856. sdw_stream_remove_slave(rt700->slave, stream->sdw_stream);
  857. return 0;
  858. }
  859. #define RT700_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
  860. #define RT700_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
  861. SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
  862. static struct snd_soc_dai_ops rt700_ops = {
  863. .hw_params = rt700_pcm_hw_params,
  864. .hw_free = rt700_pcm_hw_free,
  865. .set_sdw_stream = rt700_set_sdw_stream,
  866. .shutdown = rt700_shutdown,
  867. };
  868. static struct snd_soc_dai_driver rt700_dai[] = {
  869. {
  870. .name = "rt700-aif1",
  871. .id = RT700_AIF1,
  872. .playback = {
  873. .stream_name = "DP1 Playback",
  874. .channels_min = 1,
  875. .channels_max = 2,
  876. .rates = RT700_STEREO_RATES,
  877. .formats = RT700_FORMATS,
  878. },
  879. .capture = {
  880. .stream_name = "DP2 Capture",
  881. .channels_min = 1,
  882. .channels_max = 2,
  883. .rates = RT700_STEREO_RATES,
  884. .formats = RT700_FORMATS,
  885. },
  886. .ops = &rt700_ops,
  887. },
  888. {
  889. .name = "rt700-aif2",
  890. .id = RT700_AIF2,
  891. .playback = {
  892. .stream_name = "DP3 Playback",
  893. .channels_min = 1,
  894. .channels_max = 2,
  895. .rates = RT700_STEREO_RATES,
  896. .formats = RT700_FORMATS,
  897. },
  898. .capture = {
  899. .stream_name = "DP4 Capture",
  900. .channels_min = 1,
  901. .channels_max = 2,
  902. .rates = RT700_STEREO_RATES,
  903. .formats = RT700_FORMATS,
  904. },
  905. .ops = &rt700_ops,
  906. },
  907. };
  908. /* Bus clock frequency */
  909. #define RT700_CLK_FREQ_9600000HZ 9600000
  910. #define RT700_CLK_FREQ_12000000HZ 12000000
  911. #define RT700_CLK_FREQ_6000000HZ 6000000
  912. #define RT700_CLK_FREQ_4800000HZ 4800000
  913. #define RT700_CLK_FREQ_2400000HZ 2400000
  914. #define RT700_CLK_FREQ_12288000HZ 12288000
  915. int rt700_clock_config(struct device *dev)
  916. {
  917. struct rt700_priv *rt700 = dev_get_drvdata(dev);
  918. unsigned int clk_freq, value;
  919. clk_freq = (rt700->params.curr_dr_freq >> 1);
  920. switch (clk_freq) {
  921. case RT700_CLK_FREQ_12000000HZ:
  922. value = 0x0;
  923. break;
  924. case RT700_CLK_FREQ_6000000HZ:
  925. value = 0x1;
  926. break;
  927. case RT700_CLK_FREQ_9600000HZ:
  928. value = 0x2;
  929. break;
  930. case RT700_CLK_FREQ_4800000HZ:
  931. value = 0x3;
  932. break;
  933. case RT700_CLK_FREQ_2400000HZ:
  934. value = 0x4;
  935. break;
  936. case RT700_CLK_FREQ_12288000HZ:
  937. value = 0x5;
  938. break;
  939. default:
  940. return -EINVAL;
  941. }
  942. regmap_write(rt700->regmap, 0xe0, value);
  943. regmap_write(rt700->regmap, 0xf0, value);
  944. dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
  945. return 0;
  946. }
  947. int rt700_init(struct device *dev, struct regmap *sdw_regmap,
  948. struct regmap *regmap, struct sdw_slave *slave)
  949. {
  950. struct rt700_priv *rt700;
  951. int ret;
  952. rt700 = devm_kzalloc(dev, sizeof(*rt700), GFP_KERNEL);
  953. if (!rt700)
  954. return -ENOMEM;
  955. dev_set_drvdata(dev, rt700);
  956. rt700->slave = slave;
  957. rt700->sdw_regmap = sdw_regmap;
  958. rt700->regmap = regmap;
  959. /*
  960. * Mark hw_init to false
  961. * HW init will be performed when device reports present
  962. */
  963. rt700->hw_init = false;
  964. rt700->first_hw_init = false;
  965. ret = devm_snd_soc_register_component(dev,
  966. &soc_codec_dev_rt700,
  967. rt700_dai,
  968. ARRAY_SIZE(rt700_dai));
  969. dev_dbg(&slave->dev, "%s\n", __func__);
  970. return ret;
  971. }
  972. int rt700_io_init(struct device *dev, struct sdw_slave *slave)
  973. {
  974. struct rt700_priv *rt700 = dev_get_drvdata(dev);
  975. if (rt700->hw_init)
  976. return 0;
  977. if (rt700->first_hw_init) {
  978. regcache_cache_only(rt700->regmap, false);
  979. regcache_cache_bypass(rt700->regmap, true);
  980. }
  981. /*
  982. * PM runtime is only enabled when a Slave reports as Attached
  983. */
  984. if (!rt700->first_hw_init) {
  985. /* set autosuspend parameters */
  986. pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
  987. pm_runtime_use_autosuspend(&slave->dev);
  988. /* update count of parent 'active' children */
  989. pm_runtime_set_active(&slave->dev);
  990. /* make sure the device does not suspend immediately */
  991. pm_runtime_mark_last_busy(&slave->dev);
  992. pm_runtime_enable(&slave->dev);
  993. }
  994. pm_runtime_get_noresume(&slave->dev);
  995. /* reset */
  996. regmap_write(rt700->regmap, 0xff01, 0x0000);
  997. regmap_write(rt700->regmap, 0x7520, 0x001a);
  998. regmap_write(rt700->regmap, 0x7420, 0xc003);
  999. /* power on */
  1000. regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  1001. /* Set Pin Widget */
  1002. regmap_write(rt700->regmap, RT700_SET_PIN_HP, 0x40);
  1003. regmap_write(rt700->regmap, RT700_SET_PIN_SPK, 0x40);
  1004. regmap_write(rt700->regmap, RT700_SET_EAPD_SPK, RT700_EAPD_HIGH);
  1005. regmap_write(rt700->regmap, RT700_SET_PIN_DMIC1, 0x20);
  1006. regmap_write(rt700->regmap, RT700_SET_PIN_DMIC2, 0x20);
  1007. regmap_write(rt700->regmap, RT700_SET_PIN_MIC2, 0x20);
  1008. /* Set Configuration Default */
  1009. regmap_write(rt700->regmap, 0x4f12, 0x91);
  1010. regmap_write(rt700->regmap, 0x4e12, 0xd6);
  1011. regmap_write(rt700->regmap, 0x4d12, 0x11);
  1012. regmap_write(rt700->regmap, 0x4c12, 0x20);
  1013. regmap_write(rt700->regmap, 0x4f13, 0x91);
  1014. regmap_write(rt700->regmap, 0x4e13, 0xd6);
  1015. regmap_write(rt700->regmap, 0x4d13, 0x11);
  1016. regmap_write(rt700->regmap, 0x4c13, 0x21);
  1017. regmap_write(rt700->regmap, 0x4f19, 0x02);
  1018. regmap_write(rt700->regmap, 0x4e19, 0xa1);
  1019. regmap_write(rt700->regmap, 0x4d19, 0x90);
  1020. regmap_write(rt700->regmap, 0x4c19, 0x80);
  1021. /* Enable Line2 */
  1022. regmap_write(rt700->regmap, 0x371b, 0x40);
  1023. regmap_write(rt700->regmap, 0x731b, 0xb0);
  1024. regmap_write(rt700->regmap, 0x839b, 0x00);
  1025. /* Set index */
  1026. rt700_index_write(rt700->regmap, 0x4a, 0x201b);
  1027. rt700_index_write(rt700->regmap, 0x45, 0x5089);
  1028. rt700_index_write(rt700->regmap, 0x6b, 0x5064);
  1029. rt700_index_write(rt700->regmap, 0x48, 0xd249);
  1030. /* Finish Initial Settings, set power to D3 */
  1031. regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  1032. if (!rt700->first_hw_init) {
  1033. INIT_DELAYED_WORK(&rt700->jack_detect_work,
  1034. rt700_jack_detect_handler);
  1035. INIT_DELAYED_WORK(&rt700->jack_btn_check_work,
  1036. rt700_btn_check_handler);
  1037. }
  1038. /*
  1039. * if set_jack callback occurred early than io_init,
  1040. * we set up the jack detection function now
  1041. */
  1042. if (rt700->hs_jack)
  1043. rt700_jack_init(rt700);
  1044. if (rt700->first_hw_init) {
  1045. regcache_cache_bypass(rt700->regmap, false);
  1046. regcache_mark_dirty(rt700->regmap);
  1047. } else
  1048. rt700->first_hw_init = true;
  1049. /* Mark Slave initialization complete */
  1050. rt700->hw_init = true;
  1051. pm_runtime_mark_last_busy(&slave->dev);
  1052. pm_runtime_put_autosuspend(&slave->dev);
  1053. dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
  1054. return 0;
  1055. }
  1056. MODULE_DESCRIPTION("ASoC RT700 driver SDW");
  1057. MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
  1058. MODULE_LICENSE("GPL v2");