/arch/arm/mach-msm/qdsp5v2/audio_a2dp_in.c

https://bitbucket.org/sammyz/iscream_thunderc-2.6.35-rebase · C · 945 lines · 779 code · 100 blank · 66 comment · 104 complexity · 4a5a0248fb0f38b6421554afa8b01647 MD5 · raw file

  1. /* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
  2. *
  3. * sbc/pcm audio input driver
  4. * Based on the pcm input driver in arch/arm/mach-msm/qdsp5v2/audio_pcm_in.c
  5. *
  6. * Copyright (C) 2008 HTC Corporation
  7. * Copyright (C) 2008 Google, Inc.
  8. *
  9. * All source code in this file is licensed under the following license except
  10. * where indicated.
  11. *
  12. * This program is free software; you can redistribute it and/or modify it
  13. * under the terms of the GNU General Public License version 2 as published
  14. * by the Free Software Foundation.
  15. *
  16. * This software is licensed under the terms of the GNU General Public
  17. * License version 2, as published by the Free Software Foundation, and
  18. * may be copied, distributed, and modified under those terms.
  19. *
  20. * This program is distributed in the hope that it will be useful,
  21. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23. * GNU General Public License for more details.
  24. *
  25. */
  26. #include <linux/module.h>
  27. #include <linux/fs.h>
  28. #include <linux/miscdevice.h>
  29. #include <linux/uaccess.h>
  30. #include <linux/sched.h>
  31. #include <linux/wait.h>
  32. #include <linux/dma-mapping.h>
  33. #include <linux/msm_audio.h>
  34. #include <linux/msm_audio_sbc.h>
  35. #include <asm/atomic.h>
  36. #include <asm/ioctls.h>
  37. #include <mach/msm_adsp.h>
  38. #include <mach/qdsp5v2/qdsp5audreccmdi.h>
  39. #include <mach/qdsp5v2/qdsp5audrecmsg.h>
  40. #include <mach/qdsp5v2/audpreproc.h>
  41. #include <mach/qdsp5v2/audio_dev_ctl.h>
  42. #include <mach/debug_mm.h>
  43. /* FRAME_NUM must be a power of two */
  44. #define FRAME_NUM (8)
  45. #define FRAME_SIZE (2052 * 2)
  46. #define FRAME_SIZE_SBC (768 * 2)
  47. #define MONO_DATA_SIZE (2048)
  48. #define STEREO_DATA_SIZE (MONO_DATA_SIZE * 2)
  49. #define DMASZ (FRAME_SIZE * FRAME_NUM)
  50. struct buffer {
  51. void *data;
  52. uint32_t size;
  53. uint32_t read;
  54. uint32_t addr;
  55. uint32_t frame_num;
  56. uint32_t frame_len;
  57. };
  58. struct audio_a2dp_in {
  59. struct buffer in[FRAME_NUM];
  60. spinlock_t dsp_lock;
  61. atomic_t in_bytes;
  62. atomic_t in_samples;
  63. struct mutex lock;
  64. struct mutex read_lock;
  65. wait_queue_head_t wait;
  66. wait_queue_head_t wait_enable;
  67. struct msm_adsp_module *audrec;
  68. /* configuration to use on next enable */
  69. uint32_t samp_rate;
  70. uint32_t channel_mode;
  71. uint32_t buffer_size; /* 2048 for mono, 4096 for stereo */
  72. uint32_t enc_type;
  73. struct msm_audio_sbc_enc_config cfg;
  74. uint32_t dsp_cnt;
  75. uint32_t in_head; /* next buffer dsp will write */
  76. uint32_t in_tail; /* next buffer read() will read */
  77. uint32_t in_count; /* number of buffers available to read() */
  78. uint32_t mode;
  79. const char *module_name;
  80. unsigned queue_ids;
  81. uint16_t enc_id; /* Session Id */
  82. uint16_t source; /* Encoding source bit mask */
  83. uint32_t device_events; /* device events interested in */
  84. uint32_t dev_cnt;
  85. spinlock_t dev_lock;
  86. /* data allocated for various buffers */
  87. char *data;
  88. dma_addr_t phys;
  89. int opened;
  90. int enabled;
  91. int running;
  92. int stopped; /* set when stopped, cleared on flush */
  93. int abort; /* set when error, like sample rate mismatch */
  94. };
  95. static struct audio_a2dp_in the_audio_a2dp_in;
  96. struct wav_frame {
  97. uint16_t frame_count_lsw;
  98. uint16_t frame_count_msw;
  99. uint16_t frame_length;
  100. uint16_t erased_a2dp;
  101. unsigned char raw_bitstream[]; /* samples */
  102. };
  103. struct sbc_frame {
  104. uint16_t bit_rate_msw;
  105. uint16_t bit_rate_lsw;
  106. uint16_t frame_length;
  107. uint16_t frame_num;
  108. unsigned char raw_bitstream[]; /* samples */
  109. };
  110. struct audio_frame {
  111. union {
  112. struct wav_frame wav;
  113. struct sbc_frame sbc;
  114. } a2dp;
  115. } __attribute__((packed));
  116. /* Audrec Queue command sent macro's */
  117. #define audrec_send_bitstreamqueue(audio, cmd, len) \
  118. msm_adsp_write(audio->audrec, ((audio->queue_ids & 0xFFFF0000) >> 16),\
  119. cmd, len)
  120. #define audrec_send_audrecqueue(audio, cmd, len) \
  121. msm_adsp_write(audio->audrec, (audio->queue_ids & 0x0000FFFF),\
  122. cmd, len)
  123. /* DSP command send functions */
  124. static int auda2dp_in_enc_config(struct audio_a2dp_in *audio, int enable);
  125. static int auda2dp_in_param_config(struct audio_a2dp_in *audio);
  126. static int auda2dp_in_mem_config(struct audio_a2dp_in *audio);
  127. static int auda2dp_in_record_config(struct audio_a2dp_in *audio, int enable);
  128. static int auda2dp_dsp_read_buffer(struct audio_a2dp_in *audio,
  129. uint32_t read_cnt);
  130. static void auda2dp_in_get_dsp_frames(struct audio_a2dp_in *audio);
  131. static void auda2dp_in_flush(struct audio_a2dp_in *audio);
  132. static void a2dp_in_listener(u32 evt_id, union auddev_evt_data *evt_payload,
  133. void *private_data)
  134. {
  135. struct audio_a2dp_in *audio = (struct audio_a2dp_in *) private_data;
  136. unsigned long flags;
  137. MM_DBG("evt_id = 0x%8x\n", evt_id);
  138. switch (evt_id) {
  139. case AUDDEV_EVT_DEV_RDY: {
  140. MM_DBG("AUDDEV_EVT_DEV_RDY\n");
  141. spin_lock_irqsave(&audio->dev_lock, flags);
  142. audio->dev_cnt++;
  143. audio->source |= (0x1 << evt_payload->routing_id);
  144. spin_unlock_irqrestore(&audio->dev_lock, flags);
  145. if ((audio->running == 1) && (audio->enabled == 1))
  146. auda2dp_in_record_config(audio, 1);
  147. break;
  148. }
  149. case AUDDEV_EVT_DEV_RLS: {
  150. MM_DBG("AUDDEV_EVT_DEV_RLS\n");
  151. spin_lock_irqsave(&audio->dev_lock, flags);
  152. audio->dev_cnt--;
  153. audio->source &= ~(0x1 << evt_payload->routing_id);
  154. spin_unlock_irqrestore(&audio->dev_lock, flags);
  155. if (!audio->running || !audio->enabled)
  156. break;
  157. /* Turn of as per source */
  158. if (audio->source)
  159. auda2dp_in_record_config(audio, 1);
  160. else
  161. /* Turn off all */
  162. auda2dp_in_record_config(audio, 0);
  163. break;
  164. }
  165. case AUDDEV_EVT_FREQ_CHG: {
  166. MM_DBG("Encoder Driver got sample rate change event\n");
  167. MM_DBG("sample rate %d\n", evt_payload->freq_info.sample_rate);
  168. MM_DBG("dev_type %d\n", evt_payload->freq_info.dev_type);
  169. MM_DBG("acdb_dev_id %d\n", evt_payload->freq_info.acdb_dev_id);
  170. if (audio->running == 1) {
  171. /* Stop Recording sample rate does not match
  172. with device sample rate */
  173. if (evt_payload->freq_info.sample_rate !=
  174. audio->samp_rate) {
  175. auda2dp_in_record_config(audio, 0);
  176. audio->abort = 1;
  177. wake_up(&audio->wait);
  178. }
  179. }
  180. break;
  181. }
  182. default:
  183. MM_ERR("wrong event %d\n", evt_id);
  184. break;
  185. }
  186. }
  187. /* ------------------- dsp preproc event handler--------------------- */
  188. static void audpreproc_dsp_event(void *data, unsigned id, void *msg)
  189. {
  190. struct audio_a2dp_in *audio = data;
  191. switch (id) {
  192. case AUDPREPROC_ERROR_MSG: {
  193. struct audpreproc_err_msg *err_msg = msg;
  194. MM_ERR("ERROR_MSG: stream id %d err idx %d\n",
  195. err_msg->stream_id, err_msg->aud_preproc_err_idx);
  196. /* Error case */
  197. wake_up(&audio->wait_enable);
  198. break;
  199. }
  200. case AUDPREPROC_CMD_CFG_DONE_MSG: {
  201. MM_DBG("CMD_CFG_DONE_MSG \n");
  202. break;
  203. }
  204. case AUDPREPROC_CMD_ENC_CFG_DONE_MSG: {
  205. struct audpreproc_cmd_enc_cfg_done_msg *enc_cfg_msg = msg;
  206. MM_DBG("CMD_ENC_CFG_DONE_MSG: stream id %d enc type \
  207. 0x%8x\n", enc_cfg_msg->stream_id,
  208. enc_cfg_msg->rec_enc_type);
  209. /* Encoder enable success */
  210. if (enc_cfg_msg->rec_enc_type & ENCODE_ENABLE)
  211. auda2dp_in_param_config(audio);
  212. else { /* Encoder disable success */
  213. audio->running = 0;
  214. auda2dp_in_record_config(audio, 0);
  215. }
  216. break;
  217. }
  218. case AUDPREPROC_CMD_ENC_PARAM_CFG_DONE_MSG: {
  219. MM_DBG("CMD_ENC_PARAM_CFG_DONE_MSG \n");
  220. auda2dp_in_mem_config(audio);
  221. break;
  222. }
  223. case AUDPREPROC_AFE_CMD_AUDIO_RECORD_CFG_DONE_MSG: {
  224. MM_DBG("AFE_CMD_AUDIO_RECORD_CFG_DONE_MSG \n");
  225. wake_up(&audio->wait_enable);
  226. break;
  227. }
  228. default:
  229. MM_ERR("Unknown Event id %d\n", id);
  230. }
  231. }
  232. /* ------------------- dsp audrec event handler--------------------- */
  233. static void audrec_dsp_event(void *data, unsigned id, size_t len,
  234. void (*getevent)(void *ptr, size_t len))
  235. {
  236. struct audio_a2dp_in *audio = data;
  237. switch (id) {
  238. case AUDREC_CMD_MEM_CFG_DONE_MSG: {
  239. MM_DBG("CMD_MEM_CFG_DONE MSG DONE\n");
  240. audio->running = 1;
  241. if (audio->dev_cnt > 0)
  242. auda2dp_in_record_config(audio, 1);
  243. break;
  244. }
  245. case AUDREC_FATAL_ERR_MSG: {
  246. struct audrec_fatal_err_msg fatal_err_msg;
  247. getevent(&fatal_err_msg, AUDREC_FATAL_ERR_MSG_LEN);
  248. MM_ERR("FATAL_ERR_MSG: err id %d\n",
  249. fatal_err_msg.audrec_err_id);
  250. /* Error stop the encoder */
  251. audio->stopped = 1;
  252. wake_up(&audio->wait);
  253. break;
  254. }
  255. case AUDREC_UP_PACKET_READY_MSG: {
  256. struct audrec_up_pkt_ready_msg pkt_ready_msg;
  257. getevent(&pkt_ready_msg, AUDREC_UP_PACKET_READY_MSG_LEN);
  258. MM_DBG("UP_PACKET_READY_MSG: write cnt lsw %d \
  259. write cnt msw %d read cnt lsw %d read cnt msw %d \n",\
  260. pkt_ready_msg.audrec_packet_write_cnt_lsw, \
  261. pkt_ready_msg.audrec_packet_write_cnt_msw, \
  262. pkt_ready_msg.audrec_up_prev_read_cnt_lsw, \
  263. pkt_ready_msg.audrec_up_prev_read_cnt_msw);
  264. auda2dp_in_get_dsp_frames(audio);
  265. break;
  266. }
  267. default:
  268. MM_ERR("Unknown Event id %d\n", id);
  269. }
  270. }
  271. static void auda2dp_in_get_dsp_frames(struct audio_a2dp_in *audio)
  272. {
  273. struct audio_frame *frame;
  274. uint32_t index;
  275. unsigned long flags;
  276. index = audio->in_head;
  277. frame = (void *) (((char *)audio->in[index].data) - \
  278. sizeof(*frame));
  279. spin_lock_irqsave(&audio->dsp_lock, flags);
  280. if (audio->enc_type == ENC_TYPE_WAV)
  281. audio->in[index].size = frame->a2dp.wav.frame_length;
  282. else if (audio->enc_type == ENC_TYPE_SBC) {
  283. audio->in[index].size = frame->a2dp.sbc.frame_length *
  284. frame->a2dp.sbc.frame_num;
  285. audio->in[index].frame_num = frame->a2dp.sbc.frame_num;
  286. audio->in[index].frame_len = frame->a2dp.sbc.frame_length;
  287. }
  288. /* statistics of read */
  289. atomic_add(audio->in[index].size, &audio->in_bytes);
  290. atomic_add(1, &audio->in_samples);
  291. audio->in_head = (audio->in_head + 1) & (FRAME_NUM - 1);
  292. /* If overflow, move the tail index foward. */
  293. if (audio->in_head == audio->in_tail)
  294. audio->in_tail = (audio->in_tail + 1) & (FRAME_NUM - 1);
  295. else
  296. audio->in_count++;
  297. auda2dp_dsp_read_buffer(audio, audio->dsp_cnt++);
  298. spin_unlock_irqrestore(&audio->dsp_lock, flags);
  299. wake_up(&audio->wait);
  300. }
  301. static struct msm_adsp_ops audrec_adsp_ops = {
  302. .event = audrec_dsp_event,
  303. };
  304. static int auda2dp_in_enc_config(struct audio_a2dp_in *audio, int enable)
  305. {
  306. struct audpreproc_audrec_cmd_enc_cfg cmd;
  307. memset(&cmd, 0, sizeof(cmd));
  308. cmd.cmd_id = AUDPREPROC_AUDREC_CMD_ENC_CFG;
  309. cmd.stream_id = audio->enc_id;
  310. if (enable)
  311. cmd.audrec_enc_type = audio->enc_type | ENCODE_ENABLE;
  312. else
  313. cmd.audrec_enc_type &= ~(ENCODE_ENABLE);
  314. return audpreproc_send_audreccmdqueue(&cmd, sizeof(cmd));
  315. }
  316. static int auda2dp_in_param_config(struct audio_a2dp_in *audio)
  317. {
  318. if (audio->enc_type == ENC_TYPE_WAV) {
  319. struct audpreproc_audrec_cmd_parm_cfg_wav cmd;
  320. memset(&cmd, 0, sizeof(cmd));
  321. cmd.common.cmd_id = AUDPREPROC_AUDREC_CMD_PARAM_CFG;
  322. cmd.common.stream_id = audio->enc_id;
  323. cmd.aud_rec_samplerate_idx = audio->samp_rate;
  324. cmd.aud_rec_stereo_mode = audio->channel_mode;
  325. return audpreproc_send_audreccmdqueue(&cmd, sizeof(cmd));
  326. } else if (audio->enc_type == ENC_TYPE_SBC) {
  327. struct audpreproc_audrec_cmd_parm_cfg_sbc cmd;
  328. memset(&cmd, 0, sizeof(cmd));
  329. cmd.common.cmd_id = AUDPREPROC_AUDREC_CMD_PARAM_CFG;
  330. cmd.common.stream_id = audio->enc_id;
  331. cmd.aud_rec_sbc_enc_param =
  332. (audio->cfg.number_of_blocks <<
  333. AUDREC_SBC_ENC_PARAM_NUM_SUB_BLOCKS_MASK) |
  334. (audio->cfg.number_of_subbands <<
  335. AUDREC_SBC_ENC_PARAM_NUM_SUB_BANDS_MASK) |
  336. (audio->cfg.mode <<
  337. AUDREC_SBC_ENC_PARAM_MODE_MASK) |
  338. (audio->cfg.bit_allocation <<
  339. AUDREC_SBC_ENC_PARAM_BIT_ALLOC_MASK);
  340. cmd.aud_rec_sbc_bit_rate_msw =
  341. (audio->cfg.bit_rate & 0xFFFF0000) >> 16;
  342. cmd.aud_rec_sbc_bit_rate_lsw =
  343. (audio->cfg.bit_rate & 0xFFFF);
  344. return audpreproc_send_audreccmdqueue(&cmd, sizeof(cmd));
  345. }
  346. return 0;
  347. }
  348. /* To Do: msm_snddev_route_enc(audio->enc_id); */
  349. static int auda2dp_in_record_config(struct audio_a2dp_in *audio, int enable)
  350. {
  351. struct audpreproc_afe_cmd_audio_record_cfg cmd;
  352. memset(&cmd, 0, sizeof(cmd));
  353. cmd.cmd_id = AUDPREPROC_AFE_CMD_AUDIO_RECORD_CFG;
  354. cmd.stream_id = audio->enc_id;
  355. if (enable)
  356. cmd.destination_activity = AUDIO_RECORDING_TURN_ON;
  357. else
  358. cmd.destination_activity = AUDIO_RECORDING_TURN_OFF;
  359. cmd.source_mix_mask = audio->source;
  360. if (audio->enc_id == 2) {
  361. if ((cmd.source_mix_mask &
  362. INTERNAL_CODEC_TX_SOURCE_MIX_MASK) ||
  363. (cmd.source_mix_mask & AUX_CODEC_TX_SOURCE_MIX_MASK) ||
  364. (cmd.source_mix_mask & VOICE_UL_SOURCE_MIX_MASK) ||
  365. (cmd.source_mix_mask & VOICE_DL_SOURCE_MIX_MASK)) {
  366. cmd.pipe_id = SOURCE_PIPE_1;
  367. }
  368. if (cmd.source_mix_mask &
  369. AUDPP_A2DP_PIPE_SOURCE_MIX_MASK)
  370. cmd.pipe_id |= SOURCE_PIPE_0;
  371. }
  372. return audpreproc_send_audreccmdqueue(&cmd, sizeof(cmd));
  373. }
  374. static int auda2dp_in_mem_config(struct audio_a2dp_in *audio)
  375. {
  376. struct audrec_cmd_arecmem_cfg cmd;
  377. uint16_t *data = (void *) audio->data;
  378. int n;
  379. memset(&cmd, 0, sizeof(cmd));
  380. cmd.cmd_id = AUDREC_CMD_MEM_CFG_CMD;
  381. cmd.audrec_up_pkt_intm_count = 1;
  382. cmd.audrec_ext_pkt_start_addr_msw = audio->phys >> 16;
  383. cmd.audrec_ext_pkt_start_addr_lsw = audio->phys;
  384. cmd.audrec_ext_pkt_buf_number = FRAME_NUM;
  385. /* prepare buffer pointers:
  386. * Wav:
  387. * Mono: 1024 samples + 4 halfword header
  388. * Stereo: 2048 samples + 4 halfword header
  389. * SBC:
  390. * 768 + 4 halfword header
  391. */
  392. if (audio->enc_type == ENC_TYPE_SBC) {
  393. for (n = 0; n < FRAME_NUM; n++) {
  394. audio->in[n].data = data + 4;
  395. data += (4 + (FRAME_SIZE_SBC/2));
  396. MM_DBG("0x%8x\n", (int)(audio->in[n].data - 8));
  397. }
  398. } else if (audio->enc_type == ENC_TYPE_WAV) {
  399. for (n = 0; n < FRAME_NUM; n++) {
  400. audio->in[n].data = data + 4;
  401. data += (4 + (audio->channel_mode ? 2048 : 1024));
  402. MM_DBG("0x%8x\n", (int)(audio->in[n].data - 8));
  403. }
  404. }
  405. return audrec_send_audrecqueue(audio, &cmd, sizeof(cmd));
  406. }
  407. static int auda2dp_dsp_read_buffer(struct audio_a2dp_in *audio,
  408. uint32_t read_cnt)
  409. {
  410. struct up_audrec_packet_ext_ptr cmd;
  411. memset(&cmd, 0, sizeof(cmd));
  412. cmd.cmd_id = UP_AUDREC_PACKET_EXT_PTR;
  413. cmd.audrec_up_curr_read_count_msw = read_cnt >> 16;
  414. cmd.audrec_up_curr_read_count_lsw = read_cnt;
  415. return audrec_send_bitstreamqueue(audio, &cmd, sizeof(cmd));
  416. }
  417. /* must be called with audio->lock held */
  418. static int auda2dp_in_enable(struct audio_a2dp_in *audio)
  419. {
  420. if (audio->enabled)
  421. return 0;
  422. if (audpreproc_enable(audio->enc_id, &audpreproc_dsp_event, audio)) {
  423. MM_ERR("msm_adsp_enable(audpreproc) failed\n");
  424. return -ENODEV;
  425. }
  426. if (msm_adsp_enable(audio->audrec)) {
  427. MM_ERR("msm_adsp_enable(audrec) failed\n");
  428. audpreproc_disable(audio->enc_id, audio);
  429. return -ENODEV;
  430. }
  431. audio->enabled = 1;
  432. auda2dp_in_enc_config(audio, 1);
  433. return 0;
  434. }
  435. /* must be called with audio->lock held */
  436. static int auda2dp_in_disable(struct audio_a2dp_in *audio)
  437. {
  438. if (audio->enabled) {
  439. audio->enabled = 0;
  440. auda2dp_in_enc_config(audio, 0);
  441. wake_up(&audio->wait);
  442. wait_event_interruptible_timeout(audio->wait_enable,
  443. audio->running == 0, 1*HZ);
  444. msm_adsp_disable(audio->audrec);
  445. audpreproc_disable(audio->enc_id, audio);
  446. }
  447. return 0;
  448. }
  449. static void auda2dp_in_flush(struct audio_a2dp_in *audio)
  450. {
  451. int i;
  452. audio->dsp_cnt = 0;
  453. audio->in_head = 0;
  454. audio->in_tail = 0;
  455. audio->in_count = 0;
  456. for (i = 0; i < FRAME_NUM; i++) {
  457. audio->in[i].size = 0;
  458. audio->in[i].read = 0;
  459. }
  460. MM_DBG("in_bytes %d\n", atomic_read(&audio->in_bytes));
  461. MM_DBG("in_samples %d\n", atomic_read(&audio->in_samples));
  462. atomic_set(&audio->in_bytes, 0);
  463. atomic_set(&audio->in_samples, 0);
  464. }
  465. /* ------------------- device --------------------- */
  466. static long auda2dp_in_ioctl(struct file *file,
  467. unsigned int cmd, unsigned long arg)
  468. {
  469. struct audio_a2dp_in *audio = file->private_data;
  470. int rc = 0;
  471. if (cmd == AUDIO_GET_STATS) {
  472. struct msm_audio_stats stats;
  473. stats.byte_count = atomic_read(&audio->in_bytes);
  474. stats.sample_count = atomic_read(&audio->in_samples);
  475. if (copy_to_user((void *) arg, &stats, sizeof(stats)))
  476. return -EFAULT;
  477. return rc;
  478. }
  479. mutex_lock(&audio->lock);
  480. switch (cmd) {
  481. case AUDIO_START: {
  482. uint32_t freq;
  483. /* Poll at 48KHz always */
  484. freq = 48000;
  485. MM_DBG("AUDIO_START\n");
  486. rc = msm_snddev_request_freq(&freq, audio->enc_id,
  487. SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
  488. MM_DBG("sample rate configured %d sample rate requested %d\n",
  489. freq, audio->samp_rate);
  490. if (rc < 0) {
  491. MM_DBG("sample rate can not be set, return code %d\n",\
  492. rc);
  493. msm_snddev_withdraw_freq(audio->enc_id,
  494. SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
  495. MM_DBG("msm_snddev_withdraw_freq\n");
  496. break;
  497. }
  498. rc = auda2dp_in_enable(audio);
  499. if (!rc) {
  500. rc =
  501. wait_event_interruptible_timeout(audio->wait_enable,
  502. audio->running != 0, 1*HZ);
  503. MM_DBG("state %d rc = %d\n", audio->running, rc);
  504. if (audio->running == 0) {
  505. rc = -ENODEV;
  506. msm_snddev_withdraw_freq(audio->enc_id,
  507. SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
  508. MM_DBG("msm_snddev_withdraw_freq\n");
  509. } else
  510. rc = 0;
  511. }
  512. audio->stopped = 0;
  513. break;
  514. }
  515. case AUDIO_STOP: {
  516. rc = auda2dp_in_disable(audio);
  517. rc = msm_snddev_withdraw_freq(audio->enc_id,
  518. SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
  519. MM_DBG("msm_snddev_withdraw_freq\n");
  520. audio->stopped = 1;
  521. audio->abort = 0;
  522. break;
  523. }
  524. case AUDIO_FLUSH: {
  525. if (audio->stopped) {
  526. /* Make sure we're stopped and we wake any threads
  527. * that might be blocked holding the read_lock.
  528. * While audio->stopped read threads will always
  529. * exit immediately.
  530. */
  531. wake_up(&audio->wait);
  532. mutex_lock(&audio->read_lock);
  533. auda2dp_in_flush(audio);
  534. mutex_unlock(&audio->read_lock);
  535. }
  536. break;
  537. }
  538. case AUDIO_SET_STREAM_CONFIG: {
  539. struct msm_audio_stream_config cfg;
  540. if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
  541. rc = -EFAULT;
  542. break;
  543. }
  544. /* Allow only single frame */
  545. if ((audio->enc_type == ENC_TYPE_SBC) &&
  546. (cfg.buffer_size != FRAME_SIZE_SBC))
  547. rc = -EINVAL;
  548. else
  549. audio->buffer_size = cfg.buffer_size;
  550. break;
  551. }
  552. case AUDIO_GET_STREAM_CONFIG: {
  553. struct msm_audio_stream_config cfg;
  554. memset(&cfg, 0, sizeof(cfg));
  555. if (audio->enc_type == ENC_TYPE_SBC)
  556. cfg.buffer_size = FRAME_SIZE_SBC;
  557. else
  558. cfg.buffer_size = MONO_DATA_SIZE;
  559. cfg.buffer_count = FRAME_NUM;
  560. if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
  561. rc = -EFAULT;
  562. break;
  563. }
  564. case AUDIO_SET_SBC_ENC_CONFIG: {
  565. if (copy_from_user(&audio->cfg, (void *) arg,
  566. sizeof(audio->cfg))) {
  567. rc = -EFAULT;
  568. break;
  569. }
  570. audio->samp_rate = audio->cfg.sample_rate;
  571. audio->channel_mode = audio->cfg.channels;
  572. audio->enc_type = ENC_TYPE_SBC;
  573. break;
  574. }
  575. case AUDIO_SET_CONFIG: {
  576. struct msm_audio_config cfg;
  577. if (copy_from_user(&cfg, (void *) arg, sizeof(cfg))) {
  578. rc = -EFAULT;
  579. break;
  580. }
  581. if (cfg.channel_count == 1) {
  582. cfg.channel_count = AUDREC_CMD_MODE_MONO;
  583. audio->buffer_size = MONO_DATA_SIZE;
  584. } else if (cfg.channel_count == 2) {
  585. cfg.channel_count = AUDREC_CMD_MODE_STEREO;
  586. audio->buffer_size = STEREO_DATA_SIZE;
  587. } else {
  588. rc = -EINVAL;
  589. break;
  590. }
  591. audio->samp_rate = cfg.sample_rate;
  592. audio->channel_mode = cfg.channel_count;
  593. audio->enc_type = ENC_TYPE_WAV;
  594. break;
  595. }
  596. case AUDIO_GET_SBC_ENC_CONFIG: {
  597. struct msm_audio_sbc_enc_config cfg;
  598. memset(&cfg, 0, sizeof(cfg));
  599. cfg.bit_allocation = audio->cfg.bit_allocation;
  600. cfg.mode = audio->cfg.mode;
  601. cfg.number_of_subbands = audio->cfg.number_of_subbands;
  602. cfg.number_of_blocks = audio->cfg.number_of_blocks;
  603. cfg.sample_rate = audio->samp_rate;
  604. cfg.channels = audio->channel_mode;
  605. cfg.bit_rate = audio->cfg.bit_rate;
  606. if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
  607. rc = -EFAULT;
  608. break;
  609. }
  610. case AUDIO_GET_CONFIG: {
  611. struct msm_audio_config cfg;
  612. memset(&cfg, 0, sizeof(cfg));
  613. cfg.buffer_count = FRAME_NUM;
  614. cfg.sample_rate = audio->samp_rate;
  615. if (audio->channel_mode == AUDREC_CMD_MODE_MONO) {
  616. cfg.channel_count = 1;
  617. cfg.buffer_size = MONO_DATA_SIZE;
  618. } else {
  619. cfg.channel_count = 2;
  620. cfg.buffer_size = STEREO_DATA_SIZE;
  621. }
  622. cfg.type = ENC_TYPE_WAV;
  623. if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
  624. rc = -EFAULT;
  625. break;
  626. }
  627. case AUDIO_GET_SESSION_ID: {
  628. if (copy_to_user((void *) arg, &audio->enc_id,
  629. sizeof(unsigned short))) {
  630. rc = -EFAULT;
  631. }
  632. break;
  633. }
  634. default:
  635. rc = -EINVAL;
  636. }
  637. mutex_unlock(&audio->lock);
  638. return rc;
  639. }
  640. static ssize_t auda2dp_in_read(struct file *file,
  641. char __user *buf,
  642. size_t count, loff_t *pos)
  643. {
  644. struct audio_a2dp_in *audio = file->private_data;
  645. unsigned long flags;
  646. const char __user *start = buf;
  647. void *data;
  648. uint32_t index;
  649. uint32_t size;
  650. int rc = 0;
  651. uint32_t f_len = 0, f_num = 0;
  652. int i = 0;
  653. mutex_lock(&audio->read_lock);
  654. while (count > 0) {
  655. rc = wait_event_interruptible(
  656. audio->wait, (audio->in_count > 0) || audio->stopped ||
  657. audio->abort);
  658. if (rc < 0)
  659. break;
  660. if (audio->stopped && !audio->in_count) {
  661. MM_DBG("Driver in stop state, No more buffer to read");
  662. rc = 0;/* End of File */
  663. break;
  664. }
  665. if (audio->abort) {
  666. rc = -EPERM; /* Not permitted due to abort */
  667. break;
  668. }
  669. index = audio->in_tail;
  670. data = (uint8_t *) audio->in[index].data;
  671. size = audio->in[index].size;
  672. if (count >= size) {
  673. if (audio->enc_type == ENC_TYPE_SBC &&
  674. (audio->in[index].frame_len % 2)) {
  675. f_len = audio->in[index].frame_len;
  676. f_num = audio->in[index].frame_num;
  677. for (i = 0; i < f_num; i++) {
  678. if (copy_to_user(&buf[i * f_len],
  679. (uint8_t *) (data + (i * (f_len + 1))),
  680. f_len)) {
  681. rc = -EFAULT;
  682. break;
  683. }
  684. }
  685. } else {
  686. if (copy_to_user(buf, data, size)) {
  687. rc = -EFAULT;
  688. break;
  689. }
  690. }
  691. spin_lock_irqsave(&audio->dsp_lock, flags);
  692. if (index != audio->in_tail) {
  693. /* overrun -- data is
  694. * invalid and we need to retry */
  695. spin_unlock_irqrestore(&audio->dsp_lock, flags);
  696. continue;
  697. }
  698. audio->in[index].size = 0;
  699. audio->in_tail = (audio->in_tail + 1) & (FRAME_NUM - 1);
  700. audio->in_count--;
  701. spin_unlock_irqrestore(&audio->dsp_lock, flags);
  702. count -= size;
  703. buf += size;
  704. } else {
  705. MM_ERR("short read\n");
  706. break;
  707. }
  708. }
  709. mutex_unlock(&audio->read_lock);
  710. if (buf > start)
  711. return buf - start;
  712. return rc;
  713. }
  714. static ssize_t auda2dp_in_write(struct file *file,
  715. const char __user *buf,
  716. size_t count, loff_t *pos)
  717. {
  718. return -EINVAL;
  719. }
  720. static int auda2dp_in_release(struct inode *inode, struct file *file)
  721. {
  722. struct audio_a2dp_in *audio = file->private_data;
  723. mutex_lock(&audio->lock);
  724. /* with draw frequency for session
  725. incase not stopped the driver */
  726. msm_snddev_withdraw_freq(audio->enc_id, SNDDEV_CAP_TX,
  727. AUDDEV_CLNT_ENC);
  728. auddev_unregister_evt_listner(AUDDEV_CLNT_ENC, audio->enc_id);
  729. auda2dp_in_disable(audio);
  730. auda2dp_in_flush(audio);
  731. msm_adsp_put(audio->audrec);
  732. audpreproc_aenc_free(audio->enc_id);
  733. audio->audrec = NULL;
  734. audio->opened = 0;
  735. mutex_unlock(&audio->lock);
  736. return 0;
  737. }
  738. static int auda2dp_in_open(struct inode *inode, struct file *file)
  739. {
  740. struct audio_a2dp_in *audio = &the_audio_a2dp_in;
  741. int rc;
  742. int encid;
  743. mutex_lock(&audio->lock);
  744. if (audio->opened) {
  745. rc = -EBUSY;
  746. goto done;
  747. }
  748. if ((file->f_mode & FMODE_WRITE) &&
  749. (file->f_mode & FMODE_READ)) {
  750. rc = -EACCES;
  751. MM_ERR("Non tunnel encoding is not supported\n");
  752. goto done;
  753. } else if (!(file->f_mode & FMODE_WRITE) &&
  754. (file->f_mode & FMODE_READ)) {
  755. audio->mode = MSM_AUD_ENC_MODE_TUNNEL;
  756. MM_DBG("Opened for Tunnel mode encoding\n");
  757. } else {
  758. rc = -EACCES;
  759. goto done;
  760. }
  761. /* Settings will be re-config at AUDIO_SET_CONFIG/SBC_ENC_CONFIG,
  762. * but at least we need to have initial config
  763. */
  764. audio->channel_mode = AUDREC_CMD_MODE_MONO;
  765. audio->buffer_size = FRAME_SIZE_SBC;
  766. audio->samp_rate = 48000;
  767. audio->enc_type = ENC_TYPE_SBC | audio->mode;
  768. audio->cfg.bit_allocation = AUDIO_SBC_BA_SNR;
  769. audio->cfg.mode = AUDIO_SBC_MODE_JSTEREO;
  770. audio->cfg.number_of_subbands = AUDIO_SBC_BANDS_8;
  771. audio->cfg.number_of_blocks = AUDIO_SBC_BLOCKS_16;
  772. audio->cfg.bit_rate = 320000; /* max 512kbps(mono), 320kbs(others) */
  773. encid = audpreproc_aenc_alloc(audio->enc_type, &audio->module_name,
  774. &audio->queue_ids);
  775. if (encid < 0) {
  776. MM_ERR("No free encoder available\n");
  777. rc = -ENODEV;
  778. goto done;
  779. }
  780. audio->enc_id = encid;
  781. rc = msm_adsp_get(audio->module_name, &audio->audrec,
  782. &audrec_adsp_ops, audio);
  783. if (rc) {
  784. audpreproc_aenc_free(audio->enc_id);
  785. goto done;
  786. }
  787. audio->stopped = 0;
  788. audio->source = 0;
  789. audio->abort = 0;
  790. auda2dp_in_flush(audio);
  791. audio->device_events = AUDDEV_EVT_DEV_RDY | AUDDEV_EVT_DEV_RLS |
  792. AUDDEV_EVT_FREQ_CHG;
  793. rc = auddev_register_evt_listner(audio->device_events,
  794. AUDDEV_CLNT_ENC, audio->enc_id,
  795. a2dp_in_listener, (void *) audio);
  796. if (rc) {
  797. MM_ERR("failed to register device event listener\n");
  798. goto evt_error;
  799. }
  800. file->private_data = audio;
  801. audio->opened = 1;
  802. rc = 0;
  803. done:
  804. mutex_unlock(&audio->lock);
  805. return rc;
  806. evt_error:
  807. msm_adsp_put(audio->audrec);
  808. audpreproc_aenc_free(audio->enc_id);
  809. mutex_unlock(&audio->lock);
  810. return rc;
  811. }
  812. static const struct file_operations audio_a2dp_in_fops = {
  813. .owner = THIS_MODULE,
  814. .open = auda2dp_in_open,
  815. .release = auda2dp_in_release,
  816. .read = auda2dp_in_read,
  817. .write = auda2dp_in_write,
  818. .unlocked_ioctl = auda2dp_in_ioctl,
  819. };
  820. struct miscdevice audio_a2dp_in_misc = {
  821. .minor = MISC_DYNAMIC_MINOR,
  822. .name = "msm_a2dp_in",
  823. .fops = &audio_a2dp_in_fops,
  824. };
  825. static int __init auda2dp_in_init(void)
  826. {
  827. the_audio_a2dp_in.data = dma_alloc_coherent(NULL, DMASZ,
  828. &the_audio_a2dp_in.phys, GFP_KERNEL);
  829. MM_DBG("Memory addr = 0x%8x phy addr = 0x%8x ---- \n", \
  830. (int) the_audio_a2dp_in.data, (int) the_audio_a2dp_in.phys);
  831. if (!the_audio_a2dp_in.data) {
  832. MM_ERR("Unable to allocate DMA buffer\n");
  833. return -ENOMEM;
  834. }
  835. mutex_init(&the_audio_a2dp_in.lock);
  836. mutex_init(&the_audio_a2dp_in.read_lock);
  837. spin_lock_init(&the_audio_a2dp_in.dsp_lock);
  838. spin_lock_init(&the_audio_a2dp_in.dev_lock);
  839. init_waitqueue_head(&the_audio_a2dp_in.wait);
  840. init_waitqueue_head(&the_audio_a2dp_in.wait_enable);
  841. return misc_register(&audio_a2dp_in_misc);
  842. }
  843. device_initcall(auda2dp_in_init);
  844. MODULE_DESCRIPTION("MSM SBC encode driver");
  845. MODULE_LICENSE("GPL v2");