PageRenderTime 2863ms CodeModel.GetById 15ms RepoModel.GetById 2ms app.codeStats 1ms

/arch/arm/mach-fsm/qdsp6/q6audio.c

https://bitbucket.org/sammyz/iscream_thunderc-2.6.35-rebase
C | 1852 lines | 1529 code | 298 blank | 25 comment | 229 complexity | efad4e9e4a09de0070cbd51e44fd14f2 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1. /*
  2. * Copyright (C) 2009 Google, Inc.
  3. * Copyright (c) 2010, Code Aurora Forum. All rights reserved.
  4. * Author: Brian Swetland <swetland@google.com>
  5. *
  6. * This software is licensed under the terms of the GNU General Public
  7. * License version 2, as published by the Free Software Foundation, and
  8. * may be copied, distributed, and modified under those terms.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. */
  16. #include <linux/mutex.h>
  17. #include <linux/sched.h>
  18. #include <linux/wait.h>
  19. #include <linux/dma-mapping.h>
  20. #include <linux/clk.h>
  21. #include <linux/delay.h>
  22. #include <linux/wakelock.h>
  23. #include <linux/android_pmem.h>
  24. #include <linux/firmware.h>
  25. #include <linux/miscdevice.h>
  26. #include "dal.h"
  27. #include "dal_audio.h"
  28. #include "dal_audio_format.h"
  29. #include "dal_acdb.h"
  30. #include "dal_adie.h"
  31. #include <mach/msm_qdsp6_audio.h>
  32. #include <linux/msm_audio_aac.h>
  33. #include <linux/gpio.h>
  34. #include "q6audio_devices.h"
  35. #include <mach/debug_mm.h>
  36. #if 0
  37. #define TRACE(x...) pr_info("Q6: "x)
  38. #else
  39. #define TRACE(x...) do{}while(0)
  40. #endif
  41. struct q6_hw_info {
  42. int min_gain;
  43. int max_gain;
  44. };
  45. /* TODO: provide mechanism to configure from board file */
  46. static struct q6_hw_info q6_audio_hw[Q6_HW_COUNT] = {
  47. [Q6_HW_HANDSET] = {
  48. .min_gain = -400,
  49. .max_gain = 1100,
  50. },
  51. [Q6_HW_HEADSET] = {
  52. .min_gain = -1100,
  53. .max_gain = 400,
  54. },
  55. [Q6_HW_SPEAKER] = {
  56. .min_gain = -1000,
  57. .max_gain = 500,
  58. },
  59. [Q6_HW_TTY] = {
  60. .min_gain = 0,
  61. .max_gain = 0,
  62. },
  63. [Q6_HW_BT_SCO] = {
  64. .min_gain = -1100,
  65. .max_gain = 400,
  66. },
  67. [Q6_HW_BT_A2DP] = {
  68. .min_gain = -1100,
  69. .max_gain = 400,
  70. },
  71. };
  72. static struct wake_lock wakelock;
  73. static struct wake_lock idlelock;
  74. static int idlecount;
  75. static DEFINE_MUTEX(idlecount_lock);
  76. void audio_prevent_sleep(void)
  77. {
  78. mutex_lock(&idlecount_lock);
  79. if (++idlecount == 1) {
  80. wake_lock(&wakelock);
  81. wake_lock(&idlelock);
  82. }
  83. mutex_unlock(&idlecount_lock);
  84. }
  85. void audio_allow_sleep(void)
  86. {
  87. mutex_lock(&idlecount_lock);
  88. if (--idlecount == 0) {
  89. wake_unlock(&idlelock);
  90. wake_unlock(&wakelock);
  91. }
  92. mutex_unlock(&idlecount_lock);
  93. }
  94. static struct clk *icodec_rx_clk;
  95. static struct clk *icodec_tx_clk;
  96. static struct clk *ecodec_clk;
  97. static struct clk *sdac_clk;
  98. static struct q6audio_analog_ops default_analog_ops;
  99. static struct q6audio_analog_ops *analog_ops = &default_analog_ops;
  100. static uint32_t tx_clk_freq = 8000;
  101. static int tx_mute_status = 0;
  102. static int rx_vol_level = 100;
  103. static uint32_t tx_acdb = 0;
  104. static uint32_t rx_acdb = 0;
  105. void q6audio_register_analog_ops(struct q6audio_analog_ops *ops)
  106. {
  107. analog_ops = ops;
  108. }
  109. static struct q6_device_info *q6_lookup_device(uint32_t device_id,
  110. uint32_t acdb_id)
  111. {
  112. struct q6_device_info *di = q6_audio_devices;
  113. if (acdb_id) {
  114. for (;;) {
  115. if (di->cad_id == acdb_id && di->id == device_id)
  116. return di;
  117. if (di->id == 0) {
  118. pr_err("[%s:%s] bogus id 0x%08x\n",
  119. __MM_FILE__, __func__, device_id);
  120. return di;
  121. }
  122. di++;
  123. }
  124. } else {
  125. for (;;) {
  126. if (di->id == device_id)
  127. return di;
  128. if (di->id == 0) {
  129. pr_err("[%s:%s] bogus id 0x%08x\n",
  130. __MM_FILE__, __func__, device_id);
  131. return di;
  132. }
  133. di++;
  134. }
  135. }
  136. }
  137. static uint32_t q6_device_to_codec(uint32_t device_id)
  138. {
  139. struct q6_device_info *di = q6_lookup_device(device_id, 0);
  140. return di->codec;
  141. }
  142. static uint32_t q6_device_to_dir(uint32_t device_id)
  143. {
  144. struct q6_device_info *di = q6_lookup_device(device_id, 0);
  145. return di->dir;
  146. }
  147. static uint32_t q6_device_to_cad_id(uint32_t device_id)
  148. {
  149. struct q6_device_info *di = q6_lookup_device(device_id, 0);
  150. return di->cad_id;
  151. }
  152. static uint32_t q6_device_to_path(uint32_t device_id, uint32_t acdb_id)
  153. {
  154. struct q6_device_info *di = q6_lookup_device(device_id, acdb_id);
  155. return di->path;
  156. }
  157. static uint32_t q6_device_to_rate(uint32_t device_id)
  158. {
  159. struct q6_device_info *di = q6_lookup_device(device_id, 0);
  160. return di->rate;
  161. }
  162. int q6_device_volume(uint32_t device_id, int level)
  163. {
  164. struct q6_device_info *di = q6_lookup_device(device_id, 0);
  165. struct q6_hw_info *hw;
  166. hw = &q6_audio_hw[di->hw];
  167. return hw->min_gain + ((hw->max_gain - hw->min_gain) * level) / 100;
  168. }
  169. static inline int adie_open(struct dal_client *client)
  170. {
  171. return dal_call_f0(client, DAL_OP_OPEN, 0);
  172. }
  173. static inline int adie_close(struct dal_client *client)
  174. {
  175. return dal_call_f0(client, DAL_OP_CLOSE, 0);
  176. }
  177. static inline int adie_set_path(struct dal_client *client,
  178. uint32_t id, uint32_t path_type)
  179. {
  180. return dal_call_f1(client, ADIE_OP_SET_PATH, id, path_type);
  181. }
  182. static inline int adie_set_path_freq_plan(struct dal_client *client,
  183. uint32_t path_type, uint32_t plan)
  184. {
  185. return dal_call_f1(client, ADIE_OP_SET_PATH_FREQUENCY_PLAN,
  186. path_type, plan);
  187. }
  188. static inline int adie_proceed_to_stage(struct dal_client *client,
  189. uint32_t path_type, uint32_t stage)
  190. {
  191. return dal_call_f1(client, ADIE_OP_PROCEED_TO_STAGE,
  192. path_type, stage);
  193. }
  194. static inline int adie_mute_path(struct dal_client *client,
  195. uint32_t path_type, uint32_t mute_state)
  196. {
  197. return dal_call_f1(client, ADIE_OP_MUTE_PATH, path_type, mute_state);
  198. }
  199. static int adie_refcount;
  200. static struct dal_client *adie;
  201. static struct dal_client *adsp;
  202. static struct dal_client *acdb;
  203. static int adie_enable(void)
  204. {
  205. adie_refcount++;
  206. if (adie_refcount == 1)
  207. adie_open(adie);
  208. return 0;
  209. }
  210. static int adie_disable(void)
  211. {
  212. adie_refcount--;
  213. if (adie_refcount == 0)
  214. adie_close(adie);
  215. return 0;
  216. }
  217. /* 4k PMEM used for exchanging acdb device config tables
  218. * and stream format descriptions with the DSP.
  219. */
  220. static char *audio_data;
  221. static int32_t audio_phys;
  222. #define SESSION_MIN 0
  223. #define SESSION_MAX 64
  224. static DEFINE_MUTEX(session_lock);
  225. static DEFINE_MUTEX(audio_lock);
  226. static struct audio_client *session[SESSION_MAX];
  227. static int session_alloc(struct audio_client *ac)
  228. {
  229. int n;
  230. mutex_lock(&session_lock);
  231. for (n = SESSION_MIN; n < SESSION_MAX; n++) {
  232. if (!session[n]) {
  233. session[n] = ac;
  234. mutex_unlock(&session_lock);
  235. return n;
  236. }
  237. }
  238. mutex_unlock(&session_lock);
  239. return -ENOMEM;
  240. }
  241. static void session_free(int n, struct audio_client *ac)
  242. {
  243. mutex_lock(&session_lock);
  244. if (session[n] == ac)
  245. session[n] = 0;
  246. mutex_unlock(&session_lock);
  247. }
  248. static void audio_client_free(struct audio_client *ac)
  249. {
  250. session_free(ac->session, ac);
  251. if (ac->buf[0].data) {
  252. iounmap(ac->buf[0].data);
  253. pmem_kfree(ac->buf[0].phys);
  254. }
  255. if (ac->buf[1].data) {
  256. iounmap(ac->buf[1].data);
  257. pmem_kfree(ac->buf[1].phys);
  258. }
  259. kfree(ac);
  260. }
  261. static struct audio_client *audio_client_alloc(unsigned bufsz)
  262. {
  263. struct audio_client *ac;
  264. int n;
  265. ac = kzalloc(sizeof(*ac), GFP_KERNEL);
  266. if (!ac)
  267. return 0;
  268. n = session_alloc(ac);
  269. if (n < 0)
  270. goto fail_session;
  271. ac->session = n;
  272. if (bufsz > 0) {
  273. ac->buf[0].phys = pmem_kalloc(bufsz,
  274. PMEM_MEMTYPE_EBI1|PMEM_ALIGNMENT_4K);
  275. ac->buf[0].data = ioremap(ac->buf[0].phys, bufsz);
  276. if (!ac->buf[0].data)
  277. goto fail;
  278. ac->buf[1].phys = pmem_kalloc(bufsz,
  279. PMEM_MEMTYPE_EBI1|PMEM_ALIGNMENT_4K);
  280. ac->buf[1].data = ioremap(ac->buf[1].phys, bufsz);
  281. if (!ac->buf[1].data)
  282. goto fail;
  283. ac->buf[0].size = bufsz;
  284. ac->buf[1].size = bufsz;
  285. }
  286. init_waitqueue_head(&ac->wait);
  287. ac->client = adsp;
  288. return ac;
  289. fail:
  290. session_free(n, ac);
  291. fail_session:
  292. audio_client_free(ac);
  293. return 0;
  294. }
  295. void audio_client_dump(struct audio_client *ac)
  296. {
  297. dal_trace_dump(ac->client);
  298. }
  299. static int audio_ioctl(struct audio_client *ac, void *ptr, uint32_t len)
  300. {
  301. struct adsp_command_hdr *hdr = ptr;
  302. uint32_t tmp;
  303. int r;
  304. hdr->size = len - sizeof(u32);
  305. hdr->dst = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_DSP);
  306. hdr->src = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_APP);
  307. hdr->context = ac->session;
  308. ac->cb_status = -EBUSY;
  309. r = dal_call(ac->client, AUDIO_OP_CONTROL, 5, ptr, len, &tmp, sizeof(tmp));
  310. if (r != 4)
  311. return -EIO;
  312. if (!wait_event_timeout(ac->wait, (ac->cb_status != -EBUSY), 5*HZ)) {
  313. dal_trace_dump(ac->client);
  314. pr_err("[%s:%s] timeout. dsp dead?\n", __MM_FILE__, __func__);
  315. q6audio_dsp_not_responding();
  316. }
  317. return ac->cb_status;
  318. }
  319. static int audio_command(struct audio_client *ac, uint32_t cmd)
  320. {
  321. struct adsp_command_hdr rpc;
  322. memset(&rpc, 0, sizeof(rpc));
  323. rpc.opcode = cmd;
  324. return audio_ioctl(ac, &rpc, sizeof(rpc));
  325. }
  326. static int audio_open_control(struct audio_client *ac)
  327. {
  328. struct adsp_open_command rpc;
  329. memset(&rpc, 0, sizeof(rpc));
  330. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_DEVICE;
  331. return audio_ioctl(ac, &rpc, sizeof(rpc));
  332. }
  333. static int audio_out_open(struct audio_client *ac, uint32_t bufsz,
  334. uint32_t rate, uint32_t channels)
  335. {
  336. struct adsp_open_command rpc;
  337. memset(&rpc, 0, sizeof(rpc));
  338. rpc.format.standard.format = ADSP_AUDIO_FORMAT_PCM;
  339. rpc.format.standard.channels = channels;
  340. rpc.format.standard.bits_per_sample = 16;
  341. rpc.format.standard.sampling_rate = rate;
  342. rpc.format.standard.is_signed = 1;
  343. rpc.format.standard.is_interleaved = 1;
  344. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_WRITE;
  345. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  346. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_PLAYBACK;
  347. rpc.buf_max_size = bufsz;
  348. TRACE("open out %p\n", ac);
  349. return audio_ioctl(ac, &rpc, sizeof(rpc));
  350. }
  351. static int audio_in_open(struct audio_client *ac, uint32_t bufsz,
  352. uint32_t flags, uint32_t rate, uint32_t channels)
  353. {
  354. struct adsp_open_command rpc;
  355. memset(&rpc, 0, sizeof(rpc));
  356. rpc.format.standard.format = ADSP_AUDIO_FORMAT_PCM;
  357. rpc.format.standard.channels = channels;
  358. rpc.format.standard.bits_per_sample = 16;
  359. rpc.format.standard.sampling_rate = rate;
  360. rpc.format.standard.is_signed = 1;
  361. rpc.format.standard.is_interleaved = 1;
  362. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_READ;
  363. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  364. if (flags == AUDIO_FLAG_READ)
  365. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD;
  366. else
  367. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_MIXED_RECORD;
  368. rpc.buf_max_size = bufsz;
  369. TRACE("%p: open in\n", ac);
  370. return audio_ioctl(ac, &rpc, sizeof(rpc));
  371. }
  372. static int audio_mp3_open(struct audio_client *ac, uint32_t bufsz,
  373. uint32_t rate, uint32_t channels)
  374. {
  375. struct adsp_open_command rpc;
  376. memset(&rpc, 0, sizeof(rpc));
  377. rpc.format.standard.format = ADSP_AUDIO_FORMAT_MP3;
  378. rpc.format.standard.channels = channels;
  379. rpc.format.standard.bits_per_sample = 16;
  380. rpc.format.standard.sampling_rate = rate;
  381. rpc.format.standard.is_signed = 1;
  382. rpc.format.standard.is_interleaved = 0;
  383. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_WRITE;
  384. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  385. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_PLAYBACK;
  386. rpc.buf_max_size = bufsz;
  387. return audio_ioctl(ac, &rpc, sizeof(rpc));
  388. }
  389. static int audio_dtmf_open(struct audio_client *ac,
  390. uint32_t rate, uint32_t channels)
  391. {
  392. struct adsp_open_command rpc;
  393. memset(&rpc, 0, sizeof(rpc));
  394. rpc.format.standard.format = ADSP_AUDIO_FORMAT_DTMF;
  395. rpc.format.standard.channels = channels;
  396. rpc.format.standard.bits_per_sample = 16;
  397. rpc.format.standard.sampling_rate = rate;
  398. rpc.format.standard.is_signed = 1;
  399. rpc.format.standard.is_interleaved = 0;
  400. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_WRITE;
  401. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  402. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_PLAYBACK;
  403. return audio_ioctl(ac, &rpc, sizeof(rpc));
  404. }
  405. static int audio_aac_open(struct audio_client *ac, uint32_t bufsz,
  406. uint32_t sample_rate, uint32_t channels,
  407. uint32_t bit_rate, uint32_t flags,
  408. uint32_t stream_format)
  409. {
  410. struct adsp_open_command rpc;
  411. int audio_object_type;
  412. int index = sizeof(u32);
  413. u32 *aac_type = NULL;
  414. memset(&rpc, 0, sizeof(rpc));
  415. rpc.format.binary.format = ADSP_AUDIO_FORMAT_MPEG4_AAC;
  416. /* only 48k sample rate is supported */
  417. sample_rate = 3;
  418. /* AAC OBJECT LC */
  419. audio_object_type = 2;
  420. aac_type = (u32 *)rpc.format.binary.data;
  421. switch (stream_format) {
  422. case AUDIO_AAC_FORMAT_ADTS:
  423. /* AAC Encoder expect MPEG4_ADTS media type */
  424. *aac_type = ADSP_AUDIO_AAC_MPEG4_ADTS;
  425. break;
  426. case AUDIO_AAC_FORMAT_RAW:
  427. /* for ADIF recording */
  428. *aac_type = ADSP_AUDIO_AAC_RAW;
  429. break;
  430. }
  431. rpc.format.binary.data[index++] = (u8)(
  432. ((audio_object_type & 0x1F) << 3) |
  433. ((sample_rate >> 1) & 0x7));
  434. rpc.format.binary.data[index] = (u8)(
  435. ((sample_rate & 0x1) << 7) |
  436. ((channels & 0x7) << 3));
  437. rpc.format.binary.num_bytes = index + 1;
  438. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_READ;
  439. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  440. if (flags == AUDIO_FLAG_READ)
  441. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD;
  442. else
  443. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_MIXED_RECORD;
  444. rpc.buf_max_size = bufsz;
  445. rpc.config.aac.bit_rate = bit_rate;
  446. rpc.config.aac.encoder_mode = ADSP_AUDIO_ENC_AAC_LC_ONLY_MODE;
  447. return audio_ioctl(ac, &rpc, sizeof(rpc));
  448. }
  449. static int audio_qcp_open(struct audio_client *ac, uint32_t bufsz,
  450. uint32_t min_rate, uint32_t max_rate,
  451. uint32_t flags, uint32_t format)
  452. {
  453. struct adsp_open_command rpc;
  454. memset(&rpc, 0, sizeof(rpc));
  455. rpc.format.standard.format = format;
  456. rpc.format.standard.channels = 1;
  457. rpc.format.standard.bits_per_sample = 16;
  458. rpc.format.standard.sampling_rate = 8000;
  459. rpc.format.standard.is_signed = 1;
  460. rpc.format.standard.is_interleaved = 0;
  461. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_READ;
  462. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  463. if (flags == AUDIO_FLAG_READ)
  464. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD;
  465. else
  466. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_MIXED_RECORD;
  467. rpc.buf_max_size = bufsz;
  468. rpc.config.evrc.min_rate = min_rate;
  469. rpc.config.evrc.max_rate = max_rate;
  470. return audio_ioctl(ac, &rpc, sizeof(rpc));
  471. }
  472. static int audio_amrnb_open(struct audio_client *ac, uint32_t bufsz,
  473. uint32_t enc_mode, uint32_t flags,
  474. uint32_t dtx_enable)
  475. {
  476. struct adsp_open_command rpc;
  477. memset(&rpc, 0, sizeof(rpc));
  478. rpc.format.standard.format = ADSP_AUDIO_FORMAT_AMRNB_FS;
  479. rpc.format.standard.channels = 1;
  480. rpc.format.standard.bits_per_sample = 16;
  481. rpc.format.standard.sampling_rate = 8000;
  482. rpc.format.standard.is_signed = 1;
  483. rpc.format.standard.is_interleaved = 0;
  484. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_OPEN_READ;
  485. rpc.device = ADSP_AUDIO_DEVICE_ID_DEFAULT;
  486. if (flags == AUDIO_FLAG_READ)
  487. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_RECORD;
  488. else
  489. rpc.stream_context = ADSP_AUDIO_DEVICE_CONTEXT_MIXED_RECORD;
  490. rpc.buf_max_size = bufsz;
  491. rpc.config.amr.mode = enc_mode;
  492. rpc.config.amr.dtx_mode = dtx_enable;
  493. rpc.config.amr.enable = 1;
  494. return audio_ioctl(ac, &rpc, sizeof(rpc));
  495. }
  496. static int audio_close(struct audio_client *ac)
  497. {
  498. TRACE("%p: close\n", ac);
  499. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_STREAM_STOP);
  500. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_CLOSE);
  501. return 0;
  502. }
  503. static int audio_set_table(struct audio_client *ac,
  504. uint32_t device_id, int size)
  505. {
  506. struct adsp_set_dev_cfg_table_command rpc;
  507. memset(&rpc, 0, sizeof(rpc));
  508. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_SET_DEVICE_CONFIG_TABLE;
  509. if (q6_device_to_dir(device_id) == Q6_TX)
  510. rpc.hdr.data = tx_clk_freq;
  511. rpc.device_id = device_id;
  512. rpc.phys_addr = audio_phys;
  513. rpc.phys_size = size;
  514. rpc.phys_used = size;
  515. TRACE("control: set table %x\n", device_id);
  516. return audio_ioctl(ac, &rpc, sizeof(rpc));
  517. }
  518. int q6audio_read(struct audio_client *ac, struct audio_buffer *ab)
  519. {
  520. struct adsp_buffer_command rpc;
  521. uint32_t res;
  522. int r;
  523. memset(&rpc, 0, sizeof(rpc));
  524. rpc.hdr.size = sizeof(rpc) - sizeof(u32);
  525. rpc.hdr.dst = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_DSP);
  526. rpc.hdr.src = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_APP);
  527. rpc.hdr.context = ac->session;
  528. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_DATA_TX;
  529. rpc.buffer.addr = ab->phys;
  530. rpc.buffer.max_size = ab->size;
  531. rpc.buffer.actual_size = ab->actual_size;
  532. TRACE("%p: read\n", ac);
  533. r = dal_call(ac->client, AUDIO_OP_DATA, 5, &rpc, sizeof(rpc),
  534. &res, sizeof(res));
  535. return 0;
  536. }
  537. int q6audio_write(struct audio_client *ac, struct audio_buffer *ab)
  538. {
  539. struct adsp_buffer_command rpc;
  540. uint32_t res;
  541. int r;
  542. memset(&rpc, 0, sizeof(rpc));
  543. rpc.hdr.size = sizeof(rpc) - sizeof(u32);
  544. rpc.hdr.dst = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_DSP);
  545. rpc.hdr.src = AUDIO_ADDR(ac->session, 0, AUDIO_DOMAIN_APP);
  546. rpc.hdr.context = ac->session;
  547. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_DATA_RX;
  548. rpc.buffer.addr = ab->phys;
  549. rpc.buffer.max_size = ab->size;
  550. rpc.buffer.actual_size = ab->actual_size;
  551. TRACE("%p: write\n", ac);
  552. r = dal_call(ac->client, AUDIO_OP_DATA, 5, &rpc, sizeof(rpc),
  553. &res, sizeof(res));
  554. return 0;
  555. }
  556. static int audio_rx_volume(struct audio_client *ac, uint32_t dev_id, int32_t volume)
  557. {
  558. struct adsp_set_dev_volume_command rpc;
  559. memset(&rpc, 0, sizeof(rpc));
  560. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_VOL;
  561. rpc.device_id = dev_id;
  562. rpc.path = ADSP_PATH_RX;
  563. rpc.volume = volume;
  564. return audio_ioctl(ac, &rpc, sizeof(rpc));
  565. }
  566. static int audio_rx_mute(struct audio_client *ac, uint32_t dev_id, int mute)
  567. {
  568. struct adsp_set_dev_mute_command rpc;
  569. memset(&rpc, 0, sizeof(rpc));
  570. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
  571. rpc.device_id = dev_id;
  572. rpc.path = ADSP_PATH_RX;
  573. rpc.mute = !!mute;
  574. return audio_ioctl(ac, &rpc, sizeof(rpc));
  575. }
  576. static int audio_tx_mute(struct audio_client *ac, uint32_t dev_id, int mute)
  577. {
  578. struct adsp_set_dev_mute_command rpc;
  579. memset(&rpc, 0, sizeof(rpc));
  580. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
  581. rpc.device_id = dev_id;
  582. rpc.path = ADSP_PATH_TX;
  583. rpc.mute = !!mute;
  584. return audio_ioctl(ac, &rpc, sizeof(rpc));
  585. }
  586. static int audio_stream_volume(struct audio_client *ac, int volume)
  587. {
  588. struct adsp_set_volume_command rpc;
  589. int rc;
  590. memset(&rpc, 0, sizeof(rpc));
  591. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_VOL;
  592. rpc.volume = volume;
  593. rc = audio_ioctl(ac, &rpc, sizeof(rpc));
  594. return rc;
  595. }
  596. static int audio_stream_mute(struct audio_client *ac, int mute)
  597. {
  598. struct adsp_set_mute_command rpc;
  599. int rc;
  600. memset(&rpc, 0, sizeof(rpc));
  601. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE;
  602. rpc.mute = mute;
  603. rc = audio_ioctl(ac, &rpc, sizeof(rpc));
  604. return rc;
  605. }
  606. static void callback(void *data, int len, void *cookie)
  607. {
  608. struct adsp_event_hdr *e = data;
  609. struct audio_client *ac;
  610. struct adsp_buffer_event *abe = data;
  611. if (e->context >= SESSION_MAX) {
  612. pr_err("[%s:%s] bogus session %d\n", __MM_FILE__, __func__,
  613. e->context);
  614. return;
  615. }
  616. ac = session[e->context];
  617. if (!ac) {
  618. pr_err("[%s:%s] unknown session %d\n", __MM_FILE__, __func__,
  619. e->context);
  620. return;
  621. }
  622. if (e->event_id == ADSP_AUDIO_IOCTL_CMD_STREAM_EOS) {
  623. TRACE("%p: CB stream eos\n", ac);
  624. if (e->status)
  625. pr_err("[%s:%s] playback status %d\n", __MM_FILE__,
  626. __func__, e->status);
  627. if (ac->cb_status == -EBUSY) {
  628. ac->cb_status = e->status;
  629. wake_up(&ac->wait);
  630. }
  631. return;
  632. }
  633. if (e->event_id == ADSP_AUDIO_EVT_STATUS_BUF_DONE) {
  634. TRACE("%p: CB done (%d)\n", ac, e->status);
  635. if (e->status)
  636. pr_err("[%s:%s] buffer status %d\n", __MM_FILE__,
  637. __func__, e->status);
  638. ac->buf[ac->dsp_buf].actual_size = abe->buffer.actual_size;
  639. ac->buf[ac->dsp_buf].used = 0;
  640. ac->dsp_buf ^= 1;
  641. wake_up(&ac->wait);
  642. return;
  643. }
  644. TRACE("%p: CB %08x status %d\n", ac, e->event_id, e->status);
  645. if (e->status)
  646. pr_warning("audio_cb: s=%d e=%08x status=%d\n",
  647. e->context, e->event_id, e->status);
  648. if (ac->cb_status == -EBUSY) {
  649. ac->cb_status = e->status;
  650. wake_up(&ac->wait);
  651. }
  652. }
  653. static void audio_init(struct dal_client *client)
  654. {
  655. u32 tmp[3];
  656. tmp[0] = 2 * sizeof(u32);
  657. tmp[1] = 0;
  658. tmp[2] = 0;
  659. dal_call(client, AUDIO_OP_INIT, 5, tmp, sizeof(tmp),
  660. tmp, sizeof(u32));
  661. }
  662. static struct audio_client *ac_control;
  663. static int q6audio_init(void)
  664. {
  665. struct audio_client *ac = 0;
  666. int res;
  667. mutex_lock(&audio_lock);
  668. if (ac_control) {
  669. res = 0;
  670. goto done;
  671. }
  672. pr_info("[%s:%s] codecs\n", __MM_FILE__, __func__);
  673. icodec_rx_clk = clk_get(0, "icodec_rx_clk");
  674. icodec_tx_clk = clk_get(0, "icodec_tx_clk");
  675. ecodec_clk = clk_get(0, "ecodec_clk");
  676. sdac_clk = clk_get(0, "sdac_clk");
  677. audio_phys = pmem_kalloc(4096, PMEM_MEMTYPE_EBI1|PMEM_ALIGNMENT_4K);
  678. audio_data = ioremap(audio_phys, 4096);
  679. adsp = dal_attach(AUDIO_DAL_DEVICE, AUDIO_DAL_PORT, 1,
  680. callback, 0);
  681. if (!adsp) {
  682. pr_err("[%s:%s] cannot attach to adsp\n", __MM_FILE__,
  683. __func__);
  684. res = -ENODEV;
  685. goto done;
  686. }
  687. pr_info("[%s:%s] INIT\n", __MM_FILE__, __func__);
  688. audio_init(adsp);
  689. dal_trace(adsp);
  690. ac = audio_client_alloc(0);
  691. if (!ac) {
  692. pr_err("[%s:%s] cannot allocate client\n",
  693. __MM_FILE__, __func__);
  694. res = -ENOMEM;
  695. goto done;
  696. }
  697. pr_info("[%s:%s] OPEN control\n", __MM_FILE__, __func__);
  698. if (audio_open_control(ac)) {
  699. pr_err("[%s:%s] cannot open control channel\n",
  700. __MM_FILE__, __func__);
  701. res = -ENODEV;
  702. goto done;
  703. }
  704. pr_info("[%s:%s] attach ACDB\n", __MM_FILE__, __func__);
  705. acdb = dal_attach(ACDB_DAL_DEVICE, ACDB_DAL_PORT, 0, 0, 0);
  706. if (!acdb) {
  707. pr_err("[%s:%s] cannot attach to acdb channel\n",
  708. __MM_FILE__, __func__);
  709. res = -ENODEV;
  710. goto done;
  711. }
  712. pr_info("[%s:%s] attach ADIE\n", __MM_FILE__, __func__);
  713. adie = dal_attach(ADIE_DAL_DEVICE, ADIE_DAL_PORT, 0, 0, 0);
  714. if (!adie) {
  715. pr_err("[%s:%s] cannot attach to adie\n",
  716. __MM_FILE__, __func__);
  717. res = -ENODEV;
  718. goto done;
  719. }
  720. if (analog_ops->init)
  721. analog_ops->init();
  722. res = 0;
  723. ac_control = ac;
  724. wake_lock_init(&idlelock, WAKE_LOCK_IDLE, "audio_pcm_idle");
  725. wake_lock_init(&wakelock, WAKE_LOCK_SUSPEND, "audio_pcm_suspend");
  726. done:
  727. if ((res < 0) && ac)
  728. audio_client_free(ac);
  729. mutex_unlock(&audio_lock);
  730. return res;
  731. }
  732. struct audio_config_data {
  733. uint32_t device_id;
  734. uint32_t sample_rate;
  735. uint32_t offset;
  736. uint32_t length;
  737. };
  738. struct audio_config_database {
  739. uint8_t magic[8];
  740. uint32_t entry_count;
  741. uint32_t unused;
  742. struct audio_config_data entry[0];
  743. };
  744. void *acdb_data;
  745. const struct firmware *acdb_fw;
  746. extern struct miscdevice q6_control_device;
  747. static int acdb_get_config_table(uint32_t device_id, uint32_t sample_rate)
  748. {
  749. struct acdb_cmd_device_table rpc;
  750. struct acdb_result res;
  751. int r;
  752. if (q6audio_init())
  753. return 0;
  754. memset(audio_data, 0, 4096);
  755. memset(&rpc, 0, sizeof(rpc));
  756. rpc.size = sizeof(rpc) - (2 * sizeof(uint32_t));
  757. rpc.command_id = ACDB_GET_DEVICE_TABLE;
  758. rpc.device_id = device_id;
  759. rpc.sample_rate_id = sample_rate;
  760. rpc.total_bytes = 4096;
  761. rpc.unmapped_buf = audio_phys;
  762. rpc.res_size = sizeof(res) - (2 * sizeof(uint32_t));
  763. r = dal_call(acdb, ACDB_OP_IOCTL, 8, &rpc, sizeof(rpc),
  764. &res, sizeof(res));
  765. if ((r == sizeof(res)) && (res.dal_status == 0))
  766. return res.used_bytes;
  767. return -EIO;
  768. }
  769. static uint32_t audio_rx_path_id = ADIE_PATH_HANDSET_RX;
  770. static uint32_t audio_rx_device_id = ADSP_AUDIO_DEVICE_ID_HANDSET_SPKR;
  771. static uint32_t audio_rx_device_group = -1;
  772. static uint32_t audio_tx_path_id = ADIE_PATH_HANDSET_TX;
  773. static uint32_t audio_tx_device_id = ADSP_AUDIO_DEVICE_ID_HANDSET_MIC;
  774. static uint32_t audio_tx_device_group = -1;
  775. static int qdsp6_devchg_notify(struct audio_client *ac,
  776. uint32_t dev_type, uint32_t dev_id)
  777. {
  778. struct adsp_device_switch_command rpc;
  779. if (dev_type != ADSP_AUDIO_RX_DEVICE &&
  780. dev_type != ADSP_AUDIO_TX_DEVICE)
  781. return -EINVAL;
  782. memset(&rpc, 0, sizeof(rpc));
  783. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_DEVICE_SWITCH_PREPARE;
  784. if (dev_type == ADSP_AUDIO_RX_DEVICE) {
  785. rpc.old_device = audio_rx_device_id;
  786. rpc.new_device = dev_id;
  787. } else {
  788. rpc.old_device = audio_tx_device_id;
  789. rpc.new_device = dev_id;
  790. }
  791. rpc.device_class = 0;
  792. rpc.device_type = dev_type;
  793. return audio_ioctl(ac, &rpc, sizeof(rpc));
  794. }
  795. static int qdsp6_standby(struct audio_client *ac)
  796. {
  797. return audio_command(ac, ADSP_AUDIO_IOCTL_CMD_DEVICE_SWITCH_STANDBY);
  798. }
  799. static int qdsp6_start(struct audio_client *ac)
  800. {
  801. return audio_command(ac, ADSP_AUDIO_IOCTL_CMD_DEVICE_SWITCH_COMMIT);
  802. }
  803. static void audio_rx_analog_enable(int en)
  804. {
  805. switch (audio_rx_device_id) {
  806. case ADSP_AUDIO_DEVICE_ID_HEADSET_SPKR_MONO:
  807. case ADSP_AUDIO_DEVICE_ID_HEADSET_SPKR_STEREO:
  808. case ADSP_AUDIO_DEVICE_ID_TTY_HEADSET_SPKR:
  809. if (analog_ops->headset_enable)
  810. analog_ops->headset_enable(en);
  811. break;
  812. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_MONO_W_MONO_HEADSET:
  813. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_MONO_W_STEREO_HEADSET:
  814. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_STEREO_W_MONO_HEADSET:
  815. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_STEREO_W_STEREO_HEADSET:
  816. if (analog_ops->headset_enable)
  817. analog_ops->headset_enable(en);
  818. if (analog_ops->speaker_enable)
  819. analog_ops->speaker_enable(en);
  820. break;
  821. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_MONO:
  822. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_STEREO:
  823. if (analog_ops->speaker_enable)
  824. analog_ops->speaker_enable(en);
  825. break;
  826. case ADSP_AUDIO_DEVICE_ID_BT_SCO_SPKR:
  827. if (analog_ops->bt_sco_enable)
  828. analog_ops->bt_sco_enable(en);
  829. break;
  830. case ADSP_AUDIO_DEVICE_ID_HANDSET_SPKR:
  831. if (analog_ops->receiver_enable)
  832. analog_ops->receiver_enable(en);
  833. break;
  834. }
  835. }
  836. static void audio_tx_analog_enable(int en)
  837. {
  838. switch (audio_tx_device_id) {
  839. case ADSP_AUDIO_DEVICE_ID_HANDSET_MIC:
  840. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_MIC:
  841. if (analog_ops->int_mic_enable)
  842. analog_ops->int_mic_enable(en);
  843. break;
  844. case ADSP_AUDIO_DEVICE_ID_HEADSET_MIC:
  845. case ADSP_AUDIO_DEVICE_ID_TTY_HEADSET_MIC:
  846. case ADSP_AUDIO_DEVICE_ID_HANDSET_DUAL_MIC:
  847. case ADSP_AUDIO_DEVICE_ID_SPKR_PHONE_DUAL_MIC:
  848. if (analog_ops->ext_mic_enable)
  849. analog_ops->ext_mic_enable(en);
  850. break;
  851. case ADSP_AUDIO_DEVICE_ID_BT_SCO_MIC:
  852. if (analog_ops->bt_sco_enable)
  853. analog_ops->bt_sco_enable(en);
  854. break;
  855. }
  856. }
  857. static int audio_update_acdb(uint32_t adev, uint32_t acdb_id)
  858. {
  859. uint32_t sample_rate;
  860. int sz;
  861. sample_rate = q6_device_to_rate(adev);
  862. if (q6_device_to_dir(adev) == Q6_RX)
  863. rx_acdb = acdb_id;
  864. else
  865. tx_acdb = acdb_id;
  866. if (acdb_id == 0)
  867. acdb_id = q6_device_to_cad_id(adev);
  868. sz = acdb_get_config_table(acdb_id, sample_rate);
  869. audio_set_table(ac_control, adev, sz);
  870. return 0;
  871. }
  872. static void adie_rx_path_enable(uint32_t acdb_id)
  873. {
  874. adie_enable();
  875. adie_set_path(adie, audio_rx_path_id, ADIE_PATH_RX);
  876. adie_set_path_freq_plan(adie, ADIE_PATH_RX, 48000);
  877. adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_DIGITAL_READY);
  878. adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_DIGITAL_ANALOG_READY);
  879. }
  880. static void q6_rx_path_enable(int reconf, uint32_t acdb_id)
  881. {
  882. audio_update_acdb(audio_rx_device_id, acdb_id);
  883. if (!reconf)
  884. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_RX_DEVICE, audio_rx_device_id);
  885. qdsp6_standby(ac_control);
  886. qdsp6_start(ac_control);
  887. }
  888. static void _audio_rx_path_enable(int reconf, uint32_t acdb_id)
  889. {
  890. q6_rx_path_enable(reconf, acdb_id);
  891. adie_rx_path_enable(acdb_id);
  892. audio_rx_analog_enable(1);
  893. }
  894. static void _audio_tx_path_enable(int reconf, uint32_t acdb_id)
  895. {
  896. audio_tx_analog_enable(1);
  897. adie_enable();
  898. adie_set_path(adie, audio_tx_path_id, ADIE_PATH_TX);
  899. if (tx_clk_freq > 8000)
  900. adie_set_path_freq_plan(adie, ADIE_PATH_TX, 48000);
  901. else
  902. adie_set_path_freq_plan(adie, ADIE_PATH_TX, 8000);
  903. adie_proceed_to_stage(adie, ADIE_PATH_TX, ADIE_STAGE_DIGITAL_READY);
  904. adie_proceed_to_stage(adie, ADIE_PATH_TX, ADIE_STAGE_DIGITAL_ANALOG_READY);
  905. audio_update_acdb(audio_tx_device_id, acdb_id);
  906. if (!reconf)
  907. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_TX_DEVICE, audio_tx_device_id);
  908. qdsp6_standby(ac_control);
  909. qdsp6_start(ac_control);
  910. audio_tx_mute(ac_control, audio_tx_device_id, tx_mute_status);
  911. }
  912. static void _audio_rx_path_disable(void)
  913. {
  914. audio_rx_analog_enable(0);
  915. adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_ANALOG_OFF);
  916. adie_proceed_to_stage(adie, ADIE_PATH_RX, ADIE_STAGE_DIGITAL_OFF);
  917. adie_disable();
  918. }
  919. static void _audio_tx_path_disable(void)
  920. {
  921. audio_tx_analog_enable(0);
  922. adie_proceed_to_stage(adie, ADIE_PATH_TX, ADIE_STAGE_ANALOG_OFF);
  923. adie_proceed_to_stage(adie, ADIE_PATH_TX, ADIE_STAGE_DIGITAL_OFF);
  924. adie_disable();
  925. }
  926. static int icodec_rx_clk_refcount;
  927. static int icodec_tx_clk_refcount;
  928. static int ecodec_clk_refcount;
  929. static int sdac_clk_refcount;
  930. static void _audio_rx_clk_enable(void)
  931. {
  932. uint32_t device_group = q6_device_to_codec(audio_rx_device_id);
  933. switch(device_group) {
  934. case Q6_ICODEC_RX:
  935. icodec_rx_clk_refcount++;
  936. if (icodec_rx_clk_refcount == 1) {
  937. clk_set_rate(icodec_rx_clk, 12288000);
  938. clk_enable(icodec_rx_clk);
  939. }
  940. break;
  941. case Q6_ECODEC_RX:
  942. ecodec_clk_refcount++;
  943. if (ecodec_clk_refcount == 1) {
  944. clk_set_rate(ecodec_clk, 2048000);
  945. clk_enable(ecodec_clk);
  946. }
  947. break;
  948. case Q6_SDAC_RX:
  949. sdac_clk_refcount++;
  950. if (sdac_clk_refcount == 1) {
  951. clk_set_rate(sdac_clk, 12288000);
  952. clk_enable(sdac_clk);
  953. }
  954. break;
  955. default:
  956. return;
  957. }
  958. audio_rx_device_group = device_group;
  959. }
  960. static void _audio_tx_clk_enable(void)
  961. {
  962. uint32_t device_group = q6_device_to_codec(audio_tx_device_id);
  963. switch (device_group) {
  964. case Q6_ICODEC_TX:
  965. icodec_tx_clk_refcount++;
  966. if (icodec_tx_clk_refcount == 1) {
  967. clk_set_rate(icodec_tx_clk, tx_clk_freq * 256);
  968. clk_enable(icodec_tx_clk);
  969. }
  970. break;
  971. case Q6_ECODEC_TX:
  972. ecodec_clk_refcount++;
  973. if (ecodec_clk_refcount == 1) {
  974. clk_set_rate(ecodec_clk, 2048000);
  975. clk_enable(ecodec_clk);
  976. }
  977. break;
  978. case Q6_SDAC_TX:
  979. /* TODO: In QCT BSP, clk rate was set to 20480000 */
  980. sdac_clk_refcount++;
  981. if (sdac_clk_refcount == 1) {
  982. clk_set_rate(sdac_clk, 12288000);
  983. clk_enable(sdac_clk);
  984. }
  985. break;
  986. default:
  987. return;
  988. }
  989. audio_tx_device_group = device_group;
  990. }
  991. static void _audio_rx_clk_disable(void)
  992. {
  993. switch (audio_rx_device_group) {
  994. case Q6_ICODEC_RX:
  995. icodec_rx_clk_refcount--;
  996. if (icodec_rx_clk_refcount == 0) {
  997. clk_disable(icodec_rx_clk);
  998. audio_rx_device_group = -1;
  999. }
  1000. break;
  1001. case Q6_ECODEC_RX:
  1002. ecodec_clk_refcount--;
  1003. if (ecodec_clk_refcount == 0) {
  1004. clk_disable(ecodec_clk);
  1005. audio_rx_device_group = -1;
  1006. }
  1007. break;
  1008. case Q6_SDAC_RX:
  1009. sdac_clk_refcount--;
  1010. if (sdac_clk_refcount == 0) {
  1011. clk_disable(sdac_clk);
  1012. audio_rx_device_group = -1;
  1013. }
  1014. break;
  1015. default:
  1016. pr_err("[%s:%s] invalid rx device group %d\n", __MM_FILE__,
  1017. __func__, audio_rx_device_group);
  1018. break;
  1019. }
  1020. }
  1021. static void _audio_tx_clk_disable(void)
  1022. {
  1023. switch (audio_tx_device_group) {
  1024. case Q6_ICODEC_TX:
  1025. icodec_tx_clk_refcount--;
  1026. if (icodec_tx_clk_refcount == 0) {
  1027. clk_disable(icodec_tx_clk);
  1028. audio_tx_device_group = -1;
  1029. }
  1030. break;
  1031. case Q6_ECODEC_TX:
  1032. ecodec_clk_refcount--;
  1033. if (ecodec_clk_refcount == 0) {
  1034. clk_disable(ecodec_clk);
  1035. audio_tx_device_group = -1;
  1036. }
  1037. break;
  1038. case Q6_SDAC_TX:
  1039. sdac_clk_refcount--;
  1040. if (sdac_clk_refcount == 0) {
  1041. clk_disable(sdac_clk);
  1042. audio_tx_device_group = -1;
  1043. }
  1044. break;
  1045. default:
  1046. pr_err("[%s:%s] invalid tx device group %d\n",
  1047. __MM_FILE__, __func__, audio_tx_device_group);
  1048. break;
  1049. }
  1050. }
  1051. static void _audio_rx_clk_reinit(uint32_t rx_device, uint32_t acdb_id)
  1052. {
  1053. uint32_t device_group = q6_device_to_codec(rx_device);
  1054. if (device_group != audio_rx_device_group)
  1055. _audio_rx_clk_disable();
  1056. audio_rx_device_id = rx_device;
  1057. audio_rx_path_id = q6_device_to_path(rx_device, acdb_id);
  1058. if (device_group != audio_rx_device_group)
  1059. _audio_rx_clk_enable();
  1060. }
  1061. static void _audio_tx_clk_reinit(uint32_t tx_device, uint32_t acdb_id)
  1062. {
  1063. uint32_t device_group = q6_device_to_codec(tx_device);
  1064. if (device_group != audio_tx_device_group)
  1065. _audio_tx_clk_disable();
  1066. audio_tx_device_id = tx_device;
  1067. audio_tx_path_id = q6_device_to_path(tx_device, acdb_id);
  1068. if (device_group != audio_tx_device_group)
  1069. _audio_tx_clk_enable();
  1070. }
  1071. static DEFINE_MUTEX(audio_path_lock);
  1072. static int audio_rx_path_refcount;
  1073. static int audio_tx_path_refcount;
  1074. static int audio_rx_path_enable(int en, uint32_t acdb_id)
  1075. {
  1076. mutex_lock(&audio_path_lock);
  1077. if (en) {
  1078. audio_rx_path_refcount++;
  1079. if (audio_rx_path_refcount == 1) {
  1080. _audio_rx_clk_enable();
  1081. _audio_rx_path_enable(0, acdb_id);
  1082. }
  1083. } else {
  1084. audio_rx_path_refcount--;
  1085. if (audio_rx_path_refcount == 0) {
  1086. _audio_rx_path_disable();
  1087. _audio_rx_clk_disable();
  1088. }
  1089. }
  1090. mutex_unlock(&audio_path_lock);
  1091. return 0;
  1092. }
  1093. static int audio_tx_path_enable(int en, uint32_t acdb_id)
  1094. {
  1095. mutex_lock(&audio_path_lock);
  1096. if (en) {
  1097. audio_tx_path_refcount++;
  1098. if (audio_tx_path_refcount == 1) {
  1099. _audio_tx_clk_enable();
  1100. _audio_tx_path_enable(0, acdb_id);
  1101. }
  1102. } else {
  1103. audio_tx_path_refcount--;
  1104. if (audio_tx_path_refcount == 0) {
  1105. _audio_tx_path_disable();
  1106. _audio_tx_clk_disable();
  1107. }
  1108. }
  1109. mutex_unlock(&audio_path_lock);
  1110. return 0;
  1111. }
  1112. int q6audio_update_acdb(uint32_t id_src, uint32_t id_dst)
  1113. {
  1114. int res;
  1115. if (q6audio_init())
  1116. return 0;
  1117. mutex_lock(&audio_path_lock);
  1118. res = audio_update_acdb(id_dst, id_src);
  1119. if (res)
  1120. goto done;
  1121. if (q6_device_to_dir(id_dst) == Q6_RX)
  1122. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_RX_DEVICE, id_dst);
  1123. else
  1124. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_TX_DEVICE, id_dst);
  1125. qdsp6_standby(ac_control);
  1126. qdsp6_start(ac_control);
  1127. done:
  1128. mutex_unlock(&audio_path_lock);
  1129. return res;
  1130. }
  1131. int q6audio_set_tx_mute(int mute)
  1132. {
  1133. uint32_t adev;
  1134. int rc;
  1135. if (q6audio_init())
  1136. return 0;
  1137. mutex_lock(&audio_path_lock);
  1138. if (mute == tx_mute_status) {
  1139. mutex_unlock(&audio_path_lock);
  1140. return 0;
  1141. }
  1142. adev = audio_tx_device_id;
  1143. rc = audio_tx_mute(ac_control, adev, mute);
  1144. if (!rc) tx_mute_status = mute;
  1145. mutex_unlock(&audio_path_lock);
  1146. return 0;
  1147. }
  1148. int q6audio_set_stream_volume(struct audio_client *ac, int vol)
  1149. {
  1150. if (vol > 1200 || vol < -4000) {
  1151. pr_err("[%s:%s] unsupported volume level %d\n", __MM_FILE__,
  1152. __func__, vol);
  1153. return -EINVAL;
  1154. }
  1155. mutex_lock(&audio_path_lock);
  1156. audio_stream_mute(ac, 0);
  1157. audio_stream_volume(ac, vol);
  1158. mutex_unlock(&audio_path_lock);
  1159. return 0;
  1160. }
  1161. int q6audio_set_rx_volume(int level)
  1162. {
  1163. uint32_t adev;
  1164. int vol;
  1165. if (q6audio_init())
  1166. return 0;
  1167. if (level < 0 || level > 100)
  1168. return -EINVAL;
  1169. mutex_lock(&audio_path_lock);
  1170. adev = ADSP_AUDIO_DEVICE_ID_VOICE;
  1171. if (level) {
  1172. vol = q6_device_volume(audio_rx_device_id, level);
  1173. audio_rx_mute(ac_control, adev, 0);
  1174. audio_rx_volume(ac_control, adev, vol);
  1175. } else
  1176. audio_rx_mute(ac_control, adev, 1);
  1177. rx_vol_level = level;
  1178. mutex_unlock(&audio_path_lock);
  1179. return 0;
  1180. }
  1181. static void do_rx_routing(uint32_t device_id, uint32_t acdb_id)
  1182. {
  1183. if (device_id == audio_rx_device_id) {
  1184. if (acdb_id != rx_acdb) {
  1185. audio_update_acdb(device_id, acdb_id);
  1186. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_RX_DEVICE, device_id);
  1187. qdsp6_standby(ac_control);
  1188. qdsp6_start(ac_control);
  1189. }
  1190. return;
  1191. }
  1192. if (audio_rx_path_refcount > 0) {
  1193. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_RX_DEVICE, device_id);
  1194. _audio_rx_path_disable();
  1195. _audio_rx_clk_reinit(device_id, acdb_id);
  1196. _audio_rx_path_enable(1, acdb_id);
  1197. } else {
  1198. audio_rx_device_id = device_id;
  1199. audio_rx_path_id = q6_device_to_path(device_id, acdb_id);
  1200. }
  1201. }
  1202. static void do_tx_routing(uint32_t device_id, uint32_t acdb_id)
  1203. {
  1204. if (device_id == audio_tx_device_id) {
  1205. if (acdb_id != tx_acdb) {
  1206. audio_update_acdb(device_id, acdb_id);
  1207. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_TX_DEVICE, device_id);
  1208. qdsp6_standby(ac_control);
  1209. qdsp6_start(ac_control);
  1210. }
  1211. return;
  1212. }
  1213. if (audio_tx_path_refcount > 0) {
  1214. qdsp6_devchg_notify(ac_control, ADSP_AUDIO_TX_DEVICE, device_id);
  1215. _audio_tx_path_disable();
  1216. _audio_tx_clk_reinit(device_id, acdb_id);
  1217. _audio_tx_path_enable(1, acdb_id);
  1218. } else {
  1219. audio_tx_device_id = device_id;
  1220. audio_tx_path_id = q6_device_to_path(device_id, acdb_id);
  1221. tx_acdb = acdb_id;
  1222. }
  1223. }
  1224. int q6audio_do_routing(uint32_t device_id, uint32_t acdb_id)
  1225. {
  1226. if (q6audio_init())
  1227. return 0;
  1228. mutex_lock(&audio_path_lock);
  1229. switch(q6_device_to_dir(device_id)) {
  1230. case Q6_RX:
  1231. do_rx_routing(device_id, acdb_id);
  1232. break;
  1233. case Q6_TX:
  1234. do_tx_routing(device_id, acdb_id);
  1235. break;
  1236. }
  1237. mutex_unlock(&audio_path_lock);
  1238. return 0;
  1239. }
  1240. int q6audio_set_route(const char *name)
  1241. {
  1242. uint32_t route;
  1243. if (!strcmp(name, "speaker")) {
  1244. route = ADIE_PATH_SPEAKER_STEREO_RX;
  1245. } else if (!strcmp(name, "headphones")) {
  1246. route = ADIE_PATH_HEADSET_STEREO_RX;
  1247. } else if (!strcmp(name, "handset")) {
  1248. route = ADIE_PATH_HANDSET_RX;
  1249. } else {
  1250. return -EINVAL;
  1251. }
  1252. mutex_lock(&audio_path_lock);
  1253. if (route == audio_rx_path_id)
  1254. goto done;
  1255. audio_rx_path_id = route;
  1256. if (audio_rx_path_refcount > 0) {
  1257. _audio_rx_path_disable();
  1258. _audio_rx_path_enable(1, 0);
  1259. }
  1260. if (audio_tx_path_refcount > 0) {
  1261. _audio_tx_path_disable();
  1262. _audio_tx_path_enable(1, 0);
  1263. }
  1264. done:
  1265. mutex_unlock(&audio_path_lock);
  1266. return 0;
  1267. }
  1268. static int audio_stream_equalizer(struct audio_client *ac, void *eq_config)
  1269. {
  1270. int i;
  1271. struct adsp_set_equalizer_command rpc;
  1272. struct adsp_audio_eq_stream_config *eq_cfg;
  1273. eq_cfg = (struct adsp_audio_eq_stream_config *) eq_config;
  1274. memset(&rpc, 0, sizeof(rpc));
  1275. rpc.hdr.opcode = ADSP_AUDIO_IOCTL_SET_SESSION_EQ_CONFIG;
  1276. rpc.enable = eq_cfg->enable;
  1277. rpc.num_bands = eq_cfg->num_bands;
  1278. for (i = 0; i < eq_cfg->num_bands; i++) {
  1279. rpc.eq_bands[i].band_idx = eq_cfg->eq_bands[i].band_idx;
  1280. rpc.eq_bands[i].filter_type = eq_cfg->eq_bands[i].filter_type;
  1281. rpc.eq_bands[i].center_freq_hz =
  1282. eq_cfg->eq_bands[i].center_freq_hz;
  1283. rpc.eq_bands[i].filter_gain = eq_cfg->eq_bands[i].filter_gain;
  1284. rpc.eq_bands[i].q_factor = eq_cfg->eq_bands[i].q_factor;
  1285. }
  1286. return audio_ioctl(ac, &rpc, sizeof(rpc));
  1287. }
  1288. int q6audio_set_stream_eq_pcm(struct audio_client *ac, void *eq_config)
  1289. {
  1290. int rc = 0;
  1291. mutex_lock(&audio_path_lock);
  1292. rc = audio_stream_equalizer(ac, eq_config);
  1293. mutex_unlock(&audio_path_lock);
  1294. return rc;
  1295. }
  1296. struct audio_client *q6audio_open_pcm(uint32_t bufsz, uint32_t rate,
  1297. uint32_t channels, uint32_t flags, uint32_t acdb_id)
  1298. {
  1299. int rc, retry = 5;
  1300. struct audio_client *ac;
  1301. if (q6audio_init())
  1302. return 0;
  1303. ac = audio_client_alloc(bufsz);
  1304. if (!ac)
  1305. return 0;
  1306. ac->flags = flags;
  1307. mutex_lock(&audio_path_lock);
  1308. if (ac->flags & AUDIO_FLAG_WRITE) {
  1309. audio_rx_path_refcount++;
  1310. if (audio_rx_path_refcount == 1) {
  1311. _audio_rx_clk_enable();
  1312. q6_rx_path_enable(0, acdb_id);
  1313. adie_rx_path_enable(acdb_id);
  1314. }
  1315. } else {
  1316. /* TODO: consider concurrency with voice call */
  1317. tx_clk_freq = rate;
  1318. audio_tx_path_refcount++;
  1319. if (audio_tx_path_refcount == 1) {
  1320. _audio_tx_clk_enable();
  1321. _audio_tx_path_enable(0, acdb_id);
  1322. }
  1323. }
  1324. for (retry = 5;;retry--) {
  1325. if (ac->flags & AUDIO_FLAG_WRITE)
  1326. rc = audio_out_open(ac, bufsz, rate, channels);
  1327. else
  1328. rc = audio_in_open(ac, bufsz, flags, rate, channels);
  1329. if (rc == 0)
  1330. break;
  1331. if (retry == 0)
  1332. q6audio_dsp_not_responding();
  1333. pr_err("[%s:%s] open pcm error %d, retrying\n",
  1334. __MM_FILE__, __func__, rc);
  1335. msleep(1);
  1336. }
  1337. if (ac->flags & AUDIO_FLAG_WRITE) {
  1338. if (audio_rx_path_refcount == 1)
  1339. audio_rx_analog_enable(1);
  1340. }
  1341. mutex_unlock(&audio_path_lock);
  1342. for (retry = 5;;retry--) {
  1343. rc = audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1344. if (rc == 0)
  1345. break;
  1346. if (retry == 0)
  1347. q6audio_dsp_not_responding();
  1348. pr_err("[%s:%s] stream start error %d, retrying\n",
  1349. __MM_FILE__, __func__, rc);
  1350. }
  1351. if (!(ac->flags & AUDIO_FLAG_WRITE)) {
  1352. ac->buf[0].used = 1;
  1353. ac->buf[1].used = 1;
  1354. q6audio_read(ac, &ac->buf[0]);
  1355. q6audio_read(ac, &ac->buf[1]);
  1356. }
  1357. audio_prevent_sleep();
  1358. return ac;
  1359. }
  1360. int q6audio_close(struct audio_client *ac)
  1361. {
  1362. audio_close(ac);
  1363. if (ac->flags & AUDIO_FLAG_WRITE)
  1364. audio_rx_path_enable(0, 0);
  1365. else
  1366. audio_tx_path_enable(0, 0);
  1367. audio_client_free(ac);
  1368. audio_allow_sleep();
  1369. return 0;
  1370. }
  1371. struct audio_client *q6voice_open(uint32_t flags)
  1372. {
  1373. struct audio_client *ac;
  1374. if (q6audio_init())
  1375. return 0;
  1376. ac = audio_client_alloc(0);
  1377. if (!ac)
  1378. return 0;
  1379. ac->flags = flags;
  1380. if (ac->flags & AUDIO_FLAG_WRITE)
  1381. audio_rx_path_enable(1, rx_acdb);
  1382. else {
  1383. tx_clk_freq = 8000;
  1384. audio_tx_path_enable(1, tx_acdb);
  1385. }
  1386. return ac;
  1387. }
  1388. int q6voice_close(struct audio_client *ac)
  1389. {
  1390. if (ac->flags & AUDIO_FLAG_WRITE)
  1391. audio_rx_path_enable(0, 0);
  1392. else
  1393. audio_tx_path_enable(0, 0);
  1394. audio_client_free(ac);
  1395. return 0;
  1396. }
  1397. struct audio_client *q6audio_open_mp3(uint32_t bufsz, uint32_t rate,
  1398. uint32_t channels, uint32_t acdb_id)
  1399. {
  1400. struct audio_client *ac;
  1401. TRACE("q6audio_open_mp3()\n");
  1402. if (q6audio_init())
  1403. return 0;
  1404. ac = audio_client_alloc(bufsz);
  1405. if (!ac)
  1406. return 0;
  1407. ac->flags = AUDIO_FLAG_WRITE;
  1408. audio_rx_path_enable(1, acdb_id);
  1409. audio_mp3_open(ac, bufsz, rate, channels);
  1410. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1411. mutex_lock(&audio_path_lock);
  1412. audio_rx_mute(ac_control, audio_rx_device_id, 0);
  1413. audio_rx_volume(ac_control, audio_rx_device_id,
  1414. q6_device_volume(audio_rx_device_id, rx_vol_level));
  1415. mutex_unlock(&audio_path_lock);
  1416. return ac;
  1417. }
  1418. struct audio_client *q6audio_open_dtmf(uint32_t rate,
  1419. uint32_t channels, uint32_t acdb_id)
  1420. {
  1421. struct audio_client *ac;
  1422. if (q6audio_init())
  1423. return 0;
  1424. ac = audio_client_alloc(0);
  1425. if (!ac)
  1426. return 0;
  1427. ac->flags = AUDIO_FLAG_WRITE;
  1428. audio_rx_path_enable(1, acdb_id);
  1429. audio_dtmf_open(ac, rate, channels);
  1430. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1431. mutex_lock(&audio_path_lock);
  1432. audio_rx_mute(ac_control, audio_rx_device_id, 0);
  1433. audio_rx_volume(ac_control, audio_rx_device_id,
  1434. q6_device_volume(audio_rx_device_id, rx_vol_level));
  1435. mutex_unlock(&audio_path_lock);
  1436. return ac;
  1437. }
  1438. int q6audio_play_dtmf(struct audio_client *ac, uint16_t dtmf_hi,
  1439. uint16_t dtmf_low, uint16_t duration, uint16_t rx_gain)
  1440. {
  1441. struct adsp_audio_dtmf_start_command dtmf_cmd;
  1442. dtmf_cmd.hdr.opcode = ADSP_AUDIO_IOCTL_CMD_SESSION_DTMF_START;
  1443. dtmf_cmd.hdr.response_type = ADSP_AUDIO_RESPONSE_COMMAND;
  1444. dtmf_cmd.tone1_hz = dtmf_hi;
  1445. dtmf_cmd.tone2_hz = dtmf_low;
  1446. dtmf_cmd.duration_usec = duration * 1000;
  1447. dtmf_cmd.gain_mb = rx_gain;
  1448. return audio_ioctl(ac, &dtmf_cmd,
  1449. sizeof(struct adsp_audio_dtmf_start_command));
  1450. }
  1451. int q6audio_mp3_close(struct audio_client *ac)
  1452. {
  1453. audio_close(ac);
  1454. audio_rx_path_enable(0, 0);
  1455. audio_client_free(ac);
  1456. return 0;
  1457. }
  1458. struct audio_client *q6audio_open_aac(uint32_t bufsz, uint32_t samplerate,
  1459. uint32_t channels, uint32_t bitrate,
  1460. uint32_t stream_format, uint32_t flags,
  1461. uint32_t acdb_id)
  1462. {
  1463. struct audio_client *ac;
  1464. TRACE("q6audio_open_aac()\n");
  1465. if (q6audio_init())
  1466. return 0;
  1467. ac = audio_client_alloc(bufsz);
  1468. if (!ac)
  1469. return 0;
  1470. ac->flags = flags;
  1471. if (ac->flags & AUDIO_FLAG_WRITE)
  1472. audio_rx_path_enable(1, acdb_id);
  1473. else{
  1474. tx_clk_freq = 48000;
  1475. audio_tx_path_enable(1, acdb_id);
  1476. }
  1477. audio_aac_open(ac, bufsz, samplerate, channels, bitrate, flags,
  1478. stream_format);
  1479. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1480. if (!(ac->flags & AUDIO_FLAG_WRITE)) {
  1481. ac->buf[0].used = 1;
  1482. ac->buf[1].used = 1;
  1483. q6audio_read(ac, &ac->buf[0]);
  1484. q6audio_read(ac, &ac->buf[1]);
  1485. }
  1486. audio_prevent_sleep();
  1487. return ac;
  1488. }
  1489. struct audio_client *q6audio_open_qcp(uint32_t bufsz, uint32_t min_rate,
  1490. uint32_t max_rate, uint32_t flags,
  1491. uint32_t format, uint32_t acdb_id)
  1492. {
  1493. struct audio_client *ac;
  1494. TRACE("q6audio_open_evrc()\n");
  1495. if (q6audio_init())
  1496. return 0;
  1497. ac = audio_client_alloc(bufsz);
  1498. if (!ac)
  1499. return 0;
  1500. ac->flags = flags;
  1501. if (ac->flags & AUDIO_FLAG_WRITE)
  1502. audio_rx_path_enable(1, acdb_id);
  1503. else{
  1504. tx_clk_freq = 8000;
  1505. audio_tx_path_enable(1, acdb_id);
  1506. }
  1507. audio_qcp_open(ac, bufsz, min_rate, max_rate, flags, format);
  1508. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1509. if (!(ac->flags & AUDIO_FLAG_WRITE)) {
  1510. ac->buf[0].used = 1;
  1511. ac->buf[1].used = 1;
  1512. q6audio_read(ac, &ac->buf[0]);
  1513. q6audio_read(ac, &ac->buf[1]);
  1514. }
  1515. audio_prevent_sleep();
  1516. return ac;
  1517. }
  1518. struct audio_client *q6audio_open_amrnb(uint32_t bufsz, uint32_t enc_mode,
  1519. uint32_t dtx_mode_enable,
  1520. uint32_t flags, uint32_t acdb_id)
  1521. {
  1522. struct audio_client *ac;
  1523. TRACE("q6audio_open_amrnb()\n");
  1524. if (q6audio_init())
  1525. return 0;
  1526. ac = audio_client_alloc(bufsz);
  1527. if (!ac)
  1528. return 0;
  1529. ac->flags = flags;
  1530. if (ac->flags & AUDIO_FLAG_WRITE)
  1531. audio_rx_path_enable(1, acdb_id);
  1532. else{
  1533. tx_clk_freq = 8000;
  1534. audio_tx_path_enable(1, acdb_id);
  1535. }
  1536. audio_amrnb_open(ac, bufsz, enc_mode, flags, dtx_mode_enable);
  1537. audio_command(ac, ADSP_AUDIO_IOCTL_CMD_SESSION_START);
  1538. if (!(ac->flags & AUDIO_FLAG_WRITE)) {
  1539. ac->buf[0].used = 1;
  1540. ac->buf[1].used = 1;
  1541. q6audio_read(ac, &ac->buf[0]);
  1542. q6audio_read(ac, &ac->buf[1]);
  1543. }
  1544. audio_prevent_sleep();
  1545. return ac;
  1546. }
  1547. int q6audio_async(struct audio_client *ac)
  1548. {
  1549. struct adsp_command_hdr rpc;
  1550. memset(&rpc, 0, sizeof(rpc));
  1551. rpc.opcode = ADSP_AUDIO_IOCTL_CMD_STREAM_EOS;
  1552. rpc.response_type = ADSP_AUDIO_RESPONSE_ASYNC;
  1553. return audio_ioctl(ac, &rpc, sizeof(rpc));
  1554. }