rt700.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258
  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 || !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. int ret;
  269. rt700->hs_jack = hs_jack;
  270. ret = pm_runtime_resume_and_get(component->dev);
  271. if (ret < 0) {
  272. if (ret != -EACCES) {
  273. dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
  274. return ret;
  275. }
  276. /* pm_runtime not enabled yet */
  277. dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
  278. return 0;
  279. }
  280. rt700_jack_init(rt700);
  281. pm_runtime_mark_last_busy(component->dev);
  282. pm_runtime_put_autosuspend(component->dev);
  283. return 0;
  284. }
  285. static void rt700_get_gain(struct rt700_priv *rt700, unsigned int addr_h,
  286. unsigned int addr_l, unsigned int val_h,
  287. unsigned int *r_val, unsigned int *l_val)
  288. {
  289. /* R Channel */
  290. *r_val = (val_h << 8);
  291. regmap_read(rt700->regmap, addr_l, r_val);
  292. /* L Channel */
  293. val_h |= 0x20;
  294. *l_val = (val_h << 8);
  295. regmap_read(rt700->regmap, addr_h, l_val);
  296. }
  297. /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
  298. static int rt700_set_amp_gain_put(struct snd_kcontrol *kcontrol,
  299. struct snd_ctl_elem_value *ucontrol)
  300. {
  301. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  302. struct snd_soc_dapm_context *dapm =
  303. snd_soc_component_get_dapm(component);
  304. struct soc_mixer_control *mc =
  305. (struct soc_mixer_control *)kcontrol->private_value;
  306. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  307. unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
  308. unsigned int read_ll, read_rl;
  309. int i;
  310. /* Can't use update bit function, so read the original value first */
  311. addr_h = mc->reg;
  312. addr_l = mc->rreg;
  313. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  314. val_h = 0x80;
  315. else /* input */
  316. val_h = 0x0;
  317. rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
  318. /* L Channel */
  319. if (mc->invert) {
  320. /* for mute */
  321. val_ll = (mc->max - ucontrol->value.integer.value[0]) << 7;
  322. /* keep gain */
  323. read_ll = read_ll & 0x7f;
  324. val_ll |= read_ll;
  325. } else {
  326. /* for gain */
  327. val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
  328. if (val_ll > mc->max)
  329. val_ll = mc->max;
  330. /* keep mute status */
  331. read_ll = read_ll & 0x80;
  332. val_ll |= read_ll;
  333. }
  334. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  335. regmap_write(rt700->regmap,
  336. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  337. /* R Channel */
  338. if (mc->invert) {
  339. /* for mute */
  340. val_lr = (mc->max - ucontrol->value.integer.value[1]) << 7;
  341. /* keep gain */
  342. read_rl = read_rl & 0x7f;
  343. val_lr |= read_rl;
  344. } else {
  345. /* for gain */
  346. val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
  347. if (val_lr > mc->max)
  348. val_lr = mc->max;
  349. /* keep mute status */
  350. read_rl = read_rl & 0x80;
  351. val_lr |= read_rl;
  352. }
  353. for (i = 0; i < 3; i++) { /* retry 3 times at most */
  354. if (val_ll == val_lr) {
  355. /* Set both L/R channels at the same time */
  356. val_h = (1 << mc->shift) | (3 << 4);
  357. regmap_write(rt700->regmap,
  358. addr_h, (val_h << 8 | val_ll));
  359. regmap_write(rt700->regmap,
  360. addr_l, (val_h << 8 | val_ll));
  361. } else {
  362. /* Lch*/
  363. val_h = (1 << mc->shift) | (1 << 5);
  364. regmap_write(rt700->regmap,
  365. addr_h, (val_h << 8 | val_ll));
  366. /* Rch */
  367. val_h = (1 << mc->shift) | (1 << 4);
  368. regmap_write(rt700->regmap,
  369. addr_l, (val_h << 8 | val_lr));
  370. }
  371. /* check result */
  372. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  373. val_h = 0x80;
  374. else /* input */
  375. val_h = 0x0;
  376. rt700_get_gain(rt700, addr_h, addr_l, val_h,
  377. &read_rl, &read_ll);
  378. if (read_rl == val_lr && read_ll == val_ll)
  379. break;
  380. }
  381. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  382. regmap_write(rt700->regmap,
  383. RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  384. return 0;
  385. }
  386. static int rt700_set_amp_gain_get(struct snd_kcontrol *kcontrol,
  387. struct snd_ctl_elem_value *ucontrol)
  388. {
  389. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  390. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  391. struct soc_mixer_control *mc =
  392. (struct soc_mixer_control *)kcontrol->private_value;
  393. unsigned int addr_h, addr_l, val_h;
  394. unsigned int read_ll, read_rl;
  395. addr_h = mc->reg;
  396. addr_l = mc->rreg;
  397. if (mc->shift == RT700_DIR_OUT_SFT) /* output */
  398. val_h = 0x80;
  399. else /* input */
  400. val_h = 0x0;
  401. rt700_get_gain(rt700, addr_h, addr_l, val_h, &read_rl, &read_ll);
  402. if (mc->invert) {
  403. /* for mute status */
  404. read_ll = !((read_ll & 0x80) >> RT700_MUTE_SFT);
  405. read_rl = !((read_rl & 0x80) >> RT700_MUTE_SFT);
  406. } else {
  407. /* for gain */
  408. read_ll = read_ll & 0x7f;
  409. read_rl = read_rl & 0x7f;
  410. }
  411. ucontrol->value.integer.value[0] = read_ll;
  412. ucontrol->value.integer.value[1] = read_rl;
  413. return 0;
  414. }
  415. static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
  416. static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
  417. static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
  418. static const struct snd_kcontrol_new rt700_snd_controls[] = {
  419. SOC_DOUBLE_R_EXT_TLV("DAC Front Playback Volume",
  420. RT700_SET_GAIN_DAC1_H, RT700_SET_GAIN_DAC1_L,
  421. RT700_DIR_OUT_SFT, 0x57, 0,
  422. rt700_set_amp_gain_get, rt700_set_amp_gain_put, out_vol_tlv),
  423. SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
  424. RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
  425. RT700_DIR_IN_SFT, 1, 1,
  426. rt700_set_amp_gain_get, rt700_set_amp_gain_put),
  427. SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
  428. RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
  429. RT700_DIR_IN_SFT, 1, 1,
  430. rt700_set_amp_gain_get, rt700_set_amp_gain_put),
  431. SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
  432. RT700_SET_GAIN_ADC2_H, RT700_SET_GAIN_ADC2_L,
  433. RT700_DIR_IN_SFT, 0x3f, 0,
  434. rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
  435. SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
  436. RT700_SET_GAIN_ADC1_H, RT700_SET_GAIN_ADC1_L,
  437. RT700_DIR_IN_SFT, 0x3f, 0,
  438. rt700_set_amp_gain_get, rt700_set_amp_gain_put, in_vol_tlv),
  439. SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
  440. RT700_SET_GAIN_AMIC_H, RT700_SET_GAIN_AMIC_L,
  441. RT700_DIR_IN_SFT, 3, 0,
  442. rt700_set_amp_gain_get, rt700_set_amp_gain_put, mic_vol_tlv),
  443. };
  444. static int rt700_mux_get(struct snd_kcontrol *kcontrol,
  445. struct snd_ctl_elem_value *ucontrol)
  446. {
  447. struct snd_soc_component *component =
  448. snd_soc_dapm_kcontrol_component(kcontrol);
  449. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  450. unsigned int reg, val = 0, nid;
  451. int ret;
  452. if (strstr(ucontrol->id.name, "HPO Mux"))
  453. nid = RT700_HP_OUT;
  454. else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  455. nid = RT700_MIXER_IN1;
  456. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  457. nid = RT700_MIXER_IN2;
  458. else
  459. return -EINVAL;
  460. /* vid = 0xf01 */
  461. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  462. ret = regmap_read(rt700->regmap, reg, &val);
  463. if (ret < 0)
  464. return ret;
  465. ucontrol->value.enumerated.item[0] = val;
  466. return 0;
  467. }
  468. static int rt700_mux_put(struct snd_kcontrol *kcontrol,
  469. struct snd_ctl_elem_value *ucontrol)
  470. {
  471. struct snd_soc_component *component =
  472. snd_soc_dapm_kcontrol_component(kcontrol);
  473. struct snd_soc_dapm_context *dapm =
  474. snd_soc_dapm_kcontrol_dapm(kcontrol);
  475. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  476. struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
  477. unsigned int *item = ucontrol->value.enumerated.item;
  478. unsigned int val, val2 = 0, change, reg, nid;
  479. int ret;
  480. if (item[0] >= e->items)
  481. return -EINVAL;
  482. if (strstr(ucontrol->id.name, "HPO Mux"))
  483. nid = RT700_HP_OUT;
  484. else if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  485. nid = RT700_MIXER_IN1;
  486. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  487. nid = RT700_MIXER_IN2;
  488. else
  489. return -EINVAL;
  490. /* Verb ID = 0x701h */
  491. val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
  492. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  493. ret = regmap_read(rt700->regmap, reg, &val2);
  494. if (ret < 0)
  495. return ret;
  496. if (val == val2)
  497. change = 0;
  498. else
  499. change = 1;
  500. if (change) {
  501. reg = RT700_VERB_SET_CONNECT_SEL | nid;
  502. regmap_write(rt700->regmap, reg, val);
  503. }
  504. snd_soc_dapm_mux_update_power(dapm, kcontrol,
  505. item[0], e, NULL);
  506. return change;
  507. }
  508. static const char * const adc_mux_text[] = {
  509. "MIC2",
  510. "LINE1",
  511. "LINE2",
  512. "DMIC",
  513. };
  514. static SOC_ENUM_SINGLE_DECL(
  515. rt700_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
  516. static SOC_ENUM_SINGLE_DECL(
  517. rt700_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
  518. static const struct snd_kcontrol_new rt700_adc22_mux =
  519. SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt700_adc22_enum,
  520. rt700_mux_get, rt700_mux_put);
  521. static const struct snd_kcontrol_new rt700_adc23_mux =
  522. SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt700_adc23_enum,
  523. rt700_mux_get, rt700_mux_put);
  524. static const char * const out_mux_text[] = {
  525. "Front",
  526. "Surround",
  527. };
  528. static SOC_ENUM_SINGLE_DECL(
  529. rt700_hp_enum, SND_SOC_NOPM, 0, out_mux_text);
  530. static const struct snd_kcontrol_new rt700_hp_mux =
  531. SOC_DAPM_ENUM_EXT("HP Mux", rt700_hp_enum,
  532. rt700_mux_get, rt700_mux_put);
  533. static int rt700_dac_front_event(struct snd_soc_dapm_widget *w,
  534. struct snd_kcontrol *kcontrol, int event)
  535. {
  536. struct snd_soc_component *component =
  537. snd_soc_dapm_to_component(w->dapm);
  538. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  539. switch (event) {
  540. case SND_SOC_DAPM_POST_PMU:
  541. regmap_write(rt700->regmap,
  542. RT700_SET_STREAMID_DAC1, 0x10);
  543. break;
  544. case SND_SOC_DAPM_PRE_PMD:
  545. regmap_write(rt700->regmap,
  546. RT700_SET_STREAMID_DAC1, 0x00);
  547. break;
  548. }
  549. return 0;
  550. }
  551. static int rt700_dac_surround_event(struct snd_soc_dapm_widget *w,
  552. struct snd_kcontrol *kcontrol, int event)
  553. {
  554. struct snd_soc_component *component =
  555. snd_soc_dapm_to_component(w->dapm);
  556. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  557. switch (event) {
  558. case SND_SOC_DAPM_POST_PMU:
  559. regmap_write(rt700->regmap,
  560. RT700_SET_STREAMID_DAC2, 0x10);
  561. break;
  562. case SND_SOC_DAPM_PRE_PMD:
  563. regmap_write(rt700->regmap,
  564. RT700_SET_STREAMID_DAC2, 0x00);
  565. break;
  566. }
  567. return 0;
  568. }
  569. static int rt700_adc_09_event(struct snd_soc_dapm_widget *w,
  570. struct snd_kcontrol *kcontrol, int event)
  571. {
  572. struct snd_soc_component *component =
  573. snd_soc_dapm_to_component(w->dapm);
  574. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  575. switch (event) {
  576. case SND_SOC_DAPM_POST_PMU:
  577. regmap_write(rt700->regmap,
  578. RT700_SET_STREAMID_ADC1, 0x10);
  579. break;
  580. case SND_SOC_DAPM_PRE_PMD:
  581. regmap_write(rt700->regmap,
  582. RT700_SET_STREAMID_ADC1, 0x00);
  583. break;
  584. }
  585. return 0;
  586. }
  587. static int rt700_adc_08_event(struct snd_soc_dapm_widget *w,
  588. struct snd_kcontrol *kcontrol, int event)
  589. {
  590. struct snd_soc_component *component =
  591. snd_soc_dapm_to_component(w->dapm);
  592. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  593. switch (event) {
  594. case SND_SOC_DAPM_POST_PMU:
  595. regmap_write(rt700->regmap,
  596. RT700_SET_STREAMID_ADC2, 0x10);
  597. break;
  598. case SND_SOC_DAPM_PRE_PMD:
  599. regmap_write(rt700->regmap,
  600. RT700_SET_STREAMID_ADC2, 0x00);
  601. break;
  602. }
  603. return 0;
  604. }
  605. static int rt700_hpo_mux_event(struct snd_soc_dapm_widget *w,
  606. struct snd_kcontrol *kcontrol, int event)
  607. {
  608. struct snd_soc_component *component =
  609. snd_soc_dapm_to_component(w->dapm);
  610. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  611. unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
  612. unsigned int val_l;
  613. switch (event) {
  614. case SND_SOC_DAPM_POST_PMU:
  615. val_l = 0x00;
  616. regmap_write(rt700->regmap,
  617. RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
  618. break;
  619. case SND_SOC_DAPM_PRE_PMD:
  620. val_l = (1 << RT700_MUTE_SFT);
  621. regmap_write(rt700->regmap,
  622. RT700_SET_GAIN_HP_H, (val_h << 8 | val_l));
  623. usleep_range(50000, 55000);
  624. break;
  625. }
  626. return 0;
  627. }
  628. static int rt700_spk_pga_event(struct snd_soc_dapm_widget *w,
  629. struct snd_kcontrol *kcontrol, int event)
  630. {
  631. struct snd_soc_component *component =
  632. snd_soc_dapm_to_component(w->dapm);
  633. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  634. unsigned int val_h = (1 << RT700_DIR_OUT_SFT) | (0x3 << 4);
  635. unsigned int val_l;
  636. switch (event) {
  637. case SND_SOC_DAPM_POST_PMU:
  638. val_l = 0x00;
  639. regmap_write(rt700->regmap,
  640. RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
  641. break;
  642. case SND_SOC_DAPM_PRE_PMD:
  643. val_l = (1 << RT700_MUTE_SFT);
  644. regmap_write(rt700->regmap,
  645. RT700_SET_GAIN_SPK_H, (val_h << 8 | val_l));
  646. break;
  647. }
  648. return 0;
  649. }
  650. static const struct snd_soc_dapm_widget rt700_dapm_widgets[] = {
  651. SND_SOC_DAPM_OUTPUT("HP"),
  652. SND_SOC_DAPM_OUTPUT("SPK"),
  653. SND_SOC_DAPM_INPUT("DMIC1"),
  654. SND_SOC_DAPM_INPUT("DMIC2"),
  655. SND_SOC_DAPM_INPUT("MIC2"),
  656. SND_SOC_DAPM_INPUT("LINE1"),
  657. SND_SOC_DAPM_INPUT("LINE2"),
  658. SND_SOC_DAPM_DAC_E("DAC Front", NULL, SND_SOC_NOPM, 0, 0,
  659. rt700_dac_front_event,
  660. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  661. SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
  662. rt700_dac_surround_event,
  663. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  664. SND_SOC_DAPM_MUX_E("HPO Mux", SND_SOC_NOPM, 0, 0, &rt700_hp_mux,
  665. rt700_hpo_mux_event,
  666. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  667. SND_SOC_DAPM_PGA_E("SPK PGA", SND_SOC_NOPM, 0, 0, NULL, 0,
  668. rt700_spk_pga_event,
  669. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  670. SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
  671. rt700_adc_09_event,
  672. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  673. SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
  674. rt700_adc_08_event,
  675. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  676. SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
  677. &rt700_adc22_mux),
  678. SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
  679. &rt700_adc23_mux),
  680. SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
  681. SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
  682. SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
  683. SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
  684. };
  685. static const struct snd_soc_dapm_route rt700_audio_map[] = {
  686. {"DAC Front", NULL, "DP1RX"},
  687. {"DAC Surround", NULL, "DP3RX"},
  688. {"DP2TX", NULL, "ADC 09"},
  689. {"DP4TX", NULL, "ADC 08"},
  690. {"ADC 09", NULL, "ADC 22 Mux"},
  691. {"ADC 08", NULL, "ADC 23 Mux"},
  692. {"ADC 22 Mux", "DMIC", "DMIC1"},
  693. {"ADC 22 Mux", "LINE1", "LINE1"},
  694. {"ADC 22 Mux", "LINE2", "LINE2"},
  695. {"ADC 22 Mux", "MIC2", "MIC2"},
  696. {"ADC 23 Mux", "DMIC", "DMIC2"},
  697. {"ADC 23 Mux", "LINE1", "LINE1"},
  698. {"ADC 23 Mux", "LINE2", "LINE2"},
  699. {"ADC 23 Mux", "MIC2", "MIC2"},
  700. {"HPO Mux", "Front", "DAC Front"},
  701. {"HPO Mux", "Surround", "DAC Surround"},
  702. {"HP", NULL, "HPO Mux"},
  703. {"SPK PGA", NULL, "DAC Front"},
  704. {"SPK", NULL, "SPK PGA"},
  705. };
  706. static int rt700_probe(struct snd_soc_component *component)
  707. {
  708. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  709. int ret;
  710. rt700->component = component;
  711. ret = pm_runtime_resume(component->dev);
  712. if (ret < 0 && ret != -EACCES)
  713. return ret;
  714. return 0;
  715. }
  716. static int rt700_set_bias_level(struct snd_soc_component *component,
  717. enum snd_soc_bias_level level)
  718. {
  719. struct snd_soc_dapm_context *dapm =
  720. snd_soc_component_get_dapm(component);
  721. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  722. switch (level) {
  723. case SND_SOC_BIAS_PREPARE:
  724. if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
  725. regmap_write(rt700->regmap,
  726. RT700_SET_AUDIO_POWER_STATE,
  727. AC_PWRST_D0);
  728. }
  729. break;
  730. case SND_SOC_BIAS_STANDBY:
  731. regmap_write(rt700->regmap,
  732. RT700_SET_AUDIO_POWER_STATE,
  733. AC_PWRST_D3);
  734. break;
  735. default:
  736. break;
  737. }
  738. dapm->bias_level = level;
  739. return 0;
  740. }
  741. static const struct snd_soc_component_driver soc_codec_dev_rt700 = {
  742. .probe = rt700_probe,
  743. .set_bias_level = rt700_set_bias_level,
  744. .controls = rt700_snd_controls,
  745. .num_controls = ARRAY_SIZE(rt700_snd_controls),
  746. .dapm_widgets = rt700_dapm_widgets,
  747. .num_dapm_widgets = ARRAY_SIZE(rt700_dapm_widgets),
  748. .dapm_routes = rt700_audio_map,
  749. .num_dapm_routes = ARRAY_SIZE(rt700_audio_map),
  750. .set_jack = rt700_set_jack_detect,
  751. .endianness = 1,
  752. };
  753. static int rt700_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
  754. int direction)
  755. {
  756. struct sdw_stream_data *stream;
  757. if (!sdw_stream)
  758. return 0;
  759. stream = kzalloc(sizeof(*stream), GFP_KERNEL);
  760. if (!stream)
  761. return -ENOMEM;
  762. stream->sdw_stream = sdw_stream;
  763. /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
  764. if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  765. dai->playback_dma_data = stream;
  766. else
  767. dai->capture_dma_data = stream;
  768. return 0;
  769. }
  770. static void rt700_shutdown(struct snd_pcm_substream *substream,
  771. struct snd_soc_dai *dai)
  772. {
  773. struct sdw_stream_data *stream;
  774. stream = snd_soc_dai_get_dma_data(dai, substream);
  775. snd_soc_dai_set_dma_data(dai, substream, NULL);
  776. kfree(stream);
  777. }
  778. static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
  779. struct snd_pcm_hw_params *params,
  780. struct snd_soc_dai *dai)
  781. {
  782. struct snd_soc_component *component = dai->component;
  783. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  784. struct sdw_stream_config stream_config;
  785. struct sdw_port_config port_config;
  786. enum sdw_data_direction direction;
  787. struct sdw_stream_data *stream;
  788. int retval, port, num_channels;
  789. unsigned int val = 0;
  790. dev_dbg(dai->dev, "%s %s", __func__, dai->name);
  791. stream = snd_soc_dai_get_dma_data(dai, substream);
  792. if (!stream)
  793. return -EINVAL;
  794. if (!rt700->slave)
  795. return -EINVAL;
  796. /* SoundWire specific configuration */
  797. /* This code assumes port 1 for playback and port 2 for capture */
  798. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  799. direction = SDW_DATA_DIR_RX;
  800. port = 1;
  801. } else {
  802. direction = SDW_DATA_DIR_TX;
  803. port = 2;
  804. }
  805. switch (dai->id) {
  806. case RT700_AIF1:
  807. break;
  808. case RT700_AIF2:
  809. port += 2;
  810. break;
  811. default:
  812. dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
  813. return -EINVAL;
  814. }
  815. stream_config.frame_rate = params_rate(params);
  816. stream_config.ch_count = params_channels(params);
  817. stream_config.bps = snd_pcm_format_width(params_format(params));
  818. stream_config.direction = direction;
  819. num_channels = params_channels(params);
  820. port_config.ch_mask = (1 << (num_channels)) - 1;
  821. port_config.num = port;
  822. retval = sdw_stream_add_slave(rt700->slave, &stream_config,
  823. &port_config, 1, stream->sdw_stream);
  824. if (retval) {
  825. dev_err(dai->dev, "Unable to configure port\n");
  826. return retval;
  827. }
  828. if (params_channels(params) <= 16) {
  829. /* bit 3:0 Number of Channel */
  830. val |= (params_channels(params) - 1);
  831. } else {
  832. dev_err(component->dev, "Unsupported channels %d\n",
  833. params_channels(params));
  834. return -EINVAL;
  835. }
  836. switch (params_width(params)) {
  837. /* bit 6:4 Bits per Sample */
  838. case 8:
  839. break;
  840. case 16:
  841. val |= (0x1 << 4);
  842. break;
  843. case 20:
  844. val |= (0x2 << 4);
  845. break;
  846. case 24:
  847. val |= (0x3 << 4);
  848. break;
  849. case 32:
  850. val |= (0x4 << 4);
  851. break;
  852. default:
  853. return -EINVAL;
  854. }
  855. /* 48Khz */
  856. regmap_write(rt700->regmap, RT700_DAC_FORMAT_H, val);
  857. regmap_write(rt700->regmap, RT700_ADC_FORMAT_H, val);
  858. return retval;
  859. }
  860. static int rt700_pcm_hw_free(struct snd_pcm_substream *substream,
  861. struct snd_soc_dai *dai)
  862. {
  863. struct snd_soc_component *component = dai->component;
  864. struct rt700_priv *rt700 = snd_soc_component_get_drvdata(component);
  865. struct sdw_stream_data *stream =
  866. snd_soc_dai_get_dma_data(dai, substream);
  867. if (!rt700->slave)
  868. return -EINVAL;
  869. sdw_stream_remove_slave(rt700->slave, stream->sdw_stream);
  870. return 0;
  871. }
  872. #define RT700_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
  873. #define RT700_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
  874. SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
  875. static const struct snd_soc_dai_ops rt700_ops = {
  876. .hw_params = rt700_pcm_hw_params,
  877. .hw_free = rt700_pcm_hw_free,
  878. .set_stream = rt700_set_sdw_stream,
  879. .shutdown = rt700_shutdown,
  880. };
  881. static struct snd_soc_dai_driver rt700_dai[] = {
  882. {
  883. .name = "rt700-aif1",
  884. .id = RT700_AIF1,
  885. .playback = {
  886. .stream_name = "DP1 Playback",
  887. .channels_min = 1,
  888. .channels_max = 2,
  889. .rates = RT700_STEREO_RATES,
  890. .formats = RT700_FORMATS,
  891. },
  892. .capture = {
  893. .stream_name = "DP2 Capture",
  894. .channels_min = 1,
  895. .channels_max = 2,
  896. .rates = RT700_STEREO_RATES,
  897. .formats = RT700_FORMATS,
  898. },
  899. .ops = &rt700_ops,
  900. },
  901. {
  902. .name = "rt700-aif2",
  903. .id = RT700_AIF2,
  904. .playback = {
  905. .stream_name = "DP3 Playback",
  906. .channels_min = 1,
  907. .channels_max = 2,
  908. .rates = RT700_STEREO_RATES,
  909. .formats = RT700_FORMATS,
  910. },
  911. .capture = {
  912. .stream_name = "DP4 Capture",
  913. .channels_min = 1,
  914. .channels_max = 2,
  915. .rates = RT700_STEREO_RATES,
  916. .formats = RT700_FORMATS,
  917. },
  918. .ops = &rt700_ops,
  919. },
  920. };
  921. /* Bus clock frequency */
  922. #define RT700_CLK_FREQ_9600000HZ 9600000
  923. #define RT700_CLK_FREQ_12000000HZ 12000000
  924. #define RT700_CLK_FREQ_6000000HZ 6000000
  925. #define RT700_CLK_FREQ_4800000HZ 4800000
  926. #define RT700_CLK_FREQ_2400000HZ 2400000
  927. #define RT700_CLK_FREQ_12288000HZ 12288000
  928. int rt700_clock_config(struct device *dev)
  929. {
  930. struct rt700_priv *rt700 = dev_get_drvdata(dev);
  931. unsigned int clk_freq, value;
  932. clk_freq = (rt700->params.curr_dr_freq >> 1);
  933. switch (clk_freq) {
  934. case RT700_CLK_FREQ_12000000HZ:
  935. value = 0x0;
  936. break;
  937. case RT700_CLK_FREQ_6000000HZ:
  938. value = 0x1;
  939. break;
  940. case RT700_CLK_FREQ_9600000HZ:
  941. value = 0x2;
  942. break;
  943. case RT700_CLK_FREQ_4800000HZ:
  944. value = 0x3;
  945. break;
  946. case RT700_CLK_FREQ_2400000HZ:
  947. value = 0x4;
  948. break;
  949. case RT700_CLK_FREQ_12288000HZ:
  950. value = 0x5;
  951. break;
  952. default:
  953. return -EINVAL;
  954. }
  955. regmap_write(rt700->regmap, 0xe0, value);
  956. regmap_write(rt700->regmap, 0xf0, value);
  957. dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
  958. return 0;
  959. }
  960. int rt700_init(struct device *dev, struct regmap *sdw_regmap,
  961. struct regmap *regmap, struct sdw_slave *slave)
  962. {
  963. struct rt700_priv *rt700;
  964. int ret;
  965. rt700 = devm_kzalloc(dev, sizeof(*rt700), GFP_KERNEL);
  966. if (!rt700)
  967. return -ENOMEM;
  968. dev_set_drvdata(dev, rt700);
  969. rt700->slave = slave;
  970. rt700->sdw_regmap = sdw_regmap;
  971. rt700->regmap = regmap;
  972. mutex_init(&rt700->disable_irq_lock);
  973. INIT_DELAYED_WORK(&rt700->jack_detect_work,
  974. rt700_jack_detect_handler);
  975. INIT_DELAYED_WORK(&rt700->jack_btn_check_work,
  976. rt700_btn_check_handler);
  977. /*
  978. * Mark hw_init to false
  979. * HW init will be performed when device reports present
  980. */
  981. rt700->hw_init = false;
  982. rt700->first_hw_init = false;
  983. ret = devm_snd_soc_register_component(dev,
  984. &soc_codec_dev_rt700,
  985. rt700_dai,
  986. ARRAY_SIZE(rt700_dai));
  987. dev_dbg(&slave->dev, "%s\n", __func__);
  988. return ret;
  989. }
  990. int rt700_io_init(struct device *dev, struct sdw_slave *slave)
  991. {
  992. struct rt700_priv *rt700 = dev_get_drvdata(dev);
  993. rt700->disable_irq = false;
  994. if (rt700->hw_init)
  995. return 0;
  996. if (rt700->first_hw_init) {
  997. regcache_cache_only(rt700->regmap, false);
  998. regcache_cache_bypass(rt700->regmap, true);
  999. }
  1000. /*
  1001. * PM runtime is only enabled when a Slave reports as Attached
  1002. */
  1003. if (!rt700->first_hw_init) {
  1004. /* set autosuspend parameters */
  1005. pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
  1006. pm_runtime_use_autosuspend(&slave->dev);
  1007. /* update count of parent 'active' children */
  1008. pm_runtime_set_active(&slave->dev);
  1009. /* make sure the device does not suspend immediately */
  1010. pm_runtime_mark_last_busy(&slave->dev);
  1011. pm_runtime_enable(&slave->dev);
  1012. }
  1013. pm_runtime_get_noresume(&slave->dev);
  1014. /* reset */
  1015. regmap_write(rt700->regmap, 0xff01, 0x0000);
  1016. regmap_write(rt700->regmap, 0x7520, 0x001a);
  1017. regmap_write(rt700->regmap, 0x7420, 0xc003);
  1018. /* power on */
  1019. regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  1020. /* Set Pin Widget */
  1021. regmap_write(rt700->regmap, RT700_SET_PIN_HP, 0x40);
  1022. regmap_write(rt700->regmap, RT700_SET_PIN_SPK, 0x40);
  1023. regmap_write(rt700->regmap, RT700_SET_EAPD_SPK, RT700_EAPD_HIGH);
  1024. regmap_write(rt700->regmap, RT700_SET_PIN_DMIC1, 0x20);
  1025. regmap_write(rt700->regmap, RT700_SET_PIN_DMIC2, 0x20);
  1026. regmap_write(rt700->regmap, RT700_SET_PIN_MIC2, 0x20);
  1027. /* Set Configuration Default */
  1028. regmap_write(rt700->regmap, 0x4f12, 0x91);
  1029. regmap_write(rt700->regmap, 0x4e12, 0xd6);
  1030. regmap_write(rt700->regmap, 0x4d12, 0x11);
  1031. regmap_write(rt700->regmap, 0x4c12, 0x20);
  1032. regmap_write(rt700->regmap, 0x4f13, 0x91);
  1033. regmap_write(rt700->regmap, 0x4e13, 0xd6);
  1034. regmap_write(rt700->regmap, 0x4d13, 0x11);
  1035. regmap_write(rt700->regmap, 0x4c13, 0x21);
  1036. regmap_write(rt700->regmap, 0x4f19, 0x02);
  1037. regmap_write(rt700->regmap, 0x4e19, 0xa1);
  1038. regmap_write(rt700->regmap, 0x4d19, 0x90);
  1039. regmap_write(rt700->regmap, 0x4c19, 0x80);
  1040. /* Enable Line2 */
  1041. regmap_write(rt700->regmap, 0x371b, 0x40);
  1042. regmap_write(rt700->regmap, 0x731b, 0xb0);
  1043. regmap_write(rt700->regmap, 0x839b, 0x00);
  1044. /* Set index */
  1045. rt700_index_write(rt700->regmap, 0x4a, 0x201b);
  1046. rt700_index_write(rt700->regmap, 0x45, 0x5089);
  1047. rt700_index_write(rt700->regmap, 0x6b, 0x5064);
  1048. rt700_index_write(rt700->regmap, 0x48, 0xd249);
  1049. /* Finish Initial Settings, set power to D3 */
  1050. regmap_write(rt700->regmap, RT700_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  1051. /*
  1052. * if set_jack callback occurred early than io_init,
  1053. * we set up the jack detection function now
  1054. */
  1055. if (rt700->hs_jack)
  1056. rt700_jack_init(rt700);
  1057. if (rt700->first_hw_init) {
  1058. regcache_cache_bypass(rt700->regmap, false);
  1059. regcache_mark_dirty(rt700->regmap);
  1060. } else
  1061. rt700->first_hw_init = true;
  1062. /* Mark Slave initialization complete */
  1063. rt700->hw_init = true;
  1064. pm_runtime_mark_last_busy(&slave->dev);
  1065. pm_runtime_put_autosuspend(&slave->dev);
  1066. dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
  1067. return 0;
  1068. }
  1069. MODULE_DESCRIPTION("ASoC RT700 driver SDW");
  1070. MODULE_AUTHOR("Shuming Fan <[email protected]>");
  1071. MODULE_LICENSE("GPL v2");