rt711.c 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // rt711.c -- rt711 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 "rt711.h"
  28. static int rt711_index_write(struct regmap *regmap,
  29. unsigned int nid, unsigned int reg, unsigned int value)
  30. {
  31. int ret;
  32. unsigned int addr = ((RT711_PRIV_INDEX_W_H | nid) << 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 rt711_index_read(struct regmap *regmap,
  40. unsigned int nid, unsigned int reg, unsigned int *value)
  41. {
  42. int ret;
  43. unsigned int addr = ((RT711_PRIV_INDEX_W_H | nid) << 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 int rt711_index_update_bits(struct regmap *regmap, unsigned int nid,
  52. unsigned int reg, unsigned int mask, unsigned int val)
  53. {
  54. unsigned int tmp, orig;
  55. int ret;
  56. ret = rt711_index_read(regmap, nid, reg, &orig);
  57. if (ret < 0)
  58. return ret;
  59. tmp = orig & ~mask;
  60. tmp |= val & mask;
  61. return rt711_index_write(regmap, nid, reg, tmp);
  62. }
  63. static void rt711_reset(struct regmap *regmap)
  64. {
  65. regmap_write(regmap, RT711_FUNC_RESET, 0);
  66. rt711_index_update_bits(regmap, RT711_VENDOR_REG,
  67. RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET,
  68. RT711_HIDDEN_REG_SW_RESET);
  69. }
  70. static int rt711_calibration(struct rt711_priv *rt711)
  71. {
  72. unsigned int val, loop = 0;
  73. struct device *dev;
  74. struct regmap *regmap = rt711->regmap;
  75. int ret = 0;
  76. mutex_lock(&rt711->calibrate_mutex);
  77. regmap_write(rt711->regmap,
  78. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  79. dev = regmap_get_device(regmap);
  80. /* Calibration manual mode */
  81. rt711_index_update_bits(regmap, RT711_VENDOR_REG, RT711_FSM_CTL,
  82. 0xf, 0x0);
  83. /* trigger */
  84. rt711_index_update_bits(regmap, RT711_VENDOR_CALI,
  85. RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER,
  86. RT711_DAC_DC_CALI_TRIGGER);
  87. /* wait for calibration process */
  88. rt711_index_read(regmap, RT711_VENDOR_CALI,
  89. RT711_DAC_DC_CALI_CTL1, &val);
  90. while (val & RT711_DAC_DC_CALI_TRIGGER) {
  91. if (loop >= 500) {
  92. pr_err("%s, calibration time-out!\n",
  93. __func__);
  94. ret = -ETIMEDOUT;
  95. break;
  96. }
  97. loop++;
  98. usleep_range(10000, 11000);
  99. rt711_index_read(regmap, RT711_VENDOR_CALI,
  100. RT711_DAC_DC_CALI_CTL1, &val);
  101. }
  102. /* depop mode */
  103. rt711_index_update_bits(regmap, RT711_VENDOR_REG,
  104. RT711_FSM_CTL, 0xf, RT711_DEPOP_CTL);
  105. regmap_write(rt711->regmap,
  106. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  107. mutex_unlock(&rt711->calibrate_mutex);
  108. dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
  109. return ret;
  110. }
  111. static unsigned int rt711_button_detect(struct rt711_priv *rt711)
  112. {
  113. unsigned int btn_type = 0, val80, val81;
  114. int ret;
  115. ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
  116. RT711_IRQ_FLAG_TABLE1, &val80);
  117. if (ret < 0)
  118. goto read_error;
  119. ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
  120. RT711_IRQ_FLAG_TABLE2, &val81);
  121. if (ret < 0)
  122. goto read_error;
  123. val80 &= 0x0381;
  124. val81 &= 0xff00;
  125. switch (val80) {
  126. case 0x0200:
  127. case 0x0100:
  128. case 0x0080:
  129. btn_type |= SND_JACK_BTN_0;
  130. break;
  131. case 0x0001:
  132. btn_type |= SND_JACK_BTN_3;
  133. break;
  134. }
  135. switch (val81) {
  136. case 0x8000:
  137. case 0x4000:
  138. case 0x2000:
  139. btn_type |= SND_JACK_BTN_1;
  140. break;
  141. case 0x1000:
  142. case 0x0800:
  143. case 0x0400:
  144. btn_type |= SND_JACK_BTN_2;
  145. break;
  146. case 0x0200:
  147. case 0x0100:
  148. btn_type |= SND_JACK_BTN_3;
  149. break;
  150. }
  151. read_error:
  152. return btn_type;
  153. }
  154. static int rt711_headset_detect(struct rt711_priv *rt711)
  155. {
  156. unsigned int buf, loop = 0;
  157. int ret;
  158. unsigned int jack_status = 0, reg;
  159. ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
  160. RT711_COMBO_JACK_AUTO_CTL2, &buf);
  161. if (ret < 0)
  162. goto io_error;
  163. while (loop < 500 &&
  164. (buf & RT711_COMBOJACK_AUTO_DET_STATUS) == 0) {
  165. loop++;
  166. usleep_range(9000, 10000);
  167. ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
  168. RT711_COMBO_JACK_AUTO_CTL2, &buf);
  169. if (ret < 0)
  170. goto io_error;
  171. reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
  172. ret = regmap_read(rt711->regmap, reg, &jack_status);
  173. if (ret < 0)
  174. goto io_error;
  175. if ((jack_status & (1 << 31)) == 0)
  176. goto remove_error;
  177. }
  178. if (loop >= 500)
  179. goto to_error;
  180. if (buf & RT711_COMBOJACK_AUTO_DET_TRS)
  181. rt711->jack_type = SND_JACK_HEADPHONE;
  182. else if ((buf & RT711_COMBOJACK_AUTO_DET_CTIA) ||
  183. (buf & RT711_COMBOJACK_AUTO_DET_OMTP))
  184. rt711->jack_type = SND_JACK_HEADSET;
  185. return 0;
  186. to_error:
  187. ret = -ETIMEDOUT;
  188. pr_err_ratelimited("Time-out error in %s\n", __func__);
  189. return ret;
  190. io_error:
  191. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  192. return ret;
  193. remove_error:
  194. pr_err_ratelimited("Jack removal in %s\n", __func__);
  195. return -ENODEV;
  196. }
  197. static void rt711_jack_detect_handler(struct work_struct *work)
  198. {
  199. struct rt711_priv *rt711 =
  200. container_of(work, struct rt711_priv, jack_detect_work.work);
  201. int btn_type = 0, ret;
  202. unsigned int jack_status = 0, reg;
  203. if (!rt711->hs_jack)
  204. return;
  205. if (!rt711->component->card->instantiated)
  206. return;
  207. reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
  208. ret = regmap_read(rt711->regmap, reg, &jack_status);
  209. if (ret < 0)
  210. goto io_error;
  211. /* pin attached */
  212. if (jack_status & (1 << 31)) {
  213. /* jack in */
  214. if (rt711->jack_type == 0) {
  215. ret = rt711_headset_detect(rt711);
  216. if (ret < 0)
  217. return;
  218. if (rt711->jack_type == SND_JACK_HEADSET)
  219. btn_type = rt711_button_detect(rt711);
  220. } else if (rt711->jack_type == SND_JACK_HEADSET) {
  221. /* jack is already in, report button event */
  222. btn_type = rt711_button_detect(rt711);
  223. }
  224. } else {
  225. /* jack out */
  226. rt711->jack_type = 0;
  227. }
  228. dev_dbg(&rt711->slave->dev,
  229. "in %s, jack_type=0x%x\n", __func__, rt711->jack_type);
  230. dev_dbg(&rt711->slave->dev,
  231. "in %s, btn_type=0x%x\n", __func__, btn_type);
  232. snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
  233. SND_JACK_HEADSET |
  234. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  235. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  236. if (btn_type) {
  237. /* button released */
  238. snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
  239. SND_JACK_HEADSET |
  240. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  241. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  242. mod_delayed_work(system_power_efficient_wq,
  243. &rt711->jack_btn_check_work, msecs_to_jiffies(200));
  244. }
  245. return;
  246. io_error:
  247. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  248. }
  249. static void rt711_btn_check_handler(struct work_struct *work)
  250. {
  251. struct rt711_priv *rt711 = container_of(work, struct rt711_priv,
  252. jack_btn_check_work.work);
  253. int btn_type = 0, ret;
  254. unsigned int jack_status = 0, reg;
  255. reg = RT711_VERB_GET_PIN_SENSE | RT711_HP_OUT;
  256. ret = regmap_read(rt711->regmap, reg, &jack_status);
  257. if (ret < 0)
  258. goto io_error;
  259. /* pin attached */
  260. if (jack_status & (1 << 31)) {
  261. if (rt711->jack_type == SND_JACK_HEADSET) {
  262. /* jack is already in, report button event */
  263. btn_type = rt711_button_detect(rt711);
  264. }
  265. } else {
  266. rt711->jack_type = 0;
  267. }
  268. /* cbj comparator */
  269. ret = rt711_index_read(rt711->regmap, RT711_VENDOR_REG,
  270. RT711_COMBO_JACK_AUTO_CTL2, &reg);
  271. if (ret < 0)
  272. goto io_error;
  273. if ((reg & 0xf0) == 0xf0)
  274. btn_type = 0;
  275. dev_dbg(&rt711->slave->dev,
  276. "%s, btn_type=0x%x\n", __func__, btn_type);
  277. snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
  278. SND_JACK_HEADSET |
  279. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  280. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  281. if (btn_type) {
  282. /* button released */
  283. snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
  284. SND_JACK_HEADSET |
  285. SND_JACK_BTN_0 | SND_JACK_BTN_1 |
  286. SND_JACK_BTN_2 | SND_JACK_BTN_3);
  287. mod_delayed_work(system_power_efficient_wq,
  288. &rt711->jack_btn_check_work, msecs_to_jiffies(200));
  289. }
  290. return;
  291. io_error:
  292. pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
  293. }
  294. static void rt711_jack_init(struct rt711_priv *rt711)
  295. {
  296. struct snd_soc_dapm_context *dapm =
  297. snd_soc_component_get_dapm(rt711->component);
  298. mutex_lock(&rt711->calibrate_mutex);
  299. /* power on */
  300. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  301. regmap_write(rt711->regmap,
  302. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  303. if (rt711->hs_jack) {
  304. /* unsolicited response & IRQ control */
  305. regmap_write(rt711->regmap,
  306. RT711_SET_MIC2_UNSOLICITED_ENABLE, 0x82);
  307. regmap_write(rt711->regmap,
  308. RT711_SET_HP_UNSOLICITED_ENABLE, 0x81);
  309. regmap_write(rt711->regmap,
  310. RT711_SET_INLINE_UNSOLICITED_ENABLE, 0x83);
  311. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  312. 0x10, 0x2420);
  313. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  314. 0x19, 0x2e11);
  315. switch (rt711->jd_src) {
  316. case RT711_JD1:
  317. /* default settings was already for JD1 */
  318. break;
  319. case RT711_JD2:
  320. rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
  321. RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP |
  322. RT711_HP_JD_SEL_JD2,
  323. RT711_JD2_2PORT_200K_DECODE_HP |
  324. RT711_HP_JD_SEL_JD2);
  325. rt711_index_update_bits(rt711->regmap, RT711_VENDOR_REG,
  326. RT711_CC_DET1,
  327. RT711_HP_JD_FINAL_RESULT_CTL_JD12,
  328. RT711_HP_JD_FINAL_RESULT_CTL_JD12);
  329. break;
  330. default:
  331. dev_warn(rt711->component->dev, "Wrong JD source\n");
  332. break;
  333. }
  334. dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__);
  335. mod_delayed_work(system_power_efficient_wq,
  336. &rt711->jack_detect_work, msecs_to_jiffies(250));
  337. } else {
  338. regmap_write(rt711->regmap,
  339. RT711_SET_MIC2_UNSOLICITED_ENABLE, 0x00);
  340. regmap_write(rt711->regmap,
  341. RT711_SET_HP_UNSOLICITED_ENABLE, 0x00);
  342. regmap_write(rt711->regmap,
  343. RT711_SET_INLINE_UNSOLICITED_ENABLE, 0x00);
  344. dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__);
  345. }
  346. /* power off */
  347. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  348. regmap_write(rt711->regmap,
  349. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  350. mutex_unlock(&rt711->calibrate_mutex);
  351. }
  352. static int rt711_set_jack_detect(struct snd_soc_component *component,
  353. struct snd_soc_jack *hs_jack, void *data)
  354. {
  355. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  356. rt711->hs_jack = hs_jack;
  357. if (!rt711->hw_init) {
  358. dev_dbg(&rt711->slave->dev,
  359. "%s hw_init not ready yet\n", __func__);
  360. return 0;
  361. }
  362. rt711_jack_init(rt711);
  363. return 0;
  364. }
  365. static void rt711_get_gain(struct rt711_priv *rt711, unsigned int addr_h,
  366. unsigned int addr_l, unsigned int val_h,
  367. unsigned int *r_val, unsigned int *l_val)
  368. {
  369. /* R Channel */
  370. *r_val = (val_h << 8);
  371. regmap_read(rt711->regmap, addr_l, r_val);
  372. /* L Channel */
  373. val_h |= 0x20;
  374. *l_val = (val_h << 8);
  375. regmap_read(rt711->regmap, addr_h, l_val);
  376. }
  377. /* For Verb-Set Amplifier Gain (Verb ID = 3h) */
  378. static int rt711_set_amp_gain_put(struct snd_kcontrol *kcontrol,
  379. struct snd_ctl_elem_value *ucontrol)
  380. {
  381. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  382. struct snd_soc_dapm_context *dapm =
  383. snd_soc_component_get_dapm(component);
  384. struct soc_mixer_control *mc =
  385. (struct soc_mixer_control *)kcontrol->private_value;
  386. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  387. unsigned int addr_h, addr_l, val_h, val_ll, val_lr;
  388. unsigned int read_ll, read_rl;
  389. int i;
  390. mutex_lock(&rt711->calibrate_mutex);
  391. /* Can't use update bit function, so read the original value first */
  392. addr_h = mc->reg;
  393. addr_l = mc->rreg;
  394. if (mc->shift == RT711_DIR_OUT_SFT) /* output */
  395. val_h = 0x80;
  396. else /* input */
  397. val_h = 0x0;
  398. rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll);
  399. /* L Channel */
  400. if (mc->invert) {
  401. /* for mute/unmute */
  402. val_ll = (mc->max - ucontrol->value.integer.value[0])
  403. << RT711_MUTE_SFT;
  404. /* keep gain */
  405. read_ll = read_ll & 0x7f;
  406. val_ll |= read_ll;
  407. } else {
  408. /* for gain */
  409. val_ll = ((ucontrol->value.integer.value[0]) & 0x7f);
  410. if (val_ll > mc->max)
  411. val_ll = mc->max;
  412. /* keep mute status */
  413. read_ll = read_ll & (1 << RT711_MUTE_SFT);
  414. val_ll |= read_ll;
  415. }
  416. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  417. regmap_write(rt711->regmap,
  418. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  419. /* R Channel */
  420. if (mc->invert) {
  421. /* for mute/unmute */
  422. val_lr = (mc->max - ucontrol->value.integer.value[1])
  423. << RT711_MUTE_SFT;
  424. /* keep gain */
  425. read_rl = read_rl & 0x7f;
  426. val_lr |= read_rl;
  427. } else {
  428. /* for gain */
  429. val_lr = ((ucontrol->value.integer.value[1]) & 0x7f);
  430. if (val_lr > mc->max)
  431. val_lr = mc->max;
  432. /* keep mute status */
  433. read_rl = read_rl & (1 << RT711_MUTE_SFT);
  434. val_lr |= read_rl;
  435. }
  436. for (i = 0; i < 3; i++) { /* retry 3 times at most */
  437. if (val_ll == val_lr) {
  438. /* Set both L/R channels at the same time */
  439. val_h = (1 << mc->shift) | (3 << 4);
  440. regmap_write(rt711->regmap,
  441. addr_h, (val_h << 8 | val_ll));
  442. regmap_write(rt711->regmap,
  443. addr_l, (val_h << 8 | val_ll));
  444. } else {
  445. /* Lch*/
  446. val_h = (1 << mc->shift) | (1 << 5);
  447. regmap_write(rt711->regmap,
  448. addr_h, (val_h << 8 | val_ll));
  449. /* Rch */
  450. val_h = (1 << mc->shift) | (1 << 4);
  451. regmap_write(rt711->regmap,
  452. addr_l, (val_h << 8 | val_lr));
  453. }
  454. /* check result */
  455. if (mc->shift == RT711_DIR_OUT_SFT) /* output */
  456. val_h = 0x80;
  457. else /* input */
  458. val_h = 0x0;
  459. rt711_get_gain(rt711, addr_h, addr_l, val_h,
  460. &read_rl, &read_ll);
  461. if (read_rl == val_lr && read_ll == val_ll)
  462. break;
  463. }
  464. if (dapm->bias_level <= SND_SOC_BIAS_STANDBY)
  465. regmap_write(rt711->regmap,
  466. RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  467. mutex_unlock(&rt711->calibrate_mutex);
  468. return 0;
  469. }
  470. static int rt711_set_amp_gain_get(struct snd_kcontrol *kcontrol,
  471. struct snd_ctl_elem_value *ucontrol)
  472. {
  473. struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  474. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  475. struct soc_mixer_control *mc =
  476. (struct soc_mixer_control *)kcontrol->private_value;
  477. unsigned int addr_h, addr_l, val_h;
  478. unsigned int read_ll, read_rl;
  479. /* switch to get command */
  480. addr_h = mc->reg;
  481. addr_l = mc->rreg;
  482. if (mc->shift == RT711_DIR_OUT_SFT) /* output */
  483. val_h = 0x80;
  484. else /* input */
  485. val_h = 0x0;
  486. rt711_get_gain(rt711, addr_h, addr_l, val_h, &read_rl, &read_ll);
  487. if (mc->invert) {
  488. /* mute/unmute for switch controls */
  489. read_ll = !((read_ll & 0x80) >> RT711_MUTE_SFT);
  490. read_rl = !((read_rl & 0x80) >> RT711_MUTE_SFT);
  491. } else {
  492. /* for gain volume controls */
  493. read_ll = read_ll & 0x7f;
  494. read_rl = read_rl & 0x7f;
  495. }
  496. ucontrol->value.integer.value[0] = read_ll;
  497. ucontrol->value.integer.value[1] = read_rl;
  498. return 0;
  499. }
  500. static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
  501. static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
  502. static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
  503. static const struct snd_kcontrol_new rt711_snd_controls[] = {
  504. SOC_DOUBLE_R_EXT_TLV("DAC Surr Playback Volume",
  505. RT711_SET_GAIN_DAC2_H, RT711_SET_GAIN_DAC2_L,
  506. RT711_DIR_OUT_SFT, 0x57, 0,
  507. rt711_set_amp_gain_get, rt711_set_amp_gain_put, out_vol_tlv),
  508. SOC_DOUBLE_R_EXT("ADC 08 Capture Switch",
  509. RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L,
  510. RT711_DIR_IN_SFT, 1, 1,
  511. rt711_set_amp_gain_get, rt711_set_amp_gain_put),
  512. SOC_DOUBLE_R_EXT("ADC 09 Capture Switch",
  513. RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L,
  514. RT711_DIR_IN_SFT, 1, 1,
  515. rt711_set_amp_gain_get, rt711_set_amp_gain_put),
  516. SOC_DOUBLE_R_EXT_TLV("ADC 08 Capture Volume",
  517. RT711_SET_GAIN_ADC2_H, RT711_SET_GAIN_ADC2_L,
  518. RT711_DIR_IN_SFT, 0x3f, 0,
  519. rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv),
  520. SOC_DOUBLE_R_EXT_TLV("ADC 09 Capture Volume",
  521. RT711_SET_GAIN_ADC1_H, RT711_SET_GAIN_ADC1_L,
  522. RT711_DIR_IN_SFT, 0x3f, 0,
  523. rt711_set_amp_gain_get, rt711_set_amp_gain_put, in_vol_tlv),
  524. SOC_DOUBLE_R_EXT_TLV("AMIC Volume",
  525. RT711_SET_GAIN_AMIC_H, RT711_SET_GAIN_AMIC_L,
  526. RT711_DIR_IN_SFT, 3, 0,
  527. rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
  528. SOC_DOUBLE_R_EXT_TLV("DMIC1 Volume",
  529. RT711_SET_GAIN_DMIC1_H, RT711_SET_GAIN_DMIC1_L,
  530. RT711_DIR_IN_SFT, 3, 0,
  531. rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
  532. SOC_DOUBLE_R_EXT_TLV("DMIC2 Volume",
  533. RT711_SET_GAIN_DMIC2_H, RT711_SET_GAIN_DMIC2_L,
  534. RT711_DIR_IN_SFT, 3, 0,
  535. rt711_set_amp_gain_get, rt711_set_amp_gain_put, mic_vol_tlv),
  536. };
  537. static int rt711_mux_get(struct snd_kcontrol *kcontrol,
  538. struct snd_ctl_elem_value *ucontrol)
  539. {
  540. struct snd_soc_component *component =
  541. snd_soc_dapm_kcontrol_component(kcontrol);
  542. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  543. unsigned int reg, val = 0, nid;
  544. int ret;
  545. if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  546. nid = RT711_MIXER_IN1;
  547. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  548. nid = RT711_MIXER_IN2;
  549. else
  550. return -EINVAL;
  551. /* vid = 0xf01 */
  552. reg = RT711_VERB_SET_CONNECT_SEL | nid;
  553. ret = regmap_read(rt711->regmap, reg, &val);
  554. if (ret < 0) {
  555. dev_err(component->dev, "%s: sdw read failed: %d\n",
  556. __func__, ret);
  557. return ret;
  558. }
  559. ucontrol->value.enumerated.item[0] = val;
  560. return 0;
  561. }
  562. static int rt711_mux_put(struct snd_kcontrol *kcontrol,
  563. struct snd_ctl_elem_value *ucontrol)
  564. {
  565. struct snd_soc_component *component =
  566. snd_soc_dapm_kcontrol_component(kcontrol);
  567. struct snd_soc_dapm_context *dapm =
  568. snd_soc_dapm_kcontrol_dapm(kcontrol);
  569. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  570. struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
  571. unsigned int *item = ucontrol->value.enumerated.item;
  572. unsigned int val, val2 = 0, change, reg, nid;
  573. int ret;
  574. if (item[0] >= e->items)
  575. return -EINVAL;
  576. if (strstr(ucontrol->id.name, "ADC 22 Mux"))
  577. nid = RT711_MIXER_IN1;
  578. else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
  579. nid = RT711_MIXER_IN2;
  580. else
  581. return -EINVAL;
  582. /* Verb ID = 0x701h */
  583. val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
  584. reg = RT711_VERB_SET_CONNECT_SEL | nid;
  585. ret = regmap_read(rt711->regmap, reg, &val2);
  586. if (ret < 0) {
  587. dev_err(component->dev, "%s: sdw read failed: %d\n",
  588. __func__, ret);
  589. return ret;
  590. }
  591. if (val == val2)
  592. change = 0;
  593. else
  594. change = 1;
  595. if (change) {
  596. reg = RT711_VERB_SET_CONNECT_SEL | nid;
  597. regmap_write(rt711->regmap, reg, val);
  598. }
  599. snd_soc_dapm_mux_update_power(dapm, kcontrol,
  600. item[0], e, NULL);
  601. return change;
  602. }
  603. static const char * const adc_mux_text[] = {
  604. "MIC2",
  605. "LINE1",
  606. "LINE2",
  607. "DMIC",
  608. };
  609. static SOC_ENUM_SINGLE_DECL(
  610. rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
  611. static SOC_ENUM_SINGLE_DECL(
  612. rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
  613. static const struct snd_kcontrol_new rt711_adc22_mux =
  614. SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum,
  615. rt711_mux_get, rt711_mux_put);
  616. static const struct snd_kcontrol_new rt711_adc23_mux =
  617. SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum,
  618. rt711_mux_get, rt711_mux_put);
  619. static int rt711_dac_surround_event(struct snd_soc_dapm_widget *w,
  620. struct snd_kcontrol *kcontrol, int event)
  621. {
  622. struct snd_soc_component *component =
  623. snd_soc_dapm_to_component(w->dapm);
  624. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  625. unsigned int val_h = (1 << RT711_DIR_OUT_SFT) | (0x3 << 4);
  626. unsigned int val_l;
  627. switch (event) {
  628. case SND_SOC_DAPM_POST_PMU:
  629. regmap_write(rt711->regmap,
  630. RT711_SET_STREAMID_DAC2, 0x10);
  631. val_l = 0x00;
  632. regmap_write(rt711->regmap,
  633. RT711_SET_GAIN_HP_H, (val_h << 8 | val_l));
  634. break;
  635. case SND_SOC_DAPM_PRE_PMD:
  636. val_l = (1 << RT711_MUTE_SFT);
  637. regmap_write(rt711->regmap,
  638. RT711_SET_GAIN_HP_H, (val_h << 8 | val_l));
  639. usleep_range(50000, 55000);
  640. regmap_write(rt711->regmap,
  641. RT711_SET_STREAMID_DAC2, 0x00);
  642. break;
  643. }
  644. return 0;
  645. }
  646. static int rt711_adc_09_event(struct snd_soc_dapm_widget *w,
  647. struct snd_kcontrol *kcontrol, int event)
  648. {
  649. struct snd_soc_component *component =
  650. snd_soc_dapm_to_component(w->dapm);
  651. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  652. switch (event) {
  653. case SND_SOC_DAPM_POST_PMU:
  654. regmap_write(rt711->regmap,
  655. RT711_SET_STREAMID_ADC1, 0x10);
  656. break;
  657. case SND_SOC_DAPM_PRE_PMD:
  658. regmap_write(rt711->regmap,
  659. RT711_SET_STREAMID_ADC1, 0x00);
  660. break;
  661. }
  662. return 0;
  663. }
  664. static int rt711_adc_08_event(struct snd_soc_dapm_widget *w,
  665. struct snd_kcontrol *kcontrol, int event)
  666. {
  667. struct snd_soc_component *component =
  668. snd_soc_dapm_to_component(w->dapm);
  669. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  670. switch (event) {
  671. case SND_SOC_DAPM_POST_PMU:
  672. regmap_write(rt711->regmap,
  673. RT711_SET_STREAMID_ADC2, 0x10);
  674. break;
  675. case SND_SOC_DAPM_PRE_PMD:
  676. regmap_write(rt711->regmap,
  677. RT711_SET_STREAMID_ADC2, 0x00);
  678. break;
  679. }
  680. return 0;
  681. }
  682. static const struct snd_soc_dapm_widget rt711_dapm_widgets[] = {
  683. SND_SOC_DAPM_OUTPUT("HP"),
  684. SND_SOC_DAPM_INPUT("MIC2"),
  685. SND_SOC_DAPM_INPUT("DMIC1"),
  686. SND_SOC_DAPM_INPUT("DMIC2"),
  687. SND_SOC_DAPM_INPUT("LINE1"),
  688. SND_SOC_DAPM_INPUT("LINE2"),
  689. SND_SOC_DAPM_DAC_E("DAC Surround", NULL, SND_SOC_NOPM, 0, 0,
  690. rt711_dac_surround_event,
  691. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  692. SND_SOC_DAPM_ADC_E("ADC 09", NULL, SND_SOC_NOPM, 0, 0,
  693. rt711_adc_09_event,
  694. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  695. SND_SOC_DAPM_ADC_E("ADC 08", NULL, SND_SOC_NOPM, 0, 0,
  696. rt711_adc_08_event,
  697. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  698. SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
  699. &rt711_adc22_mux),
  700. SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
  701. &rt711_adc23_mux),
  702. SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
  703. SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
  704. SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
  705. };
  706. static const struct snd_soc_dapm_route rt711_audio_map[] = {
  707. {"DAC Surround", NULL, "DP3RX"},
  708. {"DP2TX", NULL, "ADC 09"},
  709. {"DP4TX", NULL, "ADC 08"},
  710. {"ADC 09", NULL, "ADC 22 Mux"},
  711. {"ADC 08", NULL, "ADC 23 Mux"},
  712. {"ADC 22 Mux", "DMIC", "DMIC1"},
  713. {"ADC 22 Mux", "LINE1", "LINE1"},
  714. {"ADC 22 Mux", "LINE2", "LINE2"},
  715. {"ADC 22 Mux", "MIC2", "MIC2"},
  716. {"ADC 23 Mux", "DMIC", "DMIC2"},
  717. {"ADC 23 Mux", "LINE1", "LINE1"},
  718. {"ADC 23 Mux", "LINE2", "LINE2"},
  719. {"ADC 23 Mux", "MIC2", "MIC2"},
  720. {"HP", NULL, "DAC Surround"},
  721. };
  722. static int rt711_set_bias_level(struct snd_soc_component *component,
  723. enum snd_soc_bias_level level)
  724. {
  725. struct snd_soc_dapm_context *dapm =
  726. snd_soc_component_get_dapm(component);
  727. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  728. switch (level) {
  729. case SND_SOC_BIAS_PREPARE:
  730. if (dapm->bias_level == SND_SOC_BIAS_STANDBY) {
  731. regmap_write(rt711->regmap,
  732. RT711_SET_AUDIO_POWER_STATE,
  733. AC_PWRST_D0);
  734. }
  735. break;
  736. case SND_SOC_BIAS_STANDBY:
  737. mutex_lock(&rt711->calibrate_mutex);
  738. regmap_write(rt711->regmap,
  739. RT711_SET_AUDIO_POWER_STATE,
  740. AC_PWRST_D3);
  741. mutex_unlock(&rt711->calibrate_mutex);
  742. break;
  743. default:
  744. break;
  745. }
  746. return 0;
  747. }
  748. static int rt711_parse_dt(struct rt711_priv *rt711, struct device *dev)
  749. {
  750. device_property_read_u32(dev, "realtek,jd-src",
  751. &rt711->jd_src);
  752. return 0;
  753. }
  754. static int rt711_probe(struct snd_soc_component *component)
  755. {
  756. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  757. rt711_parse_dt(rt711, &rt711->slave->dev);
  758. rt711->component = component;
  759. return 0;
  760. }
  761. static void rt711_remove(struct snd_soc_component *component)
  762. {
  763. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  764. regcache_cache_only(rt711->regmap, true);
  765. }
  766. static const struct snd_soc_component_driver soc_codec_dev_rt711 = {
  767. .probe = rt711_probe,
  768. .set_bias_level = rt711_set_bias_level,
  769. .controls = rt711_snd_controls,
  770. .num_controls = ARRAY_SIZE(rt711_snd_controls),
  771. .dapm_widgets = rt711_dapm_widgets,
  772. .num_dapm_widgets = ARRAY_SIZE(rt711_dapm_widgets),
  773. .dapm_routes = rt711_audio_map,
  774. .num_dapm_routes = ARRAY_SIZE(rt711_audio_map),
  775. .set_jack = rt711_set_jack_detect,
  776. .remove = rt711_remove,
  777. };
  778. static int rt711_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
  779. int direction)
  780. {
  781. struct sdw_stream_data *stream;
  782. if (!sdw_stream)
  783. return 0;
  784. stream = kzalloc(sizeof(*stream), GFP_KERNEL);
  785. if (!stream)
  786. return -ENOMEM;
  787. stream->sdw_stream = (struct sdw_stream_runtime *)sdw_stream;
  788. /* Use tx_mask or rx_mask to configure stream tag and set dma_data */
  789. if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  790. dai->playback_dma_data = stream;
  791. else
  792. dai->capture_dma_data = stream;
  793. return 0;
  794. }
  795. static void rt711_shutdown(struct snd_pcm_substream *substream,
  796. struct snd_soc_dai *dai)
  797. {
  798. struct sdw_stream_data *stream;
  799. stream = snd_soc_dai_get_dma_data(dai, substream);
  800. snd_soc_dai_set_dma_data(dai, substream, NULL);
  801. kfree(stream);
  802. }
  803. static int rt711_pcm_hw_params(struct snd_pcm_substream *substream,
  804. struct snd_pcm_hw_params *params,
  805. struct snd_soc_dai *dai)
  806. {
  807. struct snd_soc_component *component = dai->component;
  808. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  809. struct sdw_stream_config stream_config;
  810. struct sdw_port_config port_config;
  811. enum sdw_data_direction direction;
  812. struct sdw_stream_data *stream;
  813. int retval, port, num_channels;
  814. unsigned int val = 0;
  815. dev_dbg(dai->dev, "%s %s", __func__, dai->name);
  816. stream = snd_soc_dai_get_dma_data(dai, substream);
  817. if (!stream)
  818. return -EINVAL;
  819. if (!rt711->slave)
  820. return -EINVAL;
  821. /* SoundWire specific configuration */
  822. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  823. direction = SDW_DATA_DIR_RX;
  824. port = 3;
  825. } else {
  826. direction = SDW_DATA_DIR_TX;
  827. if (dai->id == RT711_AIF1)
  828. port = 4;
  829. else if (dai->id == RT711_AIF2)
  830. port = 2;
  831. else
  832. return -EINVAL;
  833. }
  834. stream_config.frame_rate = params_rate(params);
  835. stream_config.ch_count = params_channels(params);
  836. stream_config.bps = snd_pcm_format_width(params_format(params));
  837. stream_config.direction = direction;
  838. num_channels = params_channels(params);
  839. port_config.ch_mask = (1 << (num_channels)) - 1;
  840. port_config.num = port;
  841. retval = sdw_stream_add_slave(rt711->slave, &stream_config,
  842. &port_config, 1, stream->sdw_stream);
  843. if (retval) {
  844. dev_err(dai->dev, "Unable to configure port\n");
  845. return retval;
  846. }
  847. if (params_channels(params) <= 16) {
  848. /* bit 3:0 Number of Channel */
  849. val |= (params_channels(params) - 1);
  850. } else {
  851. dev_err(component->dev, "Unsupported channels %d\n",
  852. params_channels(params));
  853. return -EINVAL;
  854. }
  855. switch (params_width(params)) {
  856. /* bit 6:4 Bits per Sample */
  857. case 8:
  858. break;
  859. case 16:
  860. val |= (0x1 << 4);
  861. break;
  862. case 20:
  863. val |= (0x2 << 4);
  864. break;
  865. case 24:
  866. val |= (0x3 << 4);
  867. break;
  868. case 32:
  869. val |= (0x4 << 4);
  870. break;
  871. default:
  872. return -EINVAL;
  873. }
  874. /* 48Khz */
  875. regmap_write(rt711->regmap, RT711_DAC_FORMAT_H, val);
  876. regmap_write(rt711->regmap, RT711_ADC1_FORMAT_H, val);
  877. regmap_write(rt711->regmap, RT711_ADC2_FORMAT_H, val);
  878. return retval;
  879. }
  880. static int rt711_pcm_hw_free(struct snd_pcm_substream *substream,
  881. struct snd_soc_dai *dai)
  882. {
  883. struct snd_soc_component *component = dai->component;
  884. struct rt711_priv *rt711 = snd_soc_component_get_drvdata(component);
  885. struct sdw_stream_data *stream =
  886. snd_soc_dai_get_dma_data(dai, substream);
  887. if (!rt711->slave)
  888. return -EINVAL;
  889. sdw_stream_remove_slave(rt711->slave, stream->sdw_stream);
  890. return 0;
  891. }
  892. #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
  893. #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
  894. SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
  895. static struct snd_soc_dai_ops rt711_ops = {
  896. .hw_params = rt711_pcm_hw_params,
  897. .hw_free = rt711_pcm_hw_free,
  898. .set_sdw_stream = rt711_set_sdw_stream,
  899. .shutdown = rt711_shutdown,
  900. };
  901. static struct snd_soc_dai_driver rt711_dai[] = {
  902. {
  903. .name = "rt711-aif1",
  904. .id = RT711_AIF1,
  905. .playback = {
  906. .stream_name = "DP3 Playback",
  907. .channels_min = 1,
  908. .channels_max = 2,
  909. .rates = RT711_STEREO_RATES,
  910. .formats = RT711_FORMATS,
  911. },
  912. .capture = {
  913. .stream_name = "DP4 Capture",
  914. .channels_min = 1,
  915. .channels_max = 2,
  916. .rates = RT711_STEREO_RATES,
  917. .formats = RT711_FORMATS,
  918. },
  919. .ops = &rt711_ops,
  920. },
  921. {
  922. .name = "rt711-aif2",
  923. .id = RT711_AIF2,
  924. .capture = {
  925. .stream_name = "DP2 Capture",
  926. .channels_min = 1,
  927. .channels_max = 2,
  928. .rates = RT711_STEREO_RATES,
  929. .formats = RT711_FORMATS,
  930. },
  931. .ops = &rt711_ops,
  932. }
  933. };
  934. /* Bus clock frequency */
  935. #define RT711_CLK_FREQ_9600000HZ 9600000
  936. #define RT711_CLK_FREQ_12000000HZ 12000000
  937. #define RT711_CLK_FREQ_6000000HZ 6000000
  938. #define RT711_CLK_FREQ_4800000HZ 4800000
  939. #define RT711_CLK_FREQ_2400000HZ 2400000
  940. #define RT711_CLK_FREQ_12288000HZ 12288000
  941. int rt711_clock_config(struct device *dev)
  942. {
  943. struct rt711_priv *rt711 = dev_get_drvdata(dev);
  944. unsigned int clk_freq, value;
  945. clk_freq = (rt711->params.curr_dr_freq >> 1);
  946. switch (clk_freq) {
  947. case RT711_CLK_FREQ_12000000HZ:
  948. value = 0x0;
  949. break;
  950. case RT711_CLK_FREQ_6000000HZ:
  951. value = 0x1;
  952. break;
  953. case RT711_CLK_FREQ_9600000HZ:
  954. value = 0x2;
  955. break;
  956. case RT711_CLK_FREQ_4800000HZ:
  957. value = 0x3;
  958. break;
  959. case RT711_CLK_FREQ_2400000HZ:
  960. value = 0x4;
  961. break;
  962. case RT711_CLK_FREQ_12288000HZ:
  963. value = 0x5;
  964. break;
  965. default:
  966. return -EINVAL;
  967. }
  968. regmap_write(rt711->regmap, 0xe0, value);
  969. regmap_write(rt711->regmap, 0xf0, value);
  970. dev_dbg(dev, "%s complete, clk_freq=%d\n", __func__, clk_freq);
  971. return 0;
  972. }
  973. static void rt711_calibration_work(struct work_struct *work)
  974. {
  975. struct rt711_priv *rt711 =
  976. container_of(work, struct rt711_priv, calibration_work);
  977. rt711_calibration(rt711);
  978. }
  979. int rt711_init(struct device *dev, struct regmap *sdw_regmap,
  980. struct regmap *regmap, struct sdw_slave *slave)
  981. {
  982. struct rt711_priv *rt711;
  983. int ret;
  984. rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL);
  985. if (!rt711)
  986. return -ENOMEM;
  987. dev_set_drvdata(dev, rt711);
  988. rt711->slave = slave;
  989. rt711->sdw_regmap = sdw_regmap;
  990. rt711->regmap = regmap;
  991. /*
  992. * Mark hw_init to false
  993. * HW init will be performed when device reports present
  994. */
  995. rt711->hw_init = false;
  996. rt711->first_hw_init = false;
  997. /* JD source uses JD2 in default */
  998. rt711->jd_src = RT711_JD2;
  999. ret = devm_snd_soc_register_component(dev,
  1000. &soc_codec_dev_rt711,
  1001. rt711_dai,
  1002. ARRAY_SIZE(rt711_dai));
  1003. dev_dbg(&slave->dev, "%s\n", __func__);
  1004. return ret;
  1005. }
  1006. int rt711_io_init(struct device *dev, struct sdw_slave *slave)
  1007. {
  1008. struct rt711_priv *rt711 = dev_get_drvdata(dev);
  1009. if (rt711->hw_init)
  1010. return 0;
  1011. if (rt711->first_hw_init) {
  1012. regcache_cache_only(rt711->regmap, false);
  1013. regcache_cache_bypass(rt711->regmap, true);
  1014. }
  1015. /*
  1016. * PM runtime is only enabled when a Slave reports as Attached
  1017. */
  1018. if (!rt711->first_hw_init) {
  1019. /* set autosuspend parameters */
  1020. pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
  1021. pm_runtime_use_autosuspend(&slave->dev);
  1022. /* update count of parent 'active' children */
  1023. pm_runtime_set_active(&slave->dev);
  1024. /* make sure the device does not suspend immediately */
  1025. pm_runtime_mark_last_busy(&slave->dev);
  1026. pm_runtime_enable(&slave->dev);
  1027. }
  1028. pm_runtime_get_noresume(&slave->dev);
  1029. rt711_reset(rt711->regmap);
  1030. /* power on */
  1031. regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D0);
  1032. /* Set Pin Widget */
  1033. regmap_write(rt711->regmap, RT711_SET_PIN_MIC2, 0x25);
  1034. regmap_write(rt711->regmap, RT711_SET_PIN_HP, 0xc0);
  1035. regmap_write(rt711->regmap, RT711_SET_PIN_DMIC1, 0x20);
  1036. regmap_write(rt711->regmap, RT711_SET_PIN_DMIC2, 0x20);
  1037. regmap_write(rt711->regmap, RT711_SET_PIN_LINE1, 0x20);
  1038. regmap_write(rt711->regmap, RT711_SET_PIN_LINE2, 0x20);
  1039. /* Mute HP/ADC1/ADC2 */
  1040. regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0xa080);
  1041. regmap_write(rt711->regmap, RT711_SET_GAIN_HP_H, 0x9080);
  1042. regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x6080);
  1043. regmap_write(rt711->regmap, RT711_SET_GAIN_ADC2_H, 0x5080);
  1044. regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x6080);
  1045. regmap_write(rt711->regmap, RT711_SET_GAIN_ADC1_H, 0x5080);
  1046. /* Set Configuration Default */
  1047. regmap_write(rt711->regmap, 0x4f12, 0x91);
  1048. regmap_write(rt711->regmap, 0x4e12, 0xd6);
  1049. regmap_write(rt711->regmap, 0x4d12, 0x11);
  1050. regmap_write(rt711->regmap, 0x4c12, 0x20);
  1051. regmap_write(rt711->regmap, 0x4f13, 0x91);
  1052. regmap_write(rt711->regmap, 0x4e13, 0xd6);
  1053. regmap_write(rt711->regmap, 0x4d13, 0x11);
  1054. regmap_write(rt711->regmap, 0x4c13, 0x21);
  1055. regmap_write(rt711->regmap, 0x4c21, 0xf0);
  1056. regmap_write(rt711->regmap, 0x4d21, 0x11);
  1057. regmap_write(rt711->regmap, 0x4e21, 0x11);
  1058. regmap_write(rt711->regmap, 0x4f21, 0x01);
  1059. /* Data port arrangement */
  1060. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  1061. RT711_TX_RX_MUX_CTL, 0x0154);
  1062. /* Set index */
  1063. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  1064. RT711_DIGITAL_MISC_CTRL4, 0x201b);
  1065. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  1066. RT711_COMBO_JACK_AUTO_CTL1, 0x5089);
  1067. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  1068. RT711_VREFOUT_CTL, 0x5064);
  1069. rt711_index_write(rt711->regmap, RT711_VENDOR_REG,
  1070. RT711_INLINE_CMD_CTL, 0xd249);
  1071. /* Finish Initial Settings, set power to D3 */
  1072. regmap_write(rt711->regmap, RT711_SET_AUDIO_POWER_STATE, AC_PWRST_D3);
  1073. if (rt711->first_hw_init)
  1074. rt711_calibration(rt711);
  1075. else {
  1076. INIT_DELAYED_WORK(&rt711->jack_detect_work,
  1077. rt711_jack_detect_handler);
  1078. INIT_DELAYED_WORK(&rt711->jack_btn_check_work,
  1079. rt711_btn_check_handler);
  1080. mutex_init(&rt711->calibrate_mutex);
  1081. INIT_WORK(&rt711->calibration_work, rt711_calibration_work);
  1082. schedule_work(&rt711->calibration_work);
  1083. }
  1084. /*
  1085. * if set_jack callback occurred early than io_init,
  1086. * we set up the jack detection function now
  1087. */
  1088. if (rt711->hs_jack)
  1089. rt711_jack_init(rt711);
  1090. if (rt711->first_hw_init) {
  1091. regcache_cache_bypass(rt711->regmap, false);
  1092. regcache_mark_dirty(rt711->regmap);
  1093. } else
  1094. rt711->first_hw_init = true;
  1095. /* Mark Slave initialization complete */
  1096. rt711->hw_init = true;
  1097. pm_runtime_mark_last_busy(&slave->dev);
  1098. pm_runtime_put_autosuspend(&slave->dev);
  1099. dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
  1100. return 0;
  1101. }
  1102. MODULE_DESCRIPTION("ASoC RT711 SDW driver");
  1103. MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
  1104. MODULE_LICENSE("GPL");