1 /* arch/arm/mach-msm/qdsp5/audio_in.c
3 * pcm audio input device
5 * Copyright (C) 2008 Google, Inc.
6 * Copyright (C) 2008 HTC Corporation
8 * This software is licensed under the terms of the GNU General Public
9 * License version 2, as published by the Free Software Foundation, and
10 * may be copied, distributed, and modified under those terms.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
19 #include <linux/module.h>
21 #include <linux/miscdevice.h>
22 #include <linux/uaccess.h>
23 #include <linux/kthread.h>
24 #include <linux/wait.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/gfp.h>
28 #include <linux/delay.h>
30 #include <linux/msm_audio.h>
32 #include <asm/atomic.h>
33 #include <asm/ioctls.h>
34 #include <mach/msm_adsp.h>
35 #include <mach/msm_rpcrouter.h>
39 #include <mach/qdsp5/qdsp5audpreproccmdi.h>
40 #include <mach/qdsp5/qdsp5audpreprocmsg.h>
41 #include <mach/qdsp5/qdsp5audreccmdi.h>
42 #include <mach/qdsp5/qdsp5audrecmsg.h>
44 /* for queue ids - should be relative to module number*/
47 /* FRAME_NUM must be a power of two */
49 #define FRAME_SIZE (2052 * 2)
50 #define MONO_DATA_SIZE (2048)
51 #define STEREO_DATA_SIZE (MONO_DATA_SIZE * 2)
52 #define DMASZ (FRAME_SIZE * FRAME_NUM)
54 #define AGC_PARAM_SIZE (20)
55 #define NS_PARAM_SIZE (6)
56 #define IIR_PARAM_SIZE (48)
59 #define AGC_ENABLE 0x0001
60 #define NS_ENABLE 0x0002
61 #define IIR_ENABLE 0x0004
63 struct tx_agc_config
{
64 uint16_t agc_params
[AGC_PARAM_SIZE
];
68 uint16_t ns_params
[NS_PARAM_SIZE
];
71 struct tx_iir_filter
{
73 uint16_t iir_params
[IIR_PARAM_SIZE
];
76 struct audpre_cmd_iir_config_type
{
80 uint16_t iir_params
[IIR_PARAM_SIZE
];
91 struct buffer in
[FRAME_NUM
];
98 struct mutex read_lock
;
99 wait_queue_head_t wait
;
101 struct msm_adsp_module
*audpre
;
102 struct msm_adsp_module
*audrec
;
104 /* configuration to use on next enable */
106 uint32_t channel_mode
;
107 uint32_t buffer_size
; /* 2048 for mono, 4096 for stereo */
108 uint32_t type
; /* 0 for PCM ,1 for AAC */
110 uint32_t in_head
; /* next buffer dsp will write */
111 uint32_t in_tail
; /* next buffer read() will read */
112 uint32_t in_count
; /* number of buffers available to read() */
114 unsigned short samp_rate_index
;
116 struct audmgr audmgr
;
118 /* data allocated for various buffers */
125 int stopped
; /* set when stopped, cleared on flush */
127 /* audpre settings */
129 struct tx_agc_config agc
;
135 struct tx_iir_filter iir
;
138 static int audio_in_dsp_enable(struct audio_in
*audio
, int enable
);
139 static int audio_in_encoder_config(struct audio_in
*audio
);
140 static int audio_dsp_read_buffer(struct audio_in
*audio
, uint32_t read_cnt
);
141 static void audio_flush(struct audio_in
*audio
);
142 static int audio_dsp_set_agc(struct audio_in
*audio
);
143 static int audio_dsp_set_ns(struct audio_in
*audio
);
144 static int audio_dsp_set_tx_iir(struct audio_in
*audio
);
146 static unsigned convert_dsp_samp_index(unsigned index
)
149 case 48000: return AUDREC_CMD_SAMP_RATE_INDX_48000
;
150 case 44100: return AUDREC_CMD_SAMP_RATE_INDX_44100
;
151 case 32000: return AUDREC_CMD_SAMP_RATE_INDX_32000
;
152 case 24000: return AUDREC_CMD_SAMP_RATE_INDX_24000
;
153 case 22050: return AUDREC_CMD_SAMP_RATE_INDX_22050
;
154 case 16000: return AUDREC_CMD_SAMP_RATE_INDX_16000
;
155 case 12000: return AUDREC_CMD_SAMP_RATE_INDX_12000
;
156 case 11025: return AUDREC_CMD_SAMP_RATE_INDX_11025
;
157 case 8000: return AUDREC_CMD_SAMP_RATE_INDX_8000
;
158 default: return AUDREC_CMD_SAMP_RATE_INDX_11025
;
162 static unsigned convert_samp_rate(unsigned hz
)
165 case 48000: return RPC_AUD_DEF_SAMPLE_RATE_48000
;
166 case 44100: return RPC_AUD_DEF_SAMPLE_RATE_44100
;
167 case 32000: return RPC_AUD_DEF_SAMPLE_RATE_32000
;
168 case 24000: return RPC_AUD_DEF_SAMPLE_RATE_24000
;
169 case 22050: return RPC_AUD_DEF_SAMPLE_RATE_22050
;
170 case 16000: return RPC_AUD_DEF_SAMPLE_RATE_16000
;
171 case 12000: return RPC_AUD_DEF_SAMPLE_RATE_12000
;
172 case 11025: return RPC_AUD_DEF_SAMPLE_RATE_11025
;
173 case 8000: return RPC_AUD_DEF_SAMPLE_RATE_8000
;
174 default: return RPC_AUD_DEF_SAMPLE_RATE_11025
;
178 static unsigned convert_samp_index(unsigned index
)
181 case RPC_AUD_DEF_SAMPLE_RATE_48000
: return 48000;
182 case RPC_AUD_DEF_SAMPLE_RATE_44100
: return 44100;
183 case RPC_AUD_DEF_SAMPLE_RATE_32000
: return 32000;
184 case RPC_AUD_DEF_SAMPLE_RATE_24000
: return 24000;
185 case RPC_AUD_DEF_SAMPLE_RATE_22050
: return 22050;
186 case RPC_AUD_DEF_SAMPLE_RATE_16000
: return 16000;
187 case RPC_AUD_DEF_SAMPLE_RATE_12000
: return 12000;
188 case RPC_AUD_DEF_SAMPLE_RATE_11025
: return 11025;
189 case RPC_AUD_DEF_SAMPLE_RATE_8000
: return 8000;
190 default: return 11025;
194 /* must be called with audio->lock held */
195 static int audio_in_enable(struct audio_in
*audio
)
197 struct audmgr_config cfg
;
203 cfg
.tx_rate
= audio
->samp_rate
;
204 cfg
.rx_rate
= RPC_AUD_DEF_SAMPLE_RATE_NONE
;
205 cfg
.def_method
= RPC_AUD_DEF_METHOD_RECORD
;
206 if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_WAV
)
207 cfg
.codec
= RPC_AUD_DEF_CODEC_PCM
;
209 cfg
.codec
= RPC_AUD_DEF_CODEC_AAC
;
210 cfg
.snd_method
= RPC_SND_METHOD_MIDI
;
212 rc
= audmgr_enable(&audio
->audmgr
, &cfg
);
216 if (msm_adsp_enable(audio
->audpre
)) {
217 pr_err("audrec: msm_adsp_enable(audpre) failed\n");
220 if (msm_adsp_enable(audio
->audrec
)) {
221 pr_err("audrec: msm_adsp_enable(audrec) failed\n");
226 audio_in_dsp_enable(audio
, 1);
231 /* must be called with audio->lock held */
232 static int audio_in_disable(struct audio_in
*audio
)
234 if (audio
->enabled
) {
237 audio_in_dsp_enable(audio
, 0);
239 wake_up(&audio
->wait
);
241 msm_adsp_disable(audio
->audrec
);
242 msm_adsp_disable(audio
->audpre
);
243 audmgr_disable(&audio
->audmgr
);
248 /* ------------------- dsp --------------------- */
249 static void audpre_dsp_event(void *data
, unsigned id
, size_t len
,
250 void (*getevent
)(void *ptr
, size_t len
))
253 getevent(msg
, sizeof(msg
));
256 case AUDPREPROC_MSG_CMD_CFG_DONE_MSG
:
257 pr_info("audpre: type %d, status_flag %d\n", msg
[0], msg
[1]);
259 case AUDPREPROC_MSG_ERROR_MSG_ID
:
260 pr_info("audpre: err_index %d\n", msg
[0]);
263 pr_err("audpre: unknown event %d\n", id
);
272 unsigned char samples
[];
273 } __attribute__((packed
));
275 static void audio_in_get_dsp_frames(struct audio_in
*audio
)
277 struct audio_frame
*frame
;
281 index
= audio
->in_head
;
283 /* XXX check for bogus frame size? */
285 frame
= (void *) (((char *)audio
->in
[index
].data
) - sizeof(*frame
));
287 spin_lock_irqsave(&audio
->dsp_lock
, flags
);
288 audio
->in
[index
].size
= frame
->bytes
;
290 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);
298 audio_dsp_read_buffer(audio
, audio
->dsp_cnt
++);
299 spin_unlock_irqrestore(&audio
->dsp_lock
, flags
);
301 wake_up(&audio
->wait
);
304 static void audrec_dsp_event(void *data
, unsigned id
, size_t len
,
305 void (*getevent
)(void *ptr
, size_t len
))
307 struct audio_in
*audio
= data
;
309 getevent(msg
, sizeof(msg
));
312 case AUDREC_MSG_CMD_CFG_DONE_MSG
:
313 if (msg
[0] & AUDREC_MSG_CFG_DONE_TYPE_0_UPDATE
) {
314 if (msg
[0] & AUDREC_MSG_CFG_DONE_TYPE_0_ENA
) {
315 pr_info("audpre: CFG ENABLED\n");
316 audio_dsp_set_agc(audio
);
317 audio_dsp_set_ns(audio
);
318 audio_dsp_set_tx_iir(audio
);
319 audio_in_encoder_config(audio
);
321 pr_info("audrec: CFG SLEEP\n");
325 pr_info("audrec: CMD_CFG_DONE %x\n", msg
[0]);
328 case AUDREC_MSG_CMD_AREC_PARAM_CFG_DONE_MSG
: {
329 pr_info("audrec: PARAM CFG DONE\n");
333 case AUDREC_MSG_FATAL_ERR_MSG
:
334 pr_err("audrec: ERROR %x\n", msg
[0]);
336 case AUDREC_MSG_PACKET_READY_MSG
:
337 /* REC_DBG("type %x, count %d", msg[0], (msg[1] | (msg[2] << 16))); */
338 audio_in_get_dsp_frames(audio
);
341 pr_err("audrec: unknown event %d\n", id
);
345 struct msm_adsp_ops audpre_adsp_ops
= {
346 .event
= audpre_dsp_event
,
349 struct msm_adsp_ops audrec_adsp_ops
= {
350 .event
= audrec_dsp_event
,
354 #define audio_send_queue_pre(audio, cmd, len) \
355 msm_adsp_write(audio->audpre, QDSP_uPAudPreProcCmdQueue, cmd, len)
356 #define audio_send_queue_recbs(audio, cmd, len) \
357 msm_adsp_write(audio->audrec, QDSP_uPAudRecBitStreamQueue, cmd, len)
358 #define audio_send_queue_rec(audio, cmd, len) \
359 msm_adsp_write(audio->audrec, \
360 QDSP_uPAudRecCmdQueue, cmd, len)
362 static int audio_dsp_set_agc(struct audio_in
*audio
)
364 audpreproc_cmd_cfg_agc_params cmd
;
366 memset(&cmd
, 0, sizeof(cmd
));
367 cmd
.cmd_id
= AUDPREPROC_CMD_CFG_AGC_PARAMS
;
369 if (audio
->agc_enable
) {
370 /* cmd.tx_agc_param_mask = 0xFE00 from sample code */
371 cmd
.tx_agc_param_mask
=
372 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_COMP_SLOPE
) |
373 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_COMP_TH
) |
374 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_EXP_SLOPE
) |
375 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_EXP_TH
) |
376 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_COMP_AIG_FLAG
) |
377 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_COMP_STATIC_GAIN
) |
378 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_TX_AGC_ENA_FLAG
);
379 cmd
.tx_agc_enable_flag
=
380 AUDPREPROC_CMD_TX_AGC_ENA_FLAG_ENA
;
381 memcpy(&cmd
.static_gain
, &audio
->agc
.agc_params
[0],
382 sizeof(uint16_t) * 6);
383 /* cmd.param_mask = 0xFFF0 from sample code */
385 (1 << AUDPREPROC_CMD_PARAM_MASK_RMS_TAY
) |
386 (1 << AUDPREPROC_CMD_PARAM_MASK_RELEASEK
) |
387 (1 << AUDPREPROC_CMD_PARAM_MASK_DELAY
) |
388 (1 << AUDPREPROC_CMD_PARAM_MASK_ATTACKK
) |
389 (1 << AUDPREPROC_CMD_PARAM_MASK_LEAKRATE_SLOW
) |
390 (1 << AUDPREPROC_CMD_PARAM_MASK_LEAKRATE_FAST
) |
391 (1 << AUDPREPROC_CMD_PARAM_MASK_AIG_RELEASEK
) |
392 (1 << AUDPREPROC_CMD_PARAM_MASK_AIG_MIN
) |
393 (1 << AUDPREPROC_CMD_PARAM_MASK_AIG_MAX
) |
394 (1 << AUDPREPROC_CMD_PARAM_MASK_LEAK_UP
) |
395 (1 << AUDPREPROC_CMD_PARAM_MASK_LEAK_DOWN
) |
396 (1 << AUDPREPROC_CMD_PARAM_MASK_AIG_ATTACKK
);
397 memcpy(&cmd
.aig_attackk
, &audio
->agc
.agc_params
[6],
398 sizeof(uint16_t) * 14);
401 cmd
.tx_agc_param_mask
=
402 (1 << AUDPREPROC_CMD_TX_AGC_PARAM_MASK_TX_AGC_ENA_FLAG
);
403 cmd
.tx_agc_enable_flag
=
404 AUDPREPROC_CMD_TX_AGC_ENA_FLAG_DIS
;
407 pr_info("cmd_id = 0x%04x\n", cmd
.cmd_id
);
408 pr_info("tx_agc_param_mask = 0x%04x\n", cmd
.tx_agc_param_mask
);
409 pr_info("tx_agc_enable_flag = 0x%04x\n", cmd
.tx_agc_enable_flag
);
410 pr_info("static_gain = 0x%04x\n", cmd
.static_gain
);
411 pr_info("adaptive_gain_flag = 0x%04x\n", cmd
.adaptive_gain_flag
);
412 pr_info("expander_th = 0x%04x\n", cmd
.expander_th
);
413 pr_info("expander_slope = 0x%04x\n", cmd
.expander_slope
);
414 pr_info("compressor_th = 0x%04x\n", cmd
.compressor_th
);
415 pr_info("compressor_slope = 0x%04x\n", cmd
.compressor_slope
);
416 pr_info("param_mask = 0x%04x\n", cmd
.param_mask
);
417 pr_info("aig_attackk = 0x%04x\n", cmd
.aig_attackk
);
418 pr_info("aig_leak_down = 0x%04x\n", cmd
.aig_leak_down
);
419 pr_info("aig_leak_up = 0x%04x\n", cmd
.aig_leak_up
);
420 pr_info("aig_max = 0x%04x\n", cmd
.aig_max
);
421 pr_info("aig_min = 0x%04x\n", cmd
.aig_min
);
422 pr_info("aig_releasek = 0x%04x\n", cmd
.aig_releasek
);
423 pr_info("aig_leakrate_fast = 0x%04x\n", cmd
.aig_leakrate_fast
);
424 pr_info("aig_leakrate_slow = 0x%04x\n", cmd
.aig_leakrate_slow
);
425 pr_info("attackk_msw = 0x%04x\n", cmd
.attackk_msw
);
426 pr_info("attackk_lsw = 0x%04x\n", cmd
.attackk_lsw
);
427 pr_info("delay = 0x%04x\n", cmd
.delay
);
428 pr_info("releasek_msw = 0x%04x\n", cmd
.releasek_msw
);
429 pr_info("releasek_lsw = 0x%04x\n", cmd
.releasek_lsw
);
430 pr_info("rms_tav = 0x%04x\n", cmd
.rms_tav
);
432 return audio_send_queue_pre(audio
, &cmd
, sizeof(cmd
));
435 static int audio_dsp_set_ns(struct audio_in
*audio
)
437 audpreproc_cmd_cfg_ns_params cmd
;
439 memset(&cmd
, 0, sizeof(cmd
));
440 cmd
.cmd_id
= AUDPREPROC_CMD_CFG_NS_PARAMS
;
442 if (audio
->ns_enable
) {
443 /* cmd.ec_mode_new is fixed as 0x0064 when enable from sample code */
445 AUDPREPROC_CMD_EC_MODE_NEW_NS_ENA
|
446 AUDPREPROC_CMD_EC_MODE_NEW_HB_ENA
|
447 AUDPREPROC_CMD_EC_MODE_NEW_VA_ENA
;
448 memcpy(&cmd
.dens_gamma_n
, &audio
->ns
.ns_params
,
449 sizeof(audio
->ns
.ns_params
));
452 AUDPREPROC_CMD_EC_MODE_NEW_NLMS_DIS
|
453 AUDPREPROC_CMD_EC_MODE_NEW_DES_DIS
|
454 AUDPREPROC_CMD_EC_MODE_NEW_NS_DIS
|
455 AUDPREPROC_CMD_EC_MODE_NEW_CNI_DIS
|
456 AUDPREPROC_CMD_EC_MODE_NEW_NLES_DIS
|
457 AUDPREPROC_CMD_EC_MODE_NEW_HB_DIS
|
458 AUDPREPROC_CMD_EC_MODE_NEW_VA_DIS
|
459 AUDPREPROC_CMD_EC_MODE_NEW_PCD_DIS
|
460 AUDPREPROC_CMD_EC_MODE_NEW_FEHI_DIS
|
461 AUDPREPROC_CMD_EC_MODE_NEW_NEHI_DIS
|
462 AUDPREPROC_CMD_EC_MODE_NEW_NLPP_DIS
|
463 AUDPREPROC_CMD_EC_MODE_NEW_FNE_DIS
|
464 AUDPREPROC_CMD_EC_MODE_NEW_PRENLMS_DIS
;
467 pr_info("cmd_id = 0x%04x\n", cmd
.cmd_id
);
468 pr_info("ec_mode_new = 0x%04x\n", cmd
.ec_mode_new
);
469 pr_info("dens_gamma_n = 0x%04x\n", cmd
.dens_gamma_n
);
470 pr_info("dens_nfe_block_size = 0x%04x\n", cmd
.dens_nfe_block_size
);
471 pr_info("dens_limit_ns = 0x%04x\n", cmd
.dens_limit_ns
);
472 pr_info("dens_limit_ns_d = 0x%04x\n", cmd
.dens_limit_ns_d
);
473 pr_info("wb_gamma_e = 0x%04x\n", cmd
.wb_gamma_e
);
474 pr_info("wb_gamma_n = 0x%04x\n", cmd
.wb_gamma_n
);
476 return audio_send_queue_pre(audio
, &cmd
, sizeof(cmd
));
479 static int audio_dsp_set_tx_iir(struct audio_in
*audio
)
481 struct audpre_cmd_iir_config_type cmd
;
483 memset(&cmd
, 0, sizeof(cmd
));
484 cmd
.cmd_id
= AUDPREPROC_CMD_CFG_IIR_TUNING_FILTER_PARAMS
;
486 if (audio
->iir_enable
) {
487 cmd
.active_flag
= AUDPREPROC_CMD_IIR_ACTIVE_FLAG_ENA
;
488 cmd
.num_bands
= audio
->iir
.num_bands
;
489 memcpy(&cmd
.iir_params
, &audio
->iir
.iir_params
,
490 sizeof(audio
->iir
.iir_params
));
492 cmd
.active_flag
= AUDPREPROC_CMD_IIR_ACTIVE_FLAG_DIS
;
495 pr_info("cmd_id = 0x%04x\n", cmd
.cmd_id
);
496 pr_info("active_flag = 0x%04x\n", cmd
.active_flag
);
498 return audio_send_queue_pre(audio
, &cmd
, sizeof(cmd
));
501 static int audio_in_dsp_enable(struct audio_in
*audio
, int enable
)
505 memset(&cmd
, 0, sizeof(cmd
));
506 cmd
.cmd_id
= AUDREC_CMD_CFG
;
507 cmd
.type_0
= enable
? AUDREC_CMD_TYPE_0_ENA
: AUDREC_CMD_TYPE_0_DIS
;
508 cmd
.type_0
|= (AUDREC_CMD_TYPE_0_UPDATE
| audio
->type
);
511 return audio_send_queue_rec(audio
, &cmd
, sizeof(cmd
));
514 static int audio_in_encoder_config(struct audio_in
*audio
)
516 audrec_cmd_arec0param_cfg cmd
;
517 uint16_t *data
= (void *) audio
->data
;
520 memset(&cmd
, 0, sizeof(cmd
));
521 cmd
.cmd_id
= AUDREC_CMD_AREC0PARAM_CFG
;
522 cmd
.ptr_to_extpkt_buffer_msw
= audio
->phys
>> 16;
523 cmd
.ptr_to_extpkt_buffer_lsw
= audio
->phys
;
524 cmd
.buf_len
= FRAME_NUM
; /* Both WAV and AAC use 8 frames */
525 cmd
.samp_rate_index
= audio
->samp_rate_index
;
526 cmd
.stereo_mode
= audio
->channel_mode
; /* 0 for mono, 1 for stereo */
528 /* FIXME have no idea why cmd.rec_quality is fixed
529 * as 0x1C00 from sample code
531 cmd
.rec_quality
= 0x1C00;
533 /* prepare buffer pointers:
534 * Mono: 1024 samples + 4 halfword header
535 * Stereo: 2048 samples + 4 halfword header
537 * Mono/Stere: 768 + 4 halfword header
539 for (n
= 0; n
< FRAME_NUM
; n
++) {
540 audio
->in
[n
].data
= data
+ 4;
541 if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_WAV
)
542 data
+= (4 + (audio
->channel_mode
? 2048 : 1024));
543 else if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_AAC
)
547 return audio_send_queue_rec(audio
, &cmd
, sizeof(cmd
));
550 static int audio_dsp_read_buffer(struct audio_in
*audio
, uint32_t read_cnt
)
552 audrec_cmd_packet_ext_ptr cmd
;
554 memset(&cmd
, 0, sizeof(cmd
));
555 cmd
.cmd_id
= AUDREC_CMD_PACKET_EXT_PTR
;
556 /* Both WAV and AAC use AUDREC_CMD_TYPE_0 */
557 cmd
.type
= AUDREC_CMD_TYPE_0
;
558 cmd
.curr_rec_count_msw
= read_cnt
>> 16;
559 cmd
.curr_rec_count_lsw
= read_cnt
;
561 return audio_send_queue_recbs(audio
, &cmd
, sizeof(cmd
));
564 /* ------------------- device --------------------- */
566 static void audio_enable_agc(struct audio_in
*audio
, int enable
)
568 if (audio
->agc_enable
!= enable
) {
569 audio
->agc_enable
= enable
;
571 audio_dsp_set_agc(audio
);
575 static void audio_enable_ns(struct audio_in
*audio
, int enable
)
577 if (audio
->ns_enable
!= enable
) {
578 audio
->ns_enable
= enable
;
580 audio_dsp_set_ns(audio
);
584 static void audio_enable_tx_iir(struct audio_in
*audio
, int enable
)
586 if (audio
->iir_enable
!= enable
) {
587 audio
->iir_enable
= enable
;
589 audio_dsp_set_tx_iir(audio
);
593 static void audio_flush(struct audio_in
*audio
)
601 for (i
= 0; i
< FRAME_NUM
; i
++) {
602 audio
->in
[i
].size
= 0;
603 audio
->in
[i
].read
= 0;
607 static long audio_in_ioctl(struct file
*file
,
608 unsigned int cmd
, unsigned long arg
)
610 struct audio_in
*audio
= file
->private_data
;
613 if (cmd
== AUDIO_GET_STATS
) {
614 struct msm_audio_stats stats
;
615 stats
.byte_count
= atomic_read(&audio
->in_bytes
);
616 if (copy_to_user((void *) arg
, &stats
, sizeof(stats
)))
621 mutex_lock(&audio
->lock
);
624 rc
= audio_in_enable(audio
);
627 rc
= audio_in_disable(audio
);
631 if (audio
->stopped
) {
632 /* Make sure we're stopped and we wake any threads
633 * that might be blocked holding the read_lock.
634 * While audio->stopped read threads will always
637 wake_up(&audio
->wait
);
638 mutex_lock(&audio
->read_lock
);
640 mutex_unlock(&audio
->read_lock
);
642 case AUDIO_SET_CONFIG
: {
643 struct msm_audio_config cfg
;
644 if (copy_from_user(&cfg
, (void *) arg
, sizeof(cfg
))) {
648 if (cfg
.channel_count
== 1) {
649 cfg
.channel_count
= AUDREC_CMD_STEREO_MODE_MONO
;
650 } else if (cfg
.channel_count
== 2) {
651 cfg
.channel_count
= AUDREC_CMD_STEREO_MODE_STEREO
;
658 cfg
.type
= AUDREC_CMD_TYPE_0_INDEX_WAV
;
659 } else if (cfg
.type
== 1) {
660 cfg
.type
= AUDREC_CMD_TYPE_0_INDEX_AAC
;
665 audio
->samp_rate
= convert_samp_rate(cfg
.sample_rate
);
666 audio
->samp_rate_index
=
667 convert_dsp_samp_index(cfg
.sample_rate
);
668 audio
->channel_mode
= cfg
.channel_count
;
670 audio
->channel_mode
? STEREO_DATA_SIZE
672 audio
->type
= cfg
.type
;
676 case AUDIO_GET_CONFIG
: {
677 struct msm_audio_config cfg
;
678 cfg
.buffer_size
= audio
->buffer_size
;
679 cfg
.buffer_count
= FRAME_NUM
;
680 cfg
.sample_rate
= convert_samp_index(audio
->samp_rate
);
681 if (audio
->channel_mode
== AUDREC_CMD_STEREO_MODE_MONO
)
682 cfg
.channel_count
= 1;
684 cfg
.channel_count
= 2;
685 if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_WAV
)
692 if (copy_to_user((void *) arg
, &cfg
, sizeof(cfg
)))
701 mutex_unlock(&audio
->lock
);
705 static ssize_t
audio_in_read(struct file
*file
,
707 size_t count
, loff_t
*pos
)
709 struct audio_in
*audio
= file
->private_data
;
711 const char __user
*start
= buf
;
717 mutex_lock(&audio
->read_lock
);
719 rc
= wait_event_interruptible(
720 audio
->wait
, (audio
->in_count
> 0) || audio
->stopped
);
724 if (audio
->stopped
) {
729 index
= audio
->in_tail
;
730 data
= (uint8_t *) audio
->in
[index
].data
;
731 size
= audio
->in
[index
].size
;
733 if (copy_to_user(buf
, data
, size
)) {
737 spin_lock_irqsave(&audio
->dsp_lock
, flags
);
738 if (index
!= audio
->in_tail
) {
739 /* overrun -- data is invalid and we need to retry */
740 spin_unlock_irqrestore(&audio
->dsp_lock
, flags
);
743 audio
->in
[index
].size
= 0;
744 audio
->in_tail
= (audio
->in_tail
+ 1) & (FRAME_NUM
- 1);
746 spin_unlock_irqrestore(&audio
->dsp_lock
, flags
);
749 if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_AAC
)
752 pr_err("audio_in: short read\n");
755 if (audio
->type
== AUDREC_CMD_TYPE_0_INDEX_AAC
)
756 break; /* AAC only read one frame */
758 mutex_unlock(&audio
->read_lock
);
766 static ssize_t
audio_in_write(struct file
*file
,
767 const char __user
*buf
,
768 size_t count
, loff_t
*pos
)
773 static int audio_in_release(struct inode
*inode
, struct file
*file
)
775 struct audio_in
*audio
= file
->private_data
;
777 mutex_lock(&audio
->lock
);
778 audio_in_disable(audio
);
780 msm_adsp_put(audio
->audrec
);
781 msm_adsp_put(audio
->audpre
);
782 audio
->audrec
= NULL
;
783 audio
->audpre
= NULL
;
785 mutex_unlock(&audio
->lock
);
789 static struct audio_in the_audio_in
;
791 static int audio_in_open(struct inode
*inode
, struct file
*file
)
793 struct audio_in
*audio
= &the_audio_in
;
796 mutex_lock(&audio
->lock
);
802 /* Settings will be re-config at AUDIO_SET_CONFIG,
803 * but at least we need to have initial config
805 audio
->samp_rate
= RPC_AUD_DEF_SAMPLE_RATE_11025
;
806 audio
->samp_rate_index
= AUDREC_CMD_SAMP_RATE_INDX_11025
;
807 audio
->channel_mode
= AUDREC_CMD_STEREO_MODE_MONO
;
808 audio
->buffer_size
= MONO_DATA_SIZE
;
809 audio
->type
= AUDREC_CMD_TYPE_0_INDEX_WAV
;
811 rc
= audmgr_open(&audio
->audmgr
);
814 rc
= msm_adsp_get("AUDPREPROCTASK", &audio
->audpre
,
815 &audpre_adsp_ops
, audio
);
818 rc
= msm_adsp_get("AUDRECTASK", &audio
->audrec
,
819 &audrec_adsp_ops
, audio
);
828 file
->private_data
= audio
;
832 mutex_unlock(&audio
->lock
);
836 static long audpre_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
838 struct audio_in
*audio
= file
->private_data
;
840 uint16_t enable_mask
;
845 mutex_lock(&audio
->lock
);
847 case AUDIO_ENABLE_AUDPRE
: {
848 if (copy_from_user(&enable_mask
, (void *) arg
,
849 sizeof(enable_mask
)))
852 enable
= (enable_mask
& AGC_ENABLE
) ? 1 : 0;
853 audio_enable_agc(audio
, enable
);
854 enable
= (enable_mask
& NS_ENABLE
) ? 1 : 0;
855 audio_enable_ns(audio
, enable
);
856 enable
= (enable_mask
& IIR_ENABLE
) ? 1 : 0;
857 audio_enable_tx_iir(audio
, enable
);
860 case AUDIO_SET_AGC
: {
861 if (copy_from_user(&audio
->agc
, (void *) arg
,
865 pr_info("set agc\n");
866 for (i
= 0; i
< AGC_PARAM_SIZE
; i
++) \
867 pr_info("agc_params[%d] = 0x%04x\n", i
,
868 audio
->agc
.agc_params
[i
]);
873 if (copy_from_user(&audio
->ns
, (void *) arg
,
878 for (i
= 0; i
< NS_PARAM_SIZE
; i
++) \
879 pr_info("ns_params[%d] = 0x%04x\n",
880 i
, audio
->ns
.ns_params
[i
]);
884 case AUDIO_SET_TX_IIR
: {
885 if (copy_from_user(&audio
->iir
, (void *) arg
,
889 pr_info("set iir\n");
890 pr_info("iir.num_bands = 0x%04x\n", audio
->iir
.num_bands
);
891 for (i
= 0; i
< IIR_PARAM_SIZE
; i
++) \
892 pr_info("iir_params[%d] = 0x%04x\n",
893 i
, audio
->iir
.iir_params
[i
]);
906 mutex_unlock(&audio
->lock
);
910 static int audpre_open(struct inode
*inode
, struct file
*file
)
912 struct audio_in
*audio
= &the_audio_in
;
913 file
->private_data
= audio
;
917 static struct file_operations audio_fops
= {
918 .owner
= THIS_MODULE
,
919 .open
= audio_in_open
,
920 .release
= audio_in_release
,
921 .read
= audio_in_read
,
922 .write
= audio_in_write
,
923 .unlocked_ioctl
= audio_in_ioctl
,
926 static struct file_operations audpre_fops
= {
927 .owner
= THIS_MODULE
,
929 .unlocked_ioctl
= audpre_ioctl
,
932 struct miscdevice audio_in_misc
= {
933 .minor
= MISC_DYNAMIC_MINOR
,
934 .name
= "msm_pcm_in",
938 struct miscdevice audpre_misc
= {
939 .minor
= MISC_DYNAMIC_MINOR
,
940 .name
= "msm_audpre",
941 .fops
= &audpre_fops
,
944 static int __init
audio_in_init(void)
947 the_audio_in
.data
= dma_alloc_coherent(NULL
, DMASZ
,
948 &the_audio_in
.phys
, GFP_KERNEL
);
949 if (!the_audio_in
.data
) {
950 printk(KERN_ERR
"%s: Unable to allocate DMA buffer\n",
955 mutex_init(&the_audio_in
.lock
);
956 mutex_init(&the_audio_in
.read_lock
);
957 spin_lock_init(&the_audio_in
.dsp_lock
);
958 init_waitqueue_head(&the_audio_in
.wait
);
959 rc
= misc_register(&audio_in_misc
);
961 rc
= misc_register(&audpre_misc
);
963 misc_deregister(&audio_in_misc
);
968 device_initcall(audio_in_init
);