swr-dmic.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
  4. */
  5. #include <linux/module.h>
  6. #include <linux/init.h>
  7. #include <linux/slab.h>
  8. #include <linux/platform_device.h>
  9. #include <linux/device.h>
  10. #include <linux/printk.h>
  11. #include <linux/bitops.h>
  12. #include <linux/regulator/consumer.h>
  13. #include <linux/pm_runtime.h>
  14. #include <linux/delay.h>
  15. #include <linux/kernel.h>
  16. #include <linux/gpio.h>
  17. #include <linux/of_gpio.h>
  18. #include <linux/of_platform.h>
  19. #include <linux/debugfs.h>
  20. #include <soc/soundwire.h>
  21. #include <sound/pcm.h>
  22. #include <sound/pcm_params.h>
  23. #include <sound/soc.h>
  24. #include <sound/soc-dapm.h>
  25. #include <sound/tlv.h>
  26. #include <asoc/msm-cdc-pinctrl.h>
  27. #include <asoc/msm-cdc-supply.h>
  28. #include <dt-bindings/sound/audio-codec-port-types.h>
  29. #include "wcd938x/wcd938x.h"
  30. #include "swr-dmic.h"
  31. #define NUM_ATTEMPTS 5
  32. #define SWRS_SCP_CONTROL 0x44
  33. #define MAX_NAME_LEN 40
  34. static int swr_master_channel_map[] = {
  35. ZERO,
  36. SWRM_TX1_CH1,
  37. SWRM_TX1_CH2,
  38. SWRM_TX1_CH3,
  39. SWRM_TX1_CH4,
  40. SWRM_TX2_CH1,
  41. SWRM_TX2_CH2,
  42. SWRM_TX2_CH3,
  43. SWRM_TX2_CH4,
  44. SWRM_TX3_CH1,
  45. SWRM_TX3_CH2,
  46. SWRM_TX3_CH3,
  47. SWRM_TX3_CH4,
  48. SWRM_PCM_IN,
  49. };
  50. /*
  51. * Private data Structure for swr-dmic. All parameters related to
  52. * external mic codec needs to be defined here.
  53. */
  54. struct swr_dmic_priv {
  55. struct device *dev;
  56. struct swr_device *swr_slave;
  57. struct snd_soc_component *component;
  58. struct snd_soc_component_driver *driver;
  59. struct snd_soc_dai_driver *dai_driver;
  60. struct snd_soc_component *supply_component;
  61. u32 micb_num;
  62. struct device_node *wcd_handle;
  63. bool is_wcd_supply;
  64. int is_en_supply;
  65. u8 tx_master_port_map[SWR_DMIC_MAX_PORTS];
  66. struct swr_port_params tx_port_params[SWR_UC_MAX][SWR_DMIC_MAX_PORTS];
  67. struct swr_dev_frame_config swr_tx_port_params[SWR_UC_MAX];
  68. struct notifier_block nblock;
  69. };
  70. const char *codec_name_list[] = {
  71. "swr-dmic.01",
  72. "swr-dmic.02",
  73. "swr-dmic.03",
  74. "swr-dmic.04",
  75. };
  76. const char *dai_name_list[] = {
  77. "swr_dmic_tx0",
  78. "swr_dmic_tx1",
  79. "swr_dmic_tx2",
  80. "swr_dmic_tx3",
  81. };
  82. const char *aif_name_list[] = {
  83. "SWR_DMIC_AIF0 Capture",
  84. "SWR_DMIC_AIF1 Capture",
  85. "SWR_DMIC_AIF2 Capture",
  86. "SWR_DMIC_AIF3 Capture",
  87. };
  88. static int swr_dmic_reset(struct swr_device *pdev);
  89. static int swr_dmic_up(struct swr_device *pdev);
  90. static int swr_dmic_down(struct swr_device *pdev);
  91. static int swr_dmic_event_notify(struct notifier_block *block,
  92. unsigned long val,
  93. void *data);
  94. static inline int swr_dmic_tx_get_slave_port_type_idx(const char *wname,
  95. unsigned int *port_idx)
  96. {
  97. u8 port_type;
  98. if (strnstr(wname, "HIFI", strlen(wname)))
  99. port_type = SWR_DMIC_HIFI_PORT;
  100. else if (strnstr(wname, "LP", strlen(wname)))
  101. port_type = SWR_DMIC_LP_PORT;
  102. else
  103. return -EINVAL;
  104. *port_idx = port_type;
  105. return 0;
  106. }
  107. static inline int swr_dmic_get_master_port_val(int port)
  108. {
  109. int i;
  110. for (i = 0; i < ARRAY_SIZE(swr_master_channel_map); i++)
  111. if (port == swr_master_channel_map[i])
  112. return i;
  113. return 0;
  114. }
  115. static int swr_dmic_tx_master_port_get(struct snd_kcontrol *kcontrol,
  116. struct snd_ctl_elem_value *ucontrol)
  117. {
  118. struct snd_soc_component *component =
  119. snd_soc_kcontrol_component(kcontrol);
  120. struct swr_dmic_priv *swr_dmic = snd_soc_component_get_drvdata(component);
  121. int ret = 0;
  122. int slave_port_idx;
  123. ret = swr_dmic_tx_get_slave_port_type_idx(kcontrol->id.name,
  124. &slave_port_idx);
  125. if (ret) {
  126. dev_dbg(component->dev, "%s: invalid port string\n", __func__);
  127. return ret;
  128. }
  129. ucontrol->value.integer.value[0] =
  130. swr_dmic_get_master_port_val(
  131. swr_dmic->tx_master_port_map[slave_port_idx]);
  132. dev_dbg(component->dev, "%s: ucontrol->value.integer.value[0] = %ld\n",
  133. __func__, ucontrol->value.integer.value[0]);
  134. return 0;
  135. }
  136. static int swr_dmic_tx_master_port_put(struct snd_kcontrol *kcontrol,
  137. struct snd_ctl_elem_value *ucontrol)
  138. {
  139. struct snd_soc_component *component =
  140. snd_soc_kcontrol_component(kcontrol);
  141. struct swr_dmic_priv *swr_dmic = snd_soc_component_get_drvdata(component);
  142. int ret = 0;
  143. int slave_port_idx;
  144. ret = swr_dmic_tx_get_slave_port_type_idx(kcontrol->id.name,
  145. &slave_port_idx);
  146. if (ret) {
  147. dev_dbg(component->dev, "%s: invalid port string\n", __func__);
  148. return ret;
  149. }
  150. swr_dmic->tx_master_port_map[slave_port_idx] =
  151. swr_master_channel_map[ucontrol->value.enumerated.item[0]];
  152. dev_dbg(component->dev, "%s: slv port id: %d, master_port_type: %d\n",
  153. __func__, slave_port_idx,
  154. swr_dmic->tx_master_port_map[slave_port_idx]);
  155. return 0;
  156. }
  157. static int swr_dmic_port_enable(struct snd_soc_dapm_widget *w,
  158. struct snd_kcontrol *kcontrol, int event)
  159. {
  160. int ret = 0;
  161. struct snd_soc_component *component =
  162. snd_soc_dapm_to_component(w->dapm);
  163. struct swr_dmic_priv *swr_dmic =
  164. snd_soc_component_get_drvdata(component);
  165. u8 ch_mask = 0x01; /* only DpnChannelEN1 register is available */
  166. u8 num_port = 1;
  167. u8 port_id = w->shift;
  168. u8 port_type = swr_dmic->tx_master_port_map[port_id];
  169. switch (event) {
  170. case SND_SOC_DAPM_POST_PMU:
  171. ret = swr_slvdev_datapath_control(swr_dmic->swr_slave,
  172. swr_dmic->swr_slave->dev_num, true);
  173. break;
  174. case SND_SOC_DAPM_PRE_PMD:
  175. ret = swr_disconnect_port(swr_dmic->swr_slave,
  176. &port_id, num_port, &ch_mask, &port_type);
  177. break;
  178. };
  179. return ret;
  180. }
  181. static int dmic_swr_ctrl(struct snd_soc_dapm_widget *w,
  182. struct snd_kcontrol *kcontrol, int event)
  183. {
  184. int ret = 0;
  185. struct snd_soc_component *component =
  186. snd_soc_dapm_to_component(w->dapm);
  187. struct swr_dmic_priv *swr_dmic =
  188. snd_soc_component_get_drvdata(component);
  189. u8 num_ch = 1;
  190. u8 ch_mask = 0x01; /* only DpnChannelEN1 register is available */
  191. u32 ch_rate = SWR_CLK_RATE_4P8MHZ;
  192. u8 num_port = 1;
  193. u8 port_type = 0;
  194. u8 port_id = w->shift;
  195. if (port_id >= SWR_DMIC_MAX_PORTS)
  196. {
  197. dev_err(component->dev, "%s: invalid port id: %d\n",
  198. __func__, port_id);
  199. return -EINVAL;
  200. }
  201. /*
  202. * Port 1 is high quality / 2.4 or 3.072 Mbps
  203. * Port 2 is listen low power / 0.6 or 0.768 Mbps
  204. */
  205. if (port_id == SWR_DMIC_HIFI_PORT)
  206. ch_rate = SWR_CLK_RATE_2P4MHZ;
  207. else
  208. ch_rate = SWR_CLK_RATE_0P6MHZ;
  209. port_type = swr_dmic->tx_master_port_map[port_id];
  210. dev_dbg(component->dev, "%s port_type: %d event: %d\n", __func__,
  211. port_type, event);
  212. switch (event) {
  213. case SND_SOC_DAPM_PRE_PMU:
  214. ret = swr_connect_port(swr_dmic->swr_slave, &port_id,
  215. num_port, &ch_mask, &ch_rate,
  216. &num_ch, &port_type);
  217. break;
  218. case SND_SOC_DAPM_POST_PMD:
  219. ret = swr_slvdev_datapath_control(swr_dmic->swr_slave,
  220. swr_dmic->swr_slave->dev_num, false);
  221. break;
  222. };
  223. return ret;
  224. }
  225. /* qcom,swr-tx-port-params = <OFFSET1_VAL0 LANE1>, <OFFSET1_VAL5 LANE0>, *UC0*
  226. <OFFSET1_VAL0 LANE1>, <OFFSET1_VAL2 LANE0>, *UC1*
  227. <OFFSET1_VAL1 LANE0>, <OFFSET1_VAL1 LANE0>, *UC2*
  228. <OFFSET1_VAL1 LANE0>, <OFFSET1_VAL1 LANE0>, *UC3 */
  229. static int swr_dmic_parse_port_params(struct device *dev,
  230. char *prop)
  231. {
  232. int i, j;
  233. u32 *dt_array, map_size, max_uc;
  234. int ret = 0;
  235. u32 cnt = 0;
  236. struct swr_port_params (*map)[SWR_UC_MAX][SWR_DMIC_MAX_PORTS];
  237. struct swr_dev_frame_config (*map_uc)[SWR_UC_MAX];
  238. struct swr_dmic_priv *swr_dmic = dev_get_drvdata(dev);
  239. map = &swr_dmic->tx_port_params;
  240. map_uc = &swr_dmic->swr_tx_port_params;
  241. if (!of_find_property(dev->of_node, prop,
  242. &map_size)) {
  243. dev_err(dev, "missing port mapping prop %s\n", prop);
  244. ret = -EINVAL;
  245. goto err_port_map;
  246. }
  247. max_uc = map_size / (SWR_DMIC_MAX_PORTS * SWR_PORT_PARAMS * sizeof(u32));
  248. if (max_uc != SWR_UC_MAX) {
  249. dev_err(dev,
  250. "%s:port params not provided for all usecases\n",
  251. __func__);
  252. ret = -EINVAL;
  253. goto err_port_map;
  254. }
  255. dt_array = kzalloc(map_size, GFP_KERNEL);
  256. if (!dt_array) {
  257. ret = -ENOMEM;
  258. goto err_alloc;
  259. }
  260. ret = of_property_read_u32_array(dev->of_node, prop, dt_array,
  261. SWR_DMIC_MAX_PORTS * SWR_PORT_PARAMS * max_uc);
  262. if (ret) {
  263. dev_err(dev, "%s: Failed to read port mapping from prop %s\n",
  264. __func__, prop);
  265. goto err_pdata_fail;
  266. }
  267. for (i = 0; i < max_uc; i++) {
  268. for (j = 0; j < SWR_DMIC_MAX_PORTS; j++) {
  269. cnt = (i * SWR_DMIC_MAX_PORTS + j) * SWR_PORT_PARAMS;
  270. (*map)[i][j].offset1 = dt_array[cnt];
  271. (*map)[i][j].lane_ctrl = dt_array[cnt + 1];
  272. dev_err(dev, "%s: port %d, uc: %d, offset1:%d, lane: %d\n",
  273. __func__, j, i, dt_array[cnt], dt_array[cnt + 1]);
  274. }
  275. (*map_uc)[i].pp = &(*map)[i][0];
  276. }
  277. kfree(dt_array);
  278. return 0;
  279. err_pdata_fail:
  280. kfree(dt_array);
  281. err_alloc:
  282. err_port_map:
  283. return ret;
  284. }
  285. static const char * const tx_master_port_text[] = {
  286. "ZERO", "SWRM_TX1_CH1", "SWRM_TX1_CH2", "SWRM_TX1_CH3", "SWRM_TX1_CH4",
  287. "SWRM_TX2_CH1", "SWRM_TX2_CH2", "SWRM_TX2_CH3", "SWRM_TX2_CH4",
  288. "SWRM_TX3_CH1", "SWRM_TX3_CH2", "SWRM_TX3_CH3", "SWRM_TX3_CH4",
  289. "SWRM_PCM_IN",
  290. };
  291. static const struct soc_enum tx_master_port_enum =
  292. SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(tx_master_port_text),
  293. tx_master_port_text);
  294. static const struct snd_kcontrol_new swr_dmic_snd_controls[] = {
  295. SOC_ENUM_EXT("HIFI PortMap", tx_master_port_enum,
  296. swr_dmic_tx_master_port_get, swr_dmic_tx_master_port_put),
  297. SOC_ENUM_EXT("LP PortMap", tx_master_port_enum,
  298. swr_dmic_tx_master_port_get, swr_dmic_tx_master_port_put),
  299. };
  300. static const struct snd_kcontrol_new dmic_switch[] = {
  301. SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
  302. };
  303. static const struct snd_kcontrol_new va_dmic_switch[] = {
  304. SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
  305. };
  306. static const struct snd_soc_dapm_widget swr_dmic_dapm_widgets[] = {
  307. SND_SOC_DAPM_MIXER_E("SWR_DMIC_MIXER", SND_SOC_NOPM,
  308. SWR_DMIC_HIFI_PORT, 0,
  309. dmic_switch, ARRAY_SIZE(dmic_switch), dmic_swr_ctrl,
  310. SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
  311. SND_SOC_DAPM_MIXER_E("SWR_DMIC_VA_MIXER", SND_SOC_NOPM,
  312. SWR_DMIC_LP_PORT, 0,
  313. va_dmic_switch, ARRAY_SIZE(va_dmic_switch), dmic_swr_ctrl,
  314. SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
  315. SND_SOC_DAPM_INPUT("SWR_DMIC"),
  316. SND_SOC_DAPM_INPUT("VA_SWR_DMIC"),
  317. SND_SOC_DAPM_OUT_DRV_E("SMIC_PORT_EN", SND_SOC_NOPM,
  318. SWR_DMIC_HIFI_PORT, 0, NULL, 0,
  319. swr_dmic_port_enable,
  320. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  321. SND_SOC_DAPM_OUT_DRV_E("SMIC_VA_PORT_EN", SND_SOC_NOPM,
  322. SWR_DMIC_LP_PORT, 0, NULL, 0,
  323. swr_dmic_port_enable,
  324. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
  325. SND_SOC_DAPM_OUTPUT("SWR_DMIC_OUTPUT"),
  326. SND_SOC_DAPM_OUTPUT("SWR_DMIC_VA_OUTPUT"),
  327. };
  328. static const struct snd_soc_dapm_route swr_dmic_audio_map[] = {
  329. {"SWR_DMIC_MIXER", "Switch", "SWR_DMIC"},
  330. {"SMIC_PORT_EN", NULL, "SWR_DMIC_MIXER"},
  331. {"SWR_DMIC_OUTPUT", NULL, "SMIC_PORT_EN"},
  332. {"SWR_DMIC_VA_MIXER", "Switch", "VA_SWR_DMIC"},
  333. {"SMIC_VA_PORT_EN", NULL, "SWR_DMIC_VA_MIXER"},
  334. {"SWR_DMIC_VA_OUTPUT", NULL, "SMIC_VA_PORT_EN"},
  335. };
  336. static int swr_dmic_codec_probe(struct snd_soc_component *component)
  337. {
  338. struct swr_dmic_priv *swr_dmic =
  339. snd_soc_component_get_drvdata(component);
  340. struct snd_soc_dapm_context *dapm =
  341. snd_soc_component_get_dapm(component);
  342. char w_name[MAX_NAME_LEN];
  343. if (!swr_dmic)
  344. return -EINVAL;
  345. swr_dmic->component = component;
  346. if (!component->name_prefix) {
  347. dev_err(component->dev, "%s: component prefix is NULL\n", __func__);
  348. return -EPROBE_DEFER;
  349. }
  350. memset(w_name, 0, sizeof(w_name));
  351. strlcpy(w_name, component->name_prefix, sizeof(w_name));
  352. strlcat(w_name, " ", sizeof(w_name));
  353. strlcat(w_name, swr_dmic->dai_driver->capture.stream_name,
  354. sizeof(w_name));
  355. snd_soc_dapm_ignore_suspend(dapm, w_name);
  356. memset(w_name, 0, sizeof(w_name));
  357. strlcpy(w_name, component->name_prefix, sizeof(w_name));
  358. strlcat(w_name, " SWR_DMIC", sizeof(w_name));
  359. snd_soc_dapm_ignore_suspend(dapm, w_name);
  360. memset(w_name, 0, sizeof(w_name));
  361. strlcpy(w_name, component->name_prefix, sizeof(w_name));
  362. strlcat(w_name, " SMIC_PORT_EN", sizeof(w_name));
  363. snd_soc_dapm_ignore_suspend(dapm, w_name);
  364. memset(w_name, 0, sizeof(w_name));
  365. strlcpy(w_name, component->name_prefix, sizeof(w_name));
  366. strlcat(w_name, " SWR_DMIC_OUTPUT", sizeof(w_name));
  367. snd_soc_dapm_ignore_suspend(dapm, w_name);
  368. snd_soc_dapm_sync(dapm);
  369. swr_dmic->nblock.notifier_call = swr_dmic_event_notify;
  370. wcd938x_swr_dmic_register_notifier(swr_dmic->supply_component,
  371. &swr_dmic->nblock, true);
  372. return 0;
  373. }
  374. static void swr_dmic_codec_remove(struct snd_soc_component *component)
  375. {
  376. struct swr_dmic_priv *swr_dmic =
  377. snd_soc_component_get_drvdata(component);
  378. swr_dmic->component = NULL;
  379. return;
  380. }
  381. static const struct snd_soc_component_driver soc_codec_dev_swr_dmic = {
  382. .name = NULL,
  383. .probe = swr_dmic_codec_probe,
  384. .remove = swr_dmic_codec_remove,
  385. .controls = swr_dmic_snd_controls,
  386. .num_controls = ARRAY_SIZE(swr_dmic_snd_controls),
  387. .dapm_widgets = swr_dmic_dapm_widgets,
  388. .num_dapm_widgets = ARRAY_SIZE(swr_dmic_dapm_widgets),
  389. .dapm_routes = swr_dmic_audio_map,
  390. .num_dapm_routes = ARRAY_SIZE(swr_dmic_audio_map),
  391. };
  392. static int enable_wcd_codec_supply(struct swr_dmic_priv *swr_dmic, bool enable)
  393. {
  394. int rc = 0;
  395. int micb_num = swr_dmic->micb_num;
  396. struct snd_soc_component *component = swr_dmic->supply_component;
  397. if (!component) {
  398. pr_err("%s: component is NULL\n", __func__);
  399. return -EINVAL;
  400. }
  401. dev_dbg(component->dev, "%s: supply %d micbias: %d enable: %d\n",
  402. __func__, swr_dmic->is_en_supply, micb_num, enable);
  403. if (enable)
  404. rc = wcd938x_codec_force_enable_micbias_v2(component,
  405. SND_SOC_DAPM_PRE_PMU, micb_num);
  406. else
  407. rc = wcd938x_codec_force_enable_micbias_v2(component,
  408. SND_SOC_DAPM_POST_PMD, micb_num);
  409. return rc;
  410. }
  411. static int swr_dmic_parse_supply(struct device_node *np,
  412. struct swr_dmic_priv *swr_dmic)
  413. {
  414. struct platform_device *pdev = NULL;
  415. if (!np || !swr_dmic)
  416. return -EINVAL;
  417. pdev = of_find_device_by_node(np);
  418. if (!pdev)
  419. return -EINVAL;
  420. swr_dmic->supply_component = snd_soc_lookup_component(&pdev->dev, NULL);
  421. return 0;
  422. }
  423. static struct snd_soc_dai_driver swr_dmic_dai[] = {
  424. {
  425. .name = "",
  426. .id = 0,
  427. .capture = {
  428. .stream_name = "",
  429. .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
  430. SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000 |
  431. SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
  432. .formats = (SNDRV_PCM_FMTBIT_S16_LE |
  433. SNDRV_PCM_FMTBIT_S24_LE |
  434. SNDRV_PCM_FMTBIT_S32_LE),
  435. .rate_max = 192000,
  436. .rate_min = 8000,
  437. .channels_min = 1,
  438. .channels_max = 2,
  439. },
  440. },
  441. };
  442. static int swr_dmic_event_notify(struct notifier_block *block,
  443. unsigned long val,
  444. void *data)
  445. {
  446. u16 event = (val & 0xffff);
  447. int ret = 0;
  448. struct swr_dmic_priv *swr_dmic = container_of(block,
  449. struct swr_dmic_priv,
  450. nblock);
  451. switch (event) {
  452. case WCD938X_EVT_SSR_DOWN:
  453. ret = swr_dmic_down(swr_dmic->swr_slave);
  454. break;
  455. case WCD938X_EVT_SSR_UP:
  456. ret = swr_dmic_up(swr_dmic->swr_slave);
  457. if (!ret)
  458. ret = swr_dmic_reset(swr_dmic->swr_slave);
  459. break;
  460. }
  461. return ret;
  462. }
  463. static int swr_dmic_probe(struct swr_device *pdev)
  464. {
  465. int ret = 0;
  466. int i = 0;
  467. u8 swr_devnum = 0;
  468. int dev_index = -1;
  469. char* prefix_name = NULL;
  470. struct swr_dmic_priv *swr_dmic = NULL;
  471. const char *swr_dmic_name_prefix_of = NULL;
  472. const char *swr_dmic_codec_name_of = NULL;
  473. struct snd_soc_component *component = NULL;
  474. int num_retry = NUM_ATTEMPTS;
  475. swr_dmic = devm_kzalloc(&pdev->dev, sizeof(struct swr_dmic_priv),
  476. GFP_KERNEL);
  477. if (!swr_dmic)
  478. return -ENOMEM;
  479. ret = of_property_read_u32(pdev->dev.of_node, "qcom,swr-dmic-supply",
  480. &swr_dmic->micb_num);
  481. if (ret) {
  482. dev_dbg(&pdev->dev, "%s: Looking up %s property in node %s failed\n",
  483. __func__, "qcom,swr-dmic-supply",
  484. pdev->dev.of_node->full_name);
  485. goto err;
  486. }
  487. swr_dmic->wcd_handle = of_parse_phandle(pdev->dev.of_node,
  488. "qcom,wcd-handle", 0);
  489. if (!swr_dmic->wcd_handle) {
  490. dev_dbg(&pdev->dev, "%s: no wcd handle listed\n",
  491. __func__);
  492. swr_dmic->is_wcd_supply = false;
  493. } else {
  494. swr_dmic_parse_supply(swr_dmic->wcd_handle, swr_dmic);
  495. swr_dmic->is_wcd_supply = true;
  496. }
  497. if (swr_dmic->is_wcd_supply) {
  498. ret = enable_wcd_codec_supply(swr_dmic, true);
  499. if (ret) {
  500. ret = -EPROBE_DEFER;
  501. swr_dmic->is_wcd_supply = false;
  502. swr_dmic->wcd_handle = NULL;
  503. goto err;
  504. }
  505. ++swr_dmic->is_en_supply;
  506. }
  507. swr_set_dev_data(pdev, swr_dmic);
  508. swr_dmic->swr_slave = pdev;
  509. ret = of_property_read_string(pdev->dev.of_node, "qcom,swr-dmic-prefix",
  510. &swr_dmic_name_prefix_of);
  511. if (ret) {
  512. dev_dbg(&pdev->dev, "%s: Looking up %s property in node %s failed\n",
  513. __func__, "qcom,swr-dmic-prefix",
  514. pdev->dev.of_node->full_name);
  515. goto dev_err;
  516. }
  517. ret = of_property_read_string(pdev->dev.of_node, "qcom,codec-name",
  518. &swr_dmic_codec_name_of);
  519. if (ret) {
  520. dev_dbg(&pdev->dev, "%s: Looking up %s property in node %s failed\n",
  521. __func__, "qcom,codec-name",
  522. pdev->dev.of_node->full_name);
  523. goto dev_err;
  524. }
  525. swr_dmic_parse_port_params(&pdev->dev, "qcom,swr-tx-port-params");
  526. /*
  527. * Add 5msec delay to provide sufficient time for
  528. * soundwire auto enumeration of slave devices as
  529. * as per HW requirement.
  530. */
  531. usleep_range(5000, 5010);
  532. do {
  533. /* Add delay for soundwire enumeration */
  534. usleep_range(100, 110);
  535. ret = swr_get_logical_dev_num(pdev, pdev->addr, &swr_devnum);
  536. } while (ret && --num_retry);
  537. if (ret) {
  538. dev_info(&pdev->dev,
  539. "%s get devnum %d for dev addr %llx failed\n",
  540. __func__, swr_devnum, pdev->addr);
  541. ret = -EPROBE_DEFER;
  542. if (swr_dmic->is_en_supply == 1) {
  543. enable_wcd_codec_supply(swr_dmic, false);
  544. --swr_dmic->is_en_supply;
  545. }
  546. swr_dmic->is_wcd_supply = false;
  547. swr_dmic->wcd_handle = NULL;
  548. goto err;
  549. }
  550. pdev->dev_num = swr_devnum;
  551. swr_init_port_params(pdev, SWR_DMIC_MAX_PORTS,
  552. swr_dmic->swr_tx_port_params);
  553. swr_dmic->driver = devm_kzalloc(&pdev->dev,
  554. sizeof(struct snd_soc_component_driver), GFP_KERNEL);
  555. if (!swr_dmic->driver) {
  556. ret = -ENOMEM;
  557. goto dev_err;
  558. }
  559. memcpy(swr_dmic->driver, &soc_codec_dev_swr_dmic,
  560. sizeof(struct snd_soc_component_driver));
  561. for (i = 0; i < ARRAY_SIZE(codec_name_list); i++) {
  562. if (!strcmp(swr_dmic_codec_name_of, codec_name_list[i])) {
  563. dev_index = i;
  564. break;
  565. }
  566. }
  567. if (dev_index < 0) {
  568. ret = -EINVAL;
  569. goto dev_err;
  570. }
  571. swr_dmic->driver->name = codec_name_list[dev_index];
  572. swr_dmic->dai_driver = devm_kzalloc(&pdev->dev,
  573. sizeof(struct snd_soc_dai_driver), GFP_KERNEL);
  574. if (!swr_dmic->dai_driver) {
  575. ret = -ENOMEM;
  576. goto dev_err;
  577. }
  578. memcpy(swr_dmic->dai_driver, swr_dmic_dai,
  579. sizeof(struct snd_soc_dai_driver));
  580. swr_dmic->dai_driver->id = dev_index;
  581. swr_dmic->dai_driver->name = dai_name_list[dev_index];
  582. swr_dmic->dai_driver->capture.stream_name = aif_name_list[dev_index];
  583. /* Number of DAI's used is 1 */
  584. ret = snd_soc_register_component(&pdev->dev, swr_dmic->driver,
  585. swr_dmic->dai_driver, 1);
  586. if (ret) {
  587. dev_err(&pdev->dev, "%s: Codec registration failed\n",
  588. __func__);
  589. goto dev_err;
  590. }
  591. component = snd_soc_lookup_component(&pdev->dev,
  592. swr_dmic->driver->name);
  593. if (!component) {
  594. dev_err(&pdev->dev, "%s: could not find swr_dmic component\n",
  595. __func__);
  596. goto dev_err;
  597. }
  598. swr_dmic->component = component;
  599. prefix_name = devm_kzalloc(&pdev->dev,
  600. strlen(swr_dmic_name_prefix_of) + 1,
  601. GFP_KERNEL);
  602. if (!prefix_name) {
  603. ret = -ENOMEM;
  604. goto dev_err;
  605. }
  606. strlcpy(prefix_name, swr_dmic_name_prefix_of,
  607. strlen(prefix_name) + 1);
  608. component->name_prefix = prefix_name;
  609. return 0;
  610. dev_err:
  611. if (swr_dmic->is_en_supply == 1) {
  612. enable_wcd_codec_supply(swr_dmic, false);
  613. --swr_dmic->is_en_supply;
  614. }
  615. swr_dmic->is_wcd_supply = false;
  616. swr_dmic->wcd_handle = NULL;
  617. swr_remove_device(pdev);
  618. err:
  619. return ret;
  620. }
  621. static int swr_dmic_remove(struct swr_device *pdev)
  622. {
  623. struct swr_dmic_priv *swr_dmic;
  624. swr_dmic = swr_get_dev_data(pdev);
  625. if (!swr_dmic) {
  626. dev_err(&pdev->dev, "%s: swr_dmic is NULL\n", __func__);
  627. return -EINVAL;
  628. }
  629. if (swr_dmic->is_en_supply == 1) {
  630. enable_wcd_codec_supply(swr_dmic, false);
  631. --swr_dmic->is_en_supply;
  632. }
  633. snd_soc_unregister_component(&pdev->dev);
  634. swr_set_dev_data(pdev, NULL);
  635. return 0;
  636. }
  637. static int swr_dmic_up(struct swr_device *pdev)
  638. {
  639. int ret = 0;
  640. struct swr_dmic_priv *swr_dmic;
  641. swr_dmic = swr_get_dev_data(pdev);
  642. if (!swr_dmic) {
  643. dev_err(&pdev->dev, "%s: swr_dmic is NULL\n", __func__);
  644. return -EINVAL;
  645. }
  646. ++swr_dmic->is_en_supply;
  647. if (swr_dmic->is_en_supply == 1)
  648. ret = enable_wcd_codec_supply(swr_dmic, true);
  649. return ret;
  650. }
  651. static int swr_dmic_down(struct swr_device *pdev)
  652. {
  653. struct swr_dmic_priv *swr_dmic;
  654. int ret = 0;
  655. swr_dmic = swr_get_dev_data(pdev);
  656. if (!swr_dmic) {
  657. dev_err(&pdev->dev, "%s: swr_dmic is NULL\n", __func__);
  658. return -EINVAL;
  659. }
  660. dev_dbg(&pdev->dev, "%s: is_en_supply: %d\n",
  661. __func__, swr_dmic->is_en_supply);
  662. --swr_dmic->is_en_supply;
  663. if (swr_dmic->is_en_supply < 0) {
  664. dev_warn(&pdev->dev, "%s: mismatch in supply count %d\n",
  665. __func__, swr_dmic->is_en_supply);
  666. swr_dmic->is_en_supply = 0;
  667. goto done;
  668. }
  669. if (!swr_dmic->is_en_supply)
  670. enable_wcd_codec_supply(swr_dmic, false);
  671. done:
  672. return ret;
  673. }
  674. static int swr_dmic_reset(struct swr_device *pdev)
  675. {
  676. struct swr_dmic_priv *swr_dmic;
  677. u8 retry = NUM_ATTEMPTS;
  678. u8 devnum = 0;
  679. swr_dmic = swr_get_dev_data(pdev);
  680. if (!swr_dmic) {
  681. dev_err(&pdev->dev, "%s: swr_dmic is NULL\n", __func__);
  682. return -EINVAL;
  683. }
  684. while (swr_get_logical_dev_num(pdev, pdev->addr, &devnum) && retry--) {
  685. /* Retry after 1 msec delay */
  686. usleep_range(1000, 1100);
  687. }
  688. pdev->dev_num = devnum;
  689. dev_dbg(&pdev->dev, "%s: devnum: %d\n", __func__, devnum);
  690. return 0;
  691. }
  692. #ifdef CONFIG_PM_SLEEP
  693. static int swr_dmic_suspend(struct device *dev)
  694. {
  695. dev_dbg(dev, "%s: system suspend\n", __func__);
  696. return 0;
  697. }
  698. static int swr_dmic_resume(struct device *dev)
  699. {
  700. struct swr_dmic_priv *swr_dmic = swr_get_dev_data(to_swr_device(dev));
  701. if (!swr_dmic) {
  702. dev_err(dev, "%s: swr_dmic private data is NULL\n", __func__);
  703. return -EINVAL;
  704. }
  705. dev_dbg(dev, "%s: system resume\n", __func__);
  706. return 0;
  707. }
  708. #endif /* CONFIG_PM_SLEEP */
  709. static const struct dev_pm_ops swr_dmic_pm_ops = {
  710. SET_SYSTEM_SLEEP_PM_OPS(swr_dmic_suspend, swr_dmic_resume)
  711. };
  712. static const struct swr_device_id swr_dmic_id[] = {
  713. {"swr-dmic", 0},
  714. {}
  715. };
  716. static const struct of_device_id swr_dmic_dt_match[] = {
  717. {
  718. .compatible = "qcom,swr-dmic",
  719. },
  720. {}
  721. };
  722. static struct swr_driver swr_dmic_driver = {
  723. .driver = {
  724. .name = "swr-dmic",
  725. .owner = THIS_MODULE,
  726. .pm = &swr_dmic_pm_ops,
  727. .of_match_table = swr_dmic_dt_match,
  728. },
  729. .probe = swr_dmic_probe,
  730. .remove = swr_dmic_remove,
  731. .id_table = swr_dmic_id,
  732. };
  733. static int __init swr_dmic_init(void)
  734. {
  735. return swr_driver_register(&swr_dmic_driver);
  736. }
  737. static void __exit swr_dmic_exit(void)
  738. {
  739. swr_driver_unregister(&swr_dmic_driver);
  740. }
  741. module_init(swr_dmic_init);
  742. module_exit(swr_dmic_exit);
  743. MODULE_DESCRIPTION("SWR DMIC driver");
  744. MODULE_LICENSE("GPL v2");