BOOL CCmdLineParser::ExpandExtNames(LPTSTR lpFilePath, LPCTSTR lpExtNames)
{
BOOL bResult = FALSE;
if ( get_path_type(lpFilePath) != 1 )
{
LPCTSTR lpFileName = get_file_name(lpFilePath);
LPTSTR lpExtName = (TCHAR*)_tcsrchr(lpFileName, _T('.'));
if ( lpExtName == NULL )
{
lpExtName = lpFilePath + _tcslen(lpFilePath);
*lpExtName++ = _T('.');
*lpExtName = _T('\0');
LPCTSTR lpFixExtName = lpExtNames;
while ( !is_empty_str(lpFixExtName) )
{
size_t nFixExtNameLen = 0;
LPTSTR lpNextFixExtName = (LPTSTR)_tcschr(lpFixExtName, _T(';'));
if ( lpNextFixExtName != NULL )
{
nFixExtNameLen = lpNextFixExtName - lpFixExtName;
lpNextFixExtName++;
}
else
{
nFixExtNameLen = _tcslen(lpFixExtName);
}
if ( lpExtName + nFixExtNameLen < lpFilePath + MAX_PATH )
{
_tcsncpy(lpExtName, lpFixExtName, nFixExtNameLen);
lpExtName[nFixExtNameLen] = 0;
if ( get_path_type(lpFilePath) == 1 )
{
bResult = TRUE;
break;
}
}
lpFixExtName = lpNextFixExtName;
}
if ( !bResult )
{
lpExtName[-1] = _T('\0');
}
}
}
else
{
bResult = TRUE;
}
return bResult;
}
static rc_t vdb_info_1( VSchema * schema, dump_format_t format, const VDBManager *mgr,
const char * acc_or_path, const char * table_name )
{
rc_t rc = 0;
vdb_info_data data;
memset( &data, 0, sizeof data );
data.s_platform = PT_NONE;
data.acc = acc_or_path;
/* #1 get path-type */
data.s_path_type = get_path_type( mgr, acc_or_path );
if ( data.s_path_type[ 0 ] == 'D' || data.s_path_type[ 0 ] == 'T' )
{
rc_t rc1;
/* #2 fork by table or database */
switch ( data.s_path_type[ 0 ] )
{
case 'D' : vdb_info_db( &data, schema, mgr ); break;
case 'T' : vdb_info_tab( &data, schema, mgr ); break;
}
/* try to resolve the path locally */
rc1 = resolve_accession( acc_or_path, data.path, sizeof data.path, false ); /* vdb-dump-helper.c */
if ( rc1 == 0 )
data.file_size = get_file_size( data.path, false );
else
{
/* try to resolve the path remotely */
rc1 = resolve_accession( acc_or_path, data.path, sizeof data.path, true ); /* vdb-dump-helper.c */
if ( rc1 == 0 )
{
data.file_size = get_file_size( data.path, true );
/* try to find out the cache-file */
rc1 = resolve_cache( acc_or_path, data.cache, sizeof data.cache ); /* vdb-dump-helper.c */
if ( rc1 == 0 )
{
/* try to find out cache completeness */
check_cache_comleteness( data.cache, &data.cache_percent, &data.bytes_in_cache );
}
}
}
switch ( format )
{
case df_xml : rc = vdb_info_print_xml( &data ); break;
case df_json : rc = vdb_info_print_json( &data ); break;
case df_csv : rc = vdb_info_print_sep( &data, ',' ); break;
case df_tab : rc = vdb_info_print_sep( &data, '\t' ); break;
case df_sql : rc = vdb_info_print_sql( table_name, &data ); break;
default : rc = vdb_info_print_dflt( &data ); break;
}
}
return rc;
}
static rc_t vdb_info_1( VSchema * schema, dump_format_t format, const VDBManager *mgr,
const char * acc_or_path, const char * table_name )
{
rc_t rc = 0;
vdb_info_data data;
memset( &data, 0, sizeof data );
data.s_platform = PT_NONE;
data.acc = acc_or_path;
/* #1 get path-type */
data.s_path_type = get_path_type( mgr, acc_or_path );
if ( data.s_path_type[ 0 ] == 'D' || data.s_path_type[ 0 ] == 'T' )
{
rc_t rc1;
/* #2 fork by table or database */
switch ( data.s_path_type[ 0 ] )
{
case 'D' : vdb_info_db( &data, schema, mgr ); break;
case 'T' : vdb_info_tab( &data, schema, mgr ); break;
}
rc1 = resolve_accession( acc_or_path, data.path, sizeof data.path, false );
if ( rc1 == 0 )
data.file_size = get_file_size( data.path );
switch ( format )
{
case df_xml : rc = vdb_info_print_xml( &data ); break;
case df_json : rc = vdb_info_print_json( &data ); break;
case df_csv : rc = vdb_info_print_sep( &data, ',' ); break;
case df_tab : rc = vdb_info_print_sep( &data, '\t' ); break;
case df_sql : rc = vdb_info_print_sql( table_name, &data ); break;
default : rc = vdb_info_print_dflt( &data ); break;
}
}
return rc;
}
//------------------------------------------------------------------------------
bool make_dir(const char* dir)
{
int type = get_path_type(dir);
if (type == path_type_dir)
return true;
str<> next;
path::get_directory(dir, next);
if (!next.empty() && !path::is_root(next.c_str()))
if (!make_dir(next.c_str()))
return false;
if (*dir)
{
wstr<280> wdir(dir);
return (CreateDirectoryW(wdir.c_str(), nullptr) == TRUE);
}
return true;
}
enum adie_state_ret_enum_type adie_state_digital_analog_active(u32 dev_type,
u32 dev_id)
{
s32 dal_rc;
enum adie_state_ret_enum_type rc;
enum adie_codec_path_type_enum path_type;
dal_rc = CAD_RES_SUCCESS;
rc = ADIE_STATE_RC_SUCCESS;
path_type = get_path_type(dev_type);
if (adie_state.adie_path_type[dev_type].enabled == ADIE_TRUE) {
/* Stay in this state till teardown or reconfigure */
if ((path_type == ADIE_CODEC_RX) ||
(path_type == ADIE_CODEC_LB)) {
if (is_speaker_mono(dev_id)) {
/* make sure its not already on */
if (!adie_spkr_mono_ref2_cnt) {
if (pmic_is_stereo)
pmic_spkr_en_mute(
LEFT_SPKR, 1);
else
pmic_speaker_cmd(
SPKR_MUTE_OFF);
}
/* increment ref count for LB and RX devices */
adie_spkr_mono_ref2_cnt++;
} else if (is_speaker_stereo(dev_id)) {
/* make sure its not already on */
if (!adie_spkr_stereo_ref2_cnt) {
if (pmic_is_stereo) {
pmic_spkr_en_mute(
LEFT_SPKR, 1);
pmic_spkr_en_mute(
RIGHT_SPKR, 1);
} else {
pmic_speaker_cmd(
SPKR_MUTE_OFF);
}
}
/* increment ref count for LB and RX devices */
adie_spkr_stereo_ref2_cnt++;
}
} else {
D("ARD ADIE Loopback Device\n");
}
} else {
if ((path_type == ADIE_CODEC_RX) ||
(path_type == ADIE_CODEC_LB)) {
if (is_speaker_mono(dev_id)) {
/* decrement ref count for LB or RX device */
adie_spkr_mono_ref2_cnt--;
if (!adie_spkr_mono_ref2_cnt) {
if (pmic_is_stereo)
pmic_spkr_en_mute(
LEFT_SPKR, 0);
else
pmic_speaker_cmd(SPKR_MUTE_ON);
}
} else if (is_speaker_stereo(dev_id)) {
/* decrement ref count for LB/RX device */
adie_spkr_stereo_ref2_cnt--;
if (!adie_spkr_stereo_ref2_cnt) {
if (pmic_is_stereo) {
pmic_spkr_en_mute(
LEFT_SPKR, 0);
pmic_spkr_en_mute(
RIGHT_SPKR, 0);
} else {
pmic_speaker_cmd(SPKR_MUTE_ON);
}
}
}
} else {
D("ARD ADIE Loopback Device\n");
}
/* Proceed to digital off stage */
dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle,
path_type, ADIE_CODEC_ANALOG_OFF);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Proceed to Stage failed,"
" dev_type %d\n", dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
adie_state.adie_path_type[dev_type].state =
ADIE_STATE_DIGITAL_ACTIVE;
adie_state.adie_path_type[dev_type].enable_request = ADIE_FALSE;
rc = ADIE_STATE_RC_CONTINUE;
}
done:
return rc;
}
enum adie_state_ret_enum_type adie_state_digital_active(u32 dev_type,
u32 dev_id)
{
enum adie_state_ret_enum_type rc;
enum adie_codec_path_type_enum path_type;
s32 dal_rc;
rc = ADIE_STATE_RC_SUCCESS;
dal_rc = CAD_RES_SUCCESS;
path_type = get_path_type(dev_type);
if (adie_state.adie_path_type[dev_type].enable_request == ADIE_TRUE) {
/* Prepare the PMIC, if necessary. Configure and power on,
but mute it until codec output is ready. */
if (path_type == ADIE_CODEC_TX)
if ((dev_id == CAD_HW_DEVICE_ID_HANDSET_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_HEADSET_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_SPKR_PHONE_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_HANDSETMIC_HEADSET_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_LOOPBACK_SPKR_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_LOOPBACK_HEADSET_MIC) ||
(dev_id == CAD_HW_DEVICE_ID_LINE_IN_MIC) )
pmic_mic_en(ON_CMD);
else
/* need to turn off MIC bias
for TTY_HEADSET_MIC */
pmic_mic_en(OFF_CMD);
else if ((path_type == ADIE_CODEC_RX) ||
(path_type == ADIE_CODEC_LB)) {
struct spkr_config_mode scm;
memset(&scm, 0, sizeof(struct spkr_config_mode));
if (is_speaker_mono(dev_id)) {
if (!adie_spkr_mono_ref1_cnt) {
if (pmic_is_stereo) {
scm.is_right_chan_en = 0;
scm.is_left_chan_en = 1;
scm.is_stereo_en = 0;
scm.is_hpf_en = 1;
pmic_spkr_en_mute(
LEFT_SPKR, 0);
pmic_spkr_en_mute(
RIGHT_SPKR, 0);
pmic_set_spkr_configuration(
&scm);
pmic_spkr_en(LEFT_SPKR, 1);
pmic_spkr_en(RIGHT_SPKR, 0);
} else {
pmic_speaker_cmd(SPKR_MUTE_ON);
pmic_speaker_cmd(SPKR_ENABLE);
}
}
/* keep a reference for stereo speaker.
case when Rx spkr is disabled when LB speaker
is already enabled. */
adie_spkr_mono_ref1_cnt++;
} else if (is_speaker_stereo(dev_id)) {
if (!adie_spkr_stereo_ref1_cnt) {
if (pmic_is_stereo) {
scm.is_right_chan_en = 1;
scm.is_left_chan_en = 1;
scm.is_stereo_en = 1;
scm.is_hpf_en = 1;
pmic_spkr_en_mute(
LEFT_SPKR, 0);
pmic_spkr_en_mute(
RIGHT_SPKR, 0);
pmic_set_spkr_configuration(
&scm);
pmic_spkr_en(LEFT_SPKR, 1);
pmic_spkr_en(RIGHT_SPKR, 1);
} else {
pmic_speaker_cmd(SPKR_MUTE_ON);
pmic_speaker_cmd(SPKR_ENABLE);
}
}
/* keep a reference for stereo speaker.
case when Rx spkr is disabled when LB speaker
is already enabled. */
adie_spkr_stereo_ref1_cnt++;
}
} else {
pr_err("bad path type\n");
}
/* Proceed to next stage */
dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle,
path_type, ADIE_CODEC_DIGITAL_ANALOG_READY);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Proceed to Stage failed,"
" dev_type %d\n", dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
adie_state.adie_path_type[dev_type].state =
ADIE_STATE_DIGITAL_ANALOG_ACTIVE;
adie_state.adie_path_type[dev_type].enabled = ADIE_TRUE;
adie_state.adie_path_type[dev_type].enable_request = ADIE_FALSE;
rc = ADIE_STATE_RC_CONTINUE;
} else {
if (path_type == ADIE_CODEC_TX)
pmic_mic_en(OFF_CMD);
else if ((path_type == ADIE_CODEC_RX) ||
(path_type == ADIE_CODEC_LB)) {
if (is_speaker_mono(dev_id)) {
/* disable a speaker LB or RX */
adie_spkr_mono_ref1_cnt--;
/* if no active speaker ref then disable pmic */
if (!adie_spkr_mono_ref1_cnt) {
if (pmic_is_stereo) {
pmic_spkr_en(LEFT_SPKR, 0);
pmic_spkr_en(RIGHT_SPKR, 0);
} else
pmic_speaker_cmd(SPKR_DISABLE);
}
} else if (is_speaker_stereo(dev_id)) {
/* disable a speaker LB or RX */
adie_spkr_stereo_ref1_cnt--;
/* if no active speaker ref then disable pmic */
if (!adie_spkr_stereo_ref1_cnt) {
if (pmic_is_stereo) {
pmic_spkr_en(LEFT_SPKR, 0);
pmic_spkr_en(RIGHT_SPKR, 0);
} else
pmic_speaker_cmd(SPKR_DISABLE);
}
}
}
/* Proceed to digital off stage */
dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle,
path_type, ADIE_CODEC_DIGITAL_OFF);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Proceed to Stage failed,"
" dev_type %d\n", dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
adie_state.adie_path_type[dev_type].state = ADIE_STATE_RESET;
rc = ADIE_STATE_RC_CONTINUE;
}
done:
return rc;
}
enum adie_state_ret_enum_type adie_state_reset(u32 dev_type, u32 dev_id)
{
enum adie_state_ret_enum_type rc;
s32 dal_rc;
enum adie_codec_path_type_enum path_type;
u32 path_id;
u32 freq_plan;
rc = ADIE_STATE_RC_SUCCESS;
dal_rc = CAD_RES_SUCCESS;
if (adie_state.adie_path_type[dev_type].enable_request != ADIE_TRUE) {
rc = ADIE_STATE_RC_SUCCESS;
adie_state.adie_path_type[dev_type].enabled = ADIE_FALSE;
goto done;
}
path_id = get_path_id(dev_id);
path_type = get_path_type(dev_type);
if (path_type == ADIE_CODEC_RX)
freq_plan = 48000;
else {
if (g_clk_info.tx_clk_freq > 16000)
freq_plan = 48000;
else if (g_clk_info.tx_clk_freq > 8000)
freq_plan = 16000;
else
freq_plan = 8000;
}
/* Set the path */
dal_rc = rpc_adie_codec_set_path(adie_state.adie_handle, path_id,
path_type);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Set Path failed for dev_type %d\n", dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
/* Set the freq plan */
dal_rc = rpc_adie_codec_set_path_freq_plan(adie_state.adie_handle,
path_type, freq_plan);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Set Path Freq Plan failed for dev_type %d\n",
dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
/* Proceed to stage */
dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle,
path_type, ADIE_CODEC_DIGITAL_READY);
if (dal_rc != CAD_RES_SUCCESS) {
pr_err("ARD ADIE Proceed to Stage failed for dev_type %d\n",
dev_type);
rc = ADIE_STATE_RC_FAILURE;
goto done;
}
adie_state.adie_path_type[dev_type].state = ADIE_STATE_DIGITAL_ACTIVE;
rc = ADIE_STATE_RC_CONTINUE;
done:
return rc;
}
