rt711.c 35 KB

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