1012 lines
31 KiB
C
1012 lines
31 KiB
C
/* Copyright (c) 2010-2011, 2012 The Linux Foundation. All rights reserved.
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <stdint.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <sys/ioctl.h>
|
|
#include "audiotest_def.h"
|
|
#include <linux/msm_audio.h>
|
|
|
|
#if defined(TARGET_USES_QCOM_MM_AUDIO)
|
|
#include "control.h"
|
|
|
|
#ifdef QDSP6V2
|
|
#include "acdb-loader.h"
|
|
#include "acdb-id-mapper.h"
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef AUDIOV2
|
|
#define DEVMGR_MAX_PLAYBACK_SESSION 4
|
|
#define DEVMGR_MAX_RECORDING_SESSION 2
|
|
#define DEVMGR_DEFAULT_SID 65523
|
|
#define ANC_FF_STEREO_RX_ACDB_ID 26
|
|
|
|
static int devmgr_devid_rx;
|
|
static int devmgr_devid_tx;
|
|
static int devmgr_dev_count_tx;
|
|
static int devmgr_dev_count_rx;
|
|
static int devmgr_init_flag;
|
|
static int devmgr_mixer_init_flag;
|
|
unsigned short devmgr_sid_rx_array[DEVMGR_MAX_PLAYBACK_SESSION];
|
|
unsigned short devmgr_sid_tx_array[DEVMGR_MAX_PLAYBACK_SESSION];
|
|
static int devmgr_sid_count_rx = 0;
|
|
static int devmgr_sid_count_tx = 0;
|
|
|
|
#ifdef QDSP6V2
|
|
static int acdb_init_count;
|
|
static int devmgr_mvslp_devid_rx;
|
|
static int devmgr_mvslp_devid_tx;
|
|
static int mvs_lp_flag = 0;
|
|
#endif
|
|
|
|
const char *devctl_help_text =
|
|
"\nDevice Control Help: MAINLY USED FOR SWITCHING THE AUDIO DEVICE. \n\
|
|
All Active playbacks will be routed to Device mentioned in this \n\
|
|
command. Device IDs are generated dynamically from the driver. \n"
|
|
#ifdef QDSP6V2
|
|
"\nTo Switch Rx Devices\n"
|
|
"Usage: echo \"devctl -cmd=dev_switch_rx -dev_id=x\" > /data/audio_test \n\n"
|
|
" \nTo test Proxy port:\n"
|
|
"Usage: echo \"devctl -cmd=dev_switch_rx -proxyporttest=<proxy port dev-id>\n \
|
|
-time=<out file log time, this is actually a loopcounter> -outfile=<out put \
|
|
file URL> -samplerate=<rate>\n \
|
|
-channels=<chan>\" > /data/audio_test \n"
|
|
"Note:First play a decode session and then use this cmd to log pcm from proxy\n\n"
|
|
#else
|
|
"Usage: echo \"devctl -cmd=dev_switch_rx -dev_id=x\" > /data/audio_test \n"
|
|
#endif
|
|
"\nTo Switch Tx Devices\n"
|
|
"echo \"devctl -cmd=dev_switch_tx -dev_id=x\" > /data/audio_test \n\n\
|
|
For making voice loopback from application side:- \n\n\
|
|
To start a voice call, input these commands: \n"
|
|
#ifdef QDSP6V2
|
|
"\nTo load voice acdb \n\
|
|
echo \"devctl -cmd=load_voice_acdb -txdev_id=x -rxdev_id=y\" > \n\
|
|
/data/audio_test \n"
|
|
#endif
|
|
"echo \"devctl -cmd=voice_route -txdev_id=x -rxdev_id=y\" > \n\
|
|
/data/audio_test \n\
|
|
echo \"devctl -cmd=enable_dev -dev_id=x\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=enable_dev -dev_id=y\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=start_voice\" > /data/audio_test \n\n\
|
|
\nTo mute/unmute: \n\
|
|
echo \"devctl -cmd=voice_tx_mute -mute=z\" > /data/audio_test \n\
|
|
To end started voice call, input these commands: \n\
|
|
echo \"devctl -cmd=end_voice\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=disable_dev -dev_id=x\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=disable_dev -dev_id=y\" > /data/audio_test \n\
|
|
where x,y = any of the supported device IDs listed below, \n\
|
|
z = 0/1 where 0 is unmute, 1 is mute \n\
|
|
echo \"devctl -cmd=loopback_set -txdev_id=x -rxdev_id=y\" >/data/audio_test\n\
|
|
echo \"devctl -cmd=loopback_reset -txdev_id=x -rxdev_id=y\" > \n\
|
|
/data/audio_test \n"
|
|
#ifdef QDSP5V2
|
|
"echo \"devctl -cmd=mute_dev -dev_id=x -mute=0/1\" > /data/audio_test\n"
|
|
#endif
|
|
#ifdef QDSP6V2
|
|
"\nTo enable active noise cancellation: \n\
|
|
echo \"devctl -cmd=enable_dev -dev_id=v\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=enable_anc\" > /data/audio_test \n\
|
|
where v = ANC Device ID \n\
|
|
If ANC Device is already enabled, then just run the enable_anc command \n\
|
|
To disable active noise cancellation: \n\
|
|
echo \"devctl -cmd=disable_anc\" > /data/audio_test \n\
|
|
echo \"devctl -cmd=loopback_set -txdev_id=x -rxdev_id=y\" >/data/audio_test\n\
|
|
echo \"devctl -cmd=loopback_reset -txdev_id=x -rxdev_id=y\" > /data/audio_test\n\
|
|
\nTo do device switch during VoIP call \n\
|
|
echo \"devctl -cmd=mvs_dev_switch -rxdev_id=x -rxdev_id=x\" \n > /data/audio_test \n"
|
|
#endif
|
|
"Note: \n\
|
|
(i) Handset RX/TX is set as default device for all playbacks/recordings \n\
|
|
(ii) After a device switch, audio will be routed to the last set \n\
|
|
device \n\
|
|
(iii) Device List and their corresponding IDs can be got using \n\
|
|
\"mm-audio-native-test -format devctl\" and also is displayed \n\
|
|
during beginning of any playback session \n";
|
|
|
|
void devctl_help_menu(void)
|
|
{
|
|
|
|
int i, alsa_ctl, dev_cnt, device_id;
|
|
const char **device_names;
|
|
|
|
printf("%s\n", devctl_help_text);
|
|
if (!devmgr_mixer_init_flag) {
|
|
alsa_ctl = msm_mixer_open("/dev/snd/controlC0", 0);
|
|
if (alsa_ctl < 0)
|
|
perror("Fail to open ALSA MIXER\n");
|
|
else
|
|
devmgr_mixer_init_flag = 1;
|
|
}
|
|
if (devmgr_mixer_init_flag) {
|
|
dev_cnt = msm_get_device_count();
|
|
device_names = msm_get_device_list();
|
|
for (i = 0; i < dev_cnt;) {
|
|
device_id = msm_get_device(device_names[i]);
|
|
if (device_id >= 0)
|
|
printf("device name %s:dev_id: %d\n",
|
|
device_names[i],
|
|
device_id);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int devmgr_disable_device(int dev_id, unsigned short route_dir)
|
|
{
|
|
if (route_dir == DIR_RX){
|
|
devmgr_dev_count_rx--;
|
|
if (devmgr_dev_count_rx == 0) {
|
|
if (msm_en_device(dev_id, 0) < 0)
|
|
return -1;
|
|
}
|
|
}
|
|
else if (route_dir == DIR_TX){
|
|
devmgr_dev_count_tx--;
|
|
if (devmgr_dev_count_tx == 0) {
|
|
if (msm_en_device(dev_id, 0) < 0)
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
perror("devmgr_disable_device: Invalid route direction\n");
|
|
return 0;
|
|
}
|
|
|
|
int devmgr_enable_device(int dev_id, unsigned short route_dir)
|
|
{
|
|
|
|
if (msm_en_device(dev_id, 1) < 0)
|
|
return -1;
|
|
if (route_dir == DIR_RX)
|
|
devmgr_dev_count_rx++;
|
|
else if (route_dir == DIR_TX)
|
|
devmgr_dev_count_tx++;
|
|
else
|
|
perror("devmgr_enable_device: Invalid route direction\n");
|
|
return 0;
|
|
}
|
|
|
|
int devmgr_register_session(unsigned short session_id, unsigned short route_dir)
|
|
{
|
|
#ifdef QDSP6V2
|
|
int acdb_id;
|
|
#endif
|
|
|
|
printf("devmgr_register_session: Registering Session ID = %d\n",
|
|
session_id);
|
|
if (route_dir == DIR_RX){
|
|
if ((devmgr_sid_count_rx < DEVMGR_MAX_PLAYBACK_SESSION) &&
|
|
(devmgr_sid_rx_array[devmgr_sid_count_rx] == DEVMGR_DEFAULT_SID))
|
|
devmgr_sid_rx_array[devmgr_sid_count_rx++] = session_id;
|
|
|
|
if (devmgr_enable_device(devmgr_devid_rx, DIR_RX) < 0){
|
|
perror("could not enable RX device\n");
|
|
return -1;
|
|
}
|
|
#ifdef QDSP6V2
|
|
acdb_mapper_get_acdb_id_from_dev_id(devmgr_devid_rx, &acdb_id);
|
|
acdb_loader_send_audio_cal(acdb_id, msm_get_device_capability(devmgr_devid_rx));
|
|
#endif
|
|
if (msm_route_stream(DIR_RX, session_id, devmgr_devid_rx, 1) < 0) {
|
|
perror("could not route stream to Device\n");
|
|
if (devmgr_disable_device(devmgr_devid_rx, DIR_RX) < 0)
|
|
perror("could not disable device\n");
|
|
return -1;
|
|
}
|
|
}
|
|
else if (route_dir == DIR_TX){
|
|
if ((devmgr_sid_count_tx < DEVMGR_MAX_RECORDING_SESSION) &&
|
|
(devmgr_sid_tx_array[devmgr_sid_count_tx] == DEVMGR_DEFAULT_SID))
|
|
devmgr_sid_tx_array[devmgr_sid_count_tx++] = session_id;
|
|
if (devmgr_enable_device(devmgr_devid_tx, DIR_TX) < 0){
|
|
perror("could not enable TX device\n");
|
|
return -1;
|
|
}
|
|
#ifdef QDSP6V2
|
|
acdb_mapper_get_acdb_id_from_dev_id(devmgr_devid_tx, &acdb_id);
|
|
acdb_loader_send_audio_cal(acdb_id, msm_get_device_capability(devmgr_devid_tx));
|
|
#endif
|
|
if (msm_route_stream(DIR_TX, session_id, devmgr_devid_tx, 1) < 0) {
|
|
perror("could not route stream to Device\n");
|
|
if (devmgr_disable_device(devmgr_devid_tx, DIR_TX) < 0)
|
|
perror("could not disable device\n");
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
perror("devmgr_register_session: Invalid route direction.\n");
|
|
return 0;
|
|
}
|
|
|
|
int devmgr_unregister_session(unsigned short session_id, unsigned short route_dir)
|
|
{
|
|
|
|
int index = 0;
|
|
printf("devmgr_unregister_session: Unregistering Session ID = %d\n",
|
|
session_id);
|
|
if (route_dir == DIR_RX){
|
|
while (index < devmgr_sid_count_rx) {
|
|
if (session_id == devmgr_sid_rx_array[index])
|
|
break;
|
|
index++;
|
|
}
|
|
while (index < (devmgr_sid_count_rx-1)) {
|
|
devmgr_sid_rx_array[index] = devmgr_sid_rx_array[index+1];
|
|
index++;
|
|
}
|
|
/* Reset the last entry */
|
|
devmgr_sid_rx_array[index] = DEVMGR_DEFAULT_SID;
|
|
devmgr_sid_count_rx--;
|
|
|
|
if (msm_route_stream(DIR_RX, session_id, devmgr_devid_rx, 0) < 0)
|
|
perror("could not de-route stream to Device\n");
|
|
|
|
if (devmgr_disable_device(devmgr_devid_rx, DIR_RX) < 0){
|
|
perror("could not disable RX device\n");
|
|
}
|
|
}else if(route_dir == DIR_TX){
|
|
while (index < devmgr_sid_count_tx) {
|
|
if (session_id == devmgr_sid_tx_array[index])
|
|
break;
|
|
index++;
|
|
}
|
|
while (index < (devmgr_sid_count_tx-1)) {
|
|
devmgr_sid_tx_array[index] = devmgr_sid_tx_array[index+1];
|
|
index++;
|
|
}
|
|
/* Reset the last entry */
|
|
devmgr_sid_tx_array[index] = DEVMGR_DEFAULT_SID;
|
|
devmgr_sid_count_tx--;
|
|
|
|
if (msm_route_stream(DIR_TX, session_id, devmgr_devid_tx, 0) < 0)
|
|
perror("could not de-route stream to Device\n");
|
|
|
|
if (devmgr_disable_device(devmgr_devid_tx, DIR_TX) < 0){
|
|
perror("could not disable TX device\n");
|
|
}
|
|
}
|
|
else
|
|
perror("devmgr_unregister_session: Invalid route direction\n");
|
|
return 0;
|
|
}
|
|
#ifdef QDSP6V2
|
|
int devmgr_enable_voice_device(int devid_rx, int devid_tx)
|
|
{
|
|
int ret = 0;
|
|
|
|
devmgr_mvslp_devid_rx = devid_rx;
|
|
devmgr_mvslp_devid_tx = devid_tx;
|
|
|
|
ret = msm_en_device(devmgr_mvslp_devid_rx, 1);
|
|
if (ret < 0)
|
|
printf("Error %d enabling rx device devid=%d \n", ret, devmgr_mvslp_devid_rx);
|
|
|
|
ret = msm_en_device(devmgr_mvslp_devid_tx, 1);
|
|
if (ret < 0)
|
|
printf("Error %d enabling tx device devid=%d\n", ret, devmgr_mvslp_devid_tx);
|
|
|
|
mvs_lp_flag = 1;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
int devmgr_disable_voice_device(void)
|
|
{
|
|
int ret = 0;
|
|
|
|
ret = msm_en_device(devmgr_mvslp_devid_rx, 0);
|
|
if (ret < 0)
|
|
printf("Error %d disabling rx device devid=%d\n", ret, devmgr_mvslp_devid_rx);
|
|
|
|
ret = msm_en_device(devmgr_mvslp_devid_tx, 0);
|
|
if (ret < 0)
|
|
printf("Error %d disabling tx device devid=%d\n", ret, devmgr_mvslp_devid_tx);
|
|
|
|
mvs_lp_flag = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
static int devmgr_mvs_dev_switch(int devid_rx, int devid_tx)
|
|
{
|
|
int acdb_id_tx = 0;
|
|
int acdb_id_rx = 0;
|
|
|
|
printf(" route to new device: rxid=%d, txid=%d \n", devid_rx, devid_tx);
|
|
msm_route_voice(devid_rx, devid_tx, 1);
|
|
|
|
printf(" disable current device: rx=%d, tx=%d\n", devmgr_mvslp_devid_rx, devmgr_mvslp_devid_tx);
|
|
msm_en_device(devmgr_mvslp_devid_rx, 0);
|
|
msm_en_device(devmgr_mvslp_devid_tx, 0);
|
|
|
|
printf(" load new acdb \n");
|
|
acdb_mapper_get_acdb_id_from_dev_id(devid_tx, &acdb_id_tx);
|
|
acdb_mapper_get_acdb_id_from_dev_id(devid_rx, &acdb_id_rx);
|
|
|
|
acdb_loader_send_voice_cal(acdb_id_rx, acdb_id_tx);
|
|
|
|
devmgr_mvslp_devid_rx = devid_rx;
|
|
devmgr_mvslp_devid_tx = devid_tx;
|
|
|
|
printf(" enable new devices \n");
|
|
msm_en_device(devmgr_mvslp_devid_rx, 1);
|
|
msm_en_device(devmgr_mvslp_devid_tx, 1);
|
|
|
|
return 0;
|
|
|
|
|
|
}
|
|
#endif
|
|
|
|
void audiotest_deinit_devmgr(void)
|
|
{
|
|
|
|
int alsa_ctl;
|
|
|
|
if (devmgr_init_flag && devmgr_mixer_init_flag) {
|
|
alsa_ctl = msm_mixer_close();
|
|
if (alsa_ctl < 0)
|
|
perror("Fail to close ALSA MIXER\n");
|
|
else{
|
|
printf("%s: Closed ALSA MIXER\n", __func__);
|
|
devmgr_mixer_init_flag = 0;
|
|
devmgr_init_flag = 0;
|
|
}
|
|
}
|
|
#ifdef QDSP6V2
|
|
if (acdb_init_count) {
|
|
acdb_loader_deallocate_ACDB();
|
|
acdb_init_count--;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void audiotest_init_devmgr(void)
|
|
{
|
|
|
|
int i, alsa_ctl, device_id, dev_cnt;
|
|
const char **device_names;
|
|
const char *def_device_rx = "handset_rx";
|
|
const char *def_device_tx = "handset_tx";
|
|
|
|
if (!devmgr_mixer_init_flag) {
|
|
alsa_ctl = msm_mixer_open("/dev/snd/controlC0", 0);
|
|
if (alsa_ctl < 0)
|
|
perror("Fail to open ALSA MIXER\n");
|
|
else
|
|
devmgr_mixer_init_flag = 1;
|
|
}
|
|
|
|
#ifdef QDSP6V2
|
|
if (!acdb_init_count) {
|
|
if (acdb_loader_init_ACDB() != 0) {
|
|
printf("ACDB init failed!\n");
|
|
return ;
|
|
}
|
|
acdb_init_count++;
|
|
}
|
|
#endif
|
|
if (devmgr_mixer_init_flag) {
|
|
printf("Device Manager: List of Devices supported: \n");
|
|
dev_cnt = msm_get_device_count();
|
|
device_names = msm_get_device_list();
|
|
for (i = 0; i < dev_cnt;) {
|
|
device_id = msm_get_device(device_names[i]);
|
|
if (device_id >= 0)
|
|
printf("device name %s:dev_id: %d\n", device_names[i], device_id);
|
|
i++;
|
|
}
|
|
printf("Setting default RX = %d\n", devmgr_devid_rx);
|
|
devmgr_devid_rx = msm_get_device(def_device_rx);
|
|
#ifdef QDSP6V2
|
|
devmgr_mvslp_devid_rx = devmgr_devid_rx;
|
|
#endif
|
|
printf("Setting default TX = %d\n", devmgr_devid_tx);
|
|
devmgr_devid_tx = msm_get_device(def_device_tx);
|
|
#ifdef QDSP6V2
|
|
devmgr_mvslp_devid_tx = devmgr_devid_tx;
|
|
#endif
|
|
for (i = 0; i < DEVMGR_MAX_PLAYBACK_SESSION; i++)
|
|
devmgr_sid_rx_array[i] = DEVMGR_DEFAULT_SID;
|
|
for (i = 0; i < DEVMGR_MAX_RECORDING_SESSION; i++)
|
|
devmgr_sid_tx_array[i] = DEVMGR_DEFAULT_SID;
|
|
devmgr_init_flag = 1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
struct audio_pvt_data audio_test;
|
|
|
|
#ifdef QDSP6V2
|
|
|
|
struct wav_header { /* Simple wave header */
|
|
char Chunk_ID[4]; /* Store "RIFF" */
|
|
unsigned int Chunk_size;
|
|
char Riff_type[4]; /* Store "WAVE" */
|
|
char Chunk_ID1[4]; /* Store "fmt " */
|
|
unsigned int Chunk_fmt_size;
|
|
unsigned short Compression_code; /*1 - 65,535, 1 - pcm */
|
|
unsigned short Number_Channels; /* 1 - 65,535 */
|
|
unsigned int Sample_rate; /* 1 - 0xFFFFFFFF */
|
|
unsigned int Bytes_Sec; /*1 - 0xFFFFFFFF */
|
|
unsigned short Block_align; /* 1 - 65,535 */
|
|
unsigned short Significant_Bits_sample; /* 1 - 65,535 */
|
|
char Chunk_ID2[4]; /* Store "data" */
|
|
unsigned int Chunk_data_size;
|
|
} __attribute__ ((packed));
|
|
|
|
static struct wav_header append_header = {
|
|
{'R', 'I', 'F', 'F'}, 0, {'W', 'A', 'V', 'E'},
|
|
{'f', 'm', 't', ' '}, 16, 1, 2, 48000, 96000, 4,
|
|
16, {'d', 'a', 't', 'a'}, 0
|
|
};
|
|
|
|
static void create_wav_header(int Datasize)
|
|
{
|
|
append_header.Chunk_size = Datasize + 8 + 16 + 12;
|
|
append_header.Chunk_data_size = Datasize;
|
|
append_header.Sample_rate= audio_test.freq;
|
|
append_header.Number_Channels= audio_test.channels;
|
|
|
|
return;
|
|
}
|
|
|
|
void proxyport_test( int value)
|
|
{
|
|
int proxydrvrfd = 0;
|
|
FILE *outfilefp = 0;
|
|
struct msm_audio_config config;
|
|
int retval = 0;
|
|
int i = 0;
|
|
int len = 0;
|
|
int totallen = 0;
|
|
char *buff = 0;
|
|
int buffsize = 0;
|
|
|
|
proxydrvrfd = open("/dev/msm_pcm_in_proxy",O_RDONLY);
|
|
|
|
if (proxydrvrfd <= 0) {
|
|
perror("proxyporttest:open drvr failed\n");
|
|
goto err;
|
|
}
|
|
|
|
memset(&config, 0, sizeof(config));
|
|
retval = ioctl(proxydrvrfd, AUDIO_GET_CONFIG, &config);
|
|
if (retval < 0) {
|
|
perror("Proxyporttest:set config failed\n");
|
|
goto err;
|
|
}
|
|
config.sample_rate = audio_test.freq;
|
|
config.channel_count= audio_test.channels;
|
|
|
|
retval = ioctl(proxydrvrfd, AUDIO_SET_CONFIG, &config);
|
|
if (retval < 0) {
|
|
perror("Proxyporttest:set config failed\n");
|
|
goto err;
|
|
}
|
|
|
|
/* to know the buffer size calculated by driver
|
|
* corresponding to the sample rate and channels set
|
|
*/
|
|
retval = ioctl(proxydrvrfd, AUDIO_GET_CONFIG, &config);
|
|
if (retval < 0) {
|
|
perror("Proxyporttest:set config failed\n");
|
|
goto err;
|
|
}
|
|
|
|
buffsize = config.buffer_size;
|
|
buff = malloc(buffsize);
|
|
|
|
printf("sample rate %d channels %d\n",
|
|
config.sample_rate, config.channel_count);
|
|
|
|
retval = ioctl(proxydrvrfd, AUDIO_START, NULL);
|
|
if (retval < 0) {
|
|
perror("proxyporttest:START failed\n");
|
|
goto err;
|
|
}
|
|
|
|
outfilefp = fopen(audio_test.outfile, "wb");
|
|
|
|
if (outfilefp == 0) {
|
|
perror("proxyporttest:out file drvr open failed\n");
|
|
goto err;
|
|
}
|
|
|
|
/* Set aside Space for Wave Header */
|
|
fseek(outfilefp , sizeof(append_header), SEEK_SET);
|
|
|
|
for(i = 0, totallen = 0; i < value; i++, totallen+=len){
|
|
len = read(proxydrvrfd, buff, buffsize);
|
|
if (len == buffsize)
|
|
printf("read chuck(%d) from proxy port success\n", i);
|
|
|
|
retval = fwrite(buff, buffsize, 1, outfilefp);
|
|
if (retval > 0)
|
|
printf("write chuck(%d) to file success\n", i);
|
|
}
|
|
|
|
create_wav_header(totallen);
|
|
fseek(outfilefp, 0, SEEK_SET);
|
|
fwrite((char *)&append_header, sizeof(append_header), 1, outfilefp);
|
|
fclose(outfilefp);
|
|
close(proxydrvrfd);
|
|
if(buff)
|
|
free(buff);
|
|
printf("\n\nProxy port test SUCCESS, find the PCM samples(bytes %d) at %s\n\n",
|
|
totallen, audio_test.outfile);
|
|
return;
|
|
|
|
err:
|
|
printf("\n\nProxy port test failed.\n\n");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
|
|
int devmgr_devctl_handler()
|
|
{
|
|
|
|
char *token;
|
|
int ret_val = 0, sid, dev_source, dev_dest, index, dev_id,
|
|
mute, txdev_id, rxdev_id;
|
|
int loopcounter = 1000;
|
|
#ifdef QDSP6V2
|
|
char *anc_device = "anc_headset_stereo_rx";
|
|
int device = 0;
|
|
int txdev_acdb_id, rxdev_acdb_id;
|
|
#endif
|
|
token = strtok(NULL, " ");
|
|
|
|
if (token != NULL) {
|
|
if (!memcmp(token, "-cmd=", (sizeof("-cmd=") - 1))) {
|
|
token = &token[sizeof("-cmd=") - 1];
|
|
if (!strcmp(token, "dev_switch_rx")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=",
|
|
(sizeof("-dev_id=") - 1))) {
|
|
dev_dest = atoi(&token
|
|
[sizeof("-dev_id=") - 1]);
|
|
dev_source = devmgr_devid_rx;
|
|
if (devmgr_mixer_init_flag &&
|
|
devmgr_init_flag) {
|
|
if (dev_source != dev_dest) {
|
|
printf("%s: Device Switch from = %d to = %d\n", __func__,
|
|
dev_source, dev_dest);
|
|
if (devmgr_sid_count_rx == 0){
|
|
devmgr_devid_rx = dev_dest;
|
|
printf("%s: Device Switch Success\n",__func__);
|
|
}
|
|
|
|
for (index = 0; index < devmgr_sid_count_rx;
|
|
index++) {
|
|
#ifdef QDSP6V2
|
|
acdb_mapper_get_acdb_id_from_dev_id(
|
|
devmgr_sid_rx_array[index], &rxdev_acdb_id);
|
|
acdb_loader_send_audio_cal(rxdev_acdb_id,
|
|
msm_get_device_capability(
|
|
devmgr_sid_rx_array[index]));
|
|
#endif
|
|
msm_route_stream
|
|
(DIR_RX, devmgr_sid_rx_array[index],
|
|
dev_dest, 1);
|
|
if (
|
|
(devmgr_disable_device
|
|
(dev_source, DIR_RX)) == 0) {
|
|
msm_route_stream(DIR_RX, devmgr_sid_rx_array[index],
|
|
dev_source, 0);
|
|
if (
|
|
(devmgr_enable_device(dev_dest, DIR_RX)
|
|
) == 0) {
|
|
printf("%s: Device Switch Success\n",__func__);
|
|
devmgr_devid_rx = dev_dest;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
printf("%s(): Device has not changed as current device is:%d\n",
|
|
__func__, dev_dest);
|
|
}
|
|
}
|
|
}
|
|
#ifdef QDSP6V2
|
|
if (!memcmp(token, "-proxyporttest=", (sizeof("-proxyporttest=") - 1))) {
|
|
dev_id = atoi(&token [sizeof("-proxyporttest=") - 1]);
|
|
printf("-->proxy port dev id %d\n", dev_id);
|
|
|
|
/* setup defaults */
|
|
audio_test.freq = 48000;
|
|
audio_test.channels = 2;
|
|
loopcounter = 1000;
|
|
|
|
while (token != NULL) {
|
|
if (!memcmp(token, "-outfile=", (sizeof("-outfile=") - 1))) {
|
|
token = &token[sizeof("-outfile=") - 1];
|
|
audio_test.outfile = token;
|
|
printf("-->outfile %s\n", token);
|
|
} else if (!memcmp(token, "-channels=", (sizeof("-channels=") - 1))) {
|
|
audio_test.channels=atoi(&token[sizeof("-channels=") - 1]);
|
|
printf("-->channels %d\n", audio_test.channels);
|
|
} else if (!memcmp(token,"-samplerate=", (sizeof("-samplerate=" - 1)))) {
|
|
audio_test.freq = atoi(&token[sizeof("-samplerate=") - 1]);
|
|
printf("-->sample rate %d\n", audio_test.freq);
|
|
} else if (!memcmp(token, "-time=", (sizeof("-time=") - 1))) {
|
|
loopcounter = atoi(&token[sizeof("-time=") - 1]);
|
|
printf("-->loopcounter %d\n", loopcounter);
|
|
}
|
|
token = strtok(NULL, " ");
|
|
}
|
|
|
|
for (index = 0; index < devmgr_sid_count_rx; index++) {
|
|
msm_route_stream (DIR_RX, devmgr_sid_rx_array[index], dev_id, 1);
|
|
if ( (devmgr_enable_device(dev_id, DIR_RX) ) == 0) {
|
|
printf("Proxy Device Switch on Success\n");
|
|
}
|
|
else
|
|
printf("Proxy Device switch on failure\n");
|
|
}
|
|
|
|
proxyport_test(loopcounter);
|
|
|
|
for (index = 0; index < devmgr_sid_count_rx; index++) {
|
|
msm_route_stream (DIR_RX, devmgr_sid_rx_array[index], dev_id, 0);
|
|
if ( (devmgr_disable_device(dev_id, DIR_RX) ) == 0) {
|
|
printf("Proxy Device Switch off Success\n");
|
|
}
|
|
else
|
|
printf("Proxy Device switch off failure\n");
|
|
}
|
|
|
|
}
|
|
#endif /*QDSP6V2*/
|
|
} else if (!strcmp(token, "dev_switch_tx")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=",
|
|
(sizeof("-dev_id=") - 1))) {
|
|
dev_dest = atoi(&token
|
|
[sizeof("-dev_id=") - 1]);
|
|
dev_source = devmgr_devid_tx;
|
|
if (devmgr_mixer_init_flag &&
|
|
devmgr_init_flag) {
|
|
if (dev_source != dev_dest) {
|
|
printf("%s: Device Switch from = %d to = %d\n", __func__,
|
|
dev_source, dev_dest);
|
|
if (devmgr_sid_count_tx == 0){
|
|
devmgr_devid_tx = dev_dest;
|
|
printf("%s: Device Switch Success\n",__func__);
|
|
}
|
|
|
|
for (index = 0; index < devmgr_sid_count_tx; index++) {
|
|
#ifdef QDSP6V2
|
|
acdb_mapper_get_acdb_id_from_dev_id(
|
|
devmgr_sid_tx_array[index], &txdev_acdb_id);
|
|
acdb_loader_send_audio_cal(txdev_acdb_id,
|
|
msm_get_device_capability(
|
|
devmgr_sid_tx_array[index]));
|
|
#endif
|
|
msm_route_stream
|
|
(DIR_TX, devmgr_sid_tx_array[index],
|
|
dev_dest, 1);
|
|
if (
|
|
(devmgr_disable_device
|
|
(dev_source, DIR_TX)) == 0) {
|
|
msm_route_stream(DIR_TX, devmgr_sid_tx_array[index],
|
|
dev_source, 0);
|
|
if (
|
|
(devmgr_enable_device(dev_dest, DIR_TX)
|
|
) == 0) {
|
|
printf("%s: Device Switch Success\n",__func__);
|
|
devmgr_devid_tx = dev_dest;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
printf("%s(): Device has not changed as current device is:%d\n",
|
|
__func__, dev_dest);
|
|
}
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "enable_dev")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
msm_en_device(dev_id, 1);
|
|
}
|
|
} else if (!strcmp(token, "disable_dev")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
msm_en_device(dev_id, 0);
|
|
}
|
|
} else if (!strcmp(token, "rx_route")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-sid=", (sizeof
|
|
("-sid=") - 1))) {
|
|
sid = atoi(&token[sizeof
|
|
("-sid=") - 1]);
|
|
devmgr_devid_rx = dev_id;
|
|
devmgr_register_session
|
|
(sid, DIR_RX);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "mute_dev")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-mute=", (sizeof
|
|
("-mute=") - 1))) {
|
|
mute = atoi(&token[sizeof
|
|
("-mute=") - 1]);
|
|
msm_device_mute
|
|
(dev_id, mute);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "tx_route")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-sid=", (sizeof
|
|
("-sid=") - 1))) {
|
|
sid = atoi(&token[sizeof
|
|
("-sid=") - 1]);
|
|
devmgr_devid_tx = dev_id;
|
|
devmgr_register_session
|
|
(sid, DIR_TX);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "rx_deroute")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-sid=", (sizeof
|
|
("-sid=") - 1))) {
|
|
sid = atoi(&token[sizeof
|
|
("-sid=") - 1]);
|
|
msm_route_stream
|
|
(DIR_RX, sid, dev_id, 0);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "tx_deroute")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-dev_id=", (sizeof
|
|
("-dev_id=") - 1))) {
|
|
dev_id = atoi(&token[sizeof("-dev_id=")
|
|
- 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-sid=", (sizeof
|
|
("-sid=") - 1))) {
|
|
sid = atoi(&token[sizeof
|
|
("-sid=") - 1]);
|
|
msm_route_stream
|
|
(DIR_TX, sid, dev_id, 0);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "voice_route")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=", (sizeof
|
|
("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=",
|
|
(sizeof("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
msm_route_voice
|
|
(rxdev_id, txdev_id, 1);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "voice_deroute")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=", (sizeof
|
|
("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=",
|
|
(sizeof("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
msm_route_voice
|
|
(txdev_id, rxdev_id, 0);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "voice_rx_vol")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-volume=", (sizeof
|
|
("-volume=") - 1))) {
|
|
int volume = atoi(&token[sizeof
|
|
("-volume=") - 1]);
|
|
msm_set_voice_rx_vol(volume);
|
|
}
|
|
} else if (!strcmp(token, "start_voice")) {
|
|
/*
|
|
* User will be able to do voice loopback and
|
|
* mute or unmute voice path. This test app
|
|
* exercises the voice call API just from
|
|
* application side; Same should be invoked
|
|
* from modem side to make it work
|
|
*/
|
|
msm_start_voice();
|
|
} else if (!strcmp(token, "end_voice")) {
|
|
msm_end_voice();
|
|
} else if (!strcmp(token, "voice_tx_mute")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-mute=", (sizeof
|
|
("-mute=") - 1))) {
|
|
int mute = atoi(&token[sizeof
|
|
("-mute=") - 1]);
|
|
msm_set_voice_tx_mute(mute);
|
|
}
|
|
}
|
|
#ifdef QDSP6V2
|
|
else if (!strcmp(token, "enable_anc")) {
|
|
ret_val |= acdb_loader_send_anc_cal(ANC_FF_STEREO_RX_ACDB_ID);
|
|
device = msm_get_device(anc_device);
|
|
ret_val |= msm_enable_anc(device, 1);
|
|
printf("Returned from enabling anc %d\n", ret_val);
|
|
} else if (!strcmp(token, "disable_anc")) {
|
|
device = msm_get_device(anc_device);
|
|
ret_val = msm_enable_anc(device, 0);
|
|
printf("Returned from disabling anc %d\n", ret_val);
|
|
} else if (!strcmp(token, "load_voice_acdb")) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=", (sizeof
|
|
("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=",
|
|
(sizeof("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
|
|
ret_val = acdb_mapper_get_acdb_id_from_dev_id(txdev_id, &txdev_acdb_id);
|
|
if (ret_val) {
|
|
printf("Error %d: Get ACDB id failed.\n", ret_val);
|
|
return ret_val;
|
|
} else {
|
|
ret_val = acdb_mapper_get_acdb_id_from_dev_id(rxdev_id, &rxdev_acdb_id);
|
|
if (ret_val) {
|
|
printf("Error %d: Get ACDB id failed.\n", ret_val);
|
|
return ret_val;
|
|
}
|
|
}
|
|
acdb_loader_send_voice_cal(txdev_acdb_id, rxdev_acdb_id);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
else if (!strcmp(token, "loopback_set")) {
|
|
printf("Loopback Set\n");
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=", (sizeof
|
|
("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=",
|
|
(sizeof("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
msm_snd_dev_loopback
|
|
(rxdev_id, txdev_id, 1);
|
|
}
|
|
}
|
|
} else if (!strcmp(token, "loopback_reset")) {
|
|
printf("Loopback Reset\n");
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=", (sizeof
|
|
("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=",
|
|
(sizeof("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
msm_snd_dev_loopback
|
|
(rxdev_id, txdev_id, 0);
|
|
}
|
|
}
|
|
}
|
|
#ifdef QDSP6V2
|
|
else if ((!strcmp(token, "mvs_dev_switch")) && (mvs_lp_flag == 1)) {
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-rxdev_id=", (sizeof
|
|
("-rxdev_id=") - 1))) {
|
|
rxdev_id = atoi(&token[sizeof
|
|
("-rxdev_id=") - 1]);
|
|
token = strtok(NULL, " ");
|
|
if (!memcmp(token, "-txdev_id=",
|
|
(sizeof("-txdev_id=") - 1))) {
|
|
txdev_id = atoi(&token[sizeof
|
|
("-txdev_id=") - 1]);
|
|
devmgr_mvs_dev_switch(rxdev_id, txdev_id);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
else {
|
|
printf("%s: Invalid command", __func__);
|
|
printf("%s\n", devctl_help_text);
|
|
ret_val = -1;
|
|
}
|
|
} else {
|
|
printf("%s: Not a devmgr command\n", __func__);
|
|
printf("%s\n", devctl_help_text);
|
|
ret_val = -1;
|
|
}
|
|
}
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
int devctl_read_params(void)
|
|
{
|
|
|
|
if (devmgr_devctl_handler() < 0) {
|
|
printf("%s() Invalid Command\n", __func__);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|