/*******************************************************************************
Description:
VINETIC Report Set for all vinetic messages
Arguments:
pDev - pointer to the device interface
driver_level - new DBG_LEVEL
Return:
IFX_SUCCESS if no error, otherwise IFX_ERROR
*******************************************************************************/
IFX_int32_t VINETIC_Report_Set(IFX_uint32_t driver_level)
{
if ((driver_level > DBG_LEVEL_HIGH) || (driver_level < DBG_LEVEL_LOW))
{
SetTraceLevel(VINETIC, DBG_LEVEL_OFF);
SetLogLevel(VINETIC, DBG_LEVEL_OFF);
}
else
{
SetTraceLevel(VINETIC, driver_level);
SetLogLevel(VINETIC, driver_level);
}
return IFX_SUCCESS;
}
RayTracer::RayTracer()
{
m_buffHeight = m_buffWidth = 0.0;
m_renderCount = 0;
SetTraceLevel(5);
m_traceflag = (TraceFlag)(TRACE_AMBIENT | TRACE_DIFFUSE_AND_SPEC | TRACE_SHADOW | TRACE_REFLECTION | TRACE_REFRACTION);
}
CTraceLog::CTraceLog(const string& szFilelog)
{
m_pFileLog = NULL;
m_szFileLogName = szFilelog;
OpenLogFile();
SetTraceLevel(5);
}
IFX_int32_t VINETIC_RuntimeTrace_Report_Set (IFX_uint32_t level)
{
#ifdef RUNTIME_TRACE
SetTraceLevel (VINETIC_RUNTIME_TRACE, level);
return IFX_SUCCESS;
#else
return IFX_ERROR;
#endif /* RUNTIME_TRACE */
}
int main(int argc, char* argv[])
{
Q_UNUSED(argc);
Q_UNUSED(argv);
SetTraceLevel( TraceDetail );
bool wasSuccessful = false;
test::CTCFibonacciTest* testData = new test::CTCFibonacciTest();
//double check for allocation errors
if ( 0 != testData ) {
wasSuccessful = testData->runTests();
//finished processing, so we delete inputData in order to release the parser a
//and call Teminate, below
delete testData;
}
return wasSuccessful ? 0 : 1;
}
int main(int argc, char* argv[])
{
char* filename = "sample3.log";
boost::filesystem::path logfile(filename);
boost::filesystem::remove(logfile);
int x = boost::log::sources::aux::get_severity_level();
boost::log::sources::aux::set_severity_level(3);
x = boost::log::sources::aux::get_severity_level();
int n = 4;
boost::log::init_log_to_console
(
std::cerr,
boost::log::keywords::filter = boost::log::filters::attr< boost::log::trivial::severity_level >("Severity", std::nothrow) >= n,
boost::log::keywords::format = boost::log::formatters::format("%1% [%2%] <%3%> %4%")
% boost::log::formatters::date_time("TimeStamp", std::nothrow)
% boost::log::formatters::time_duration("Uptime", std::nothrow)
% boost::log::formatters::attr< boost::log::trivial::severity_level >("Severity", std::nothrow)
% boost::log::formatters::message()
);
SetTraceLevel("file");
return 0;
}
int main(int argc, char *argv[])
{
int check_integrity = 0;
int check_iplog = 0, check_replycache = 0;
char *timespec_iplog = NULL, *timespec_replycache = NULL;
int vacuum_db = 0, purge_deleted = 0, set_deleted = 0, dangling_aliases = 0, rehash = 0;
int show_help = 0;
int do_nothing = 1;
int is_header = 0;
int migrate = 0, migrate_limit = 10000;
static struct option long_options[] = {
{ "rehash", 0, 0, 0 },
{ 0, 0, 0, 0 }
};
int opt_index = 0;
int opt;
g_mime_init(0);
openlog(PNAME, LOG_PID, LOG_MAIL);
setvbuf(stdout, 0, _IONBF, 0);
/* get options */
opterr = 0; /* suppress error message from getopt() */
while ((opt = getopt_long(argc, argv, "-acbtl:r:pudsMm:" "i" "f:qnyvVh", long_options, &opt_index)) != -1) {
/* The initial "-" of optstring allows unaccompanied
* options and reports them as the optarg to opt 1 (not '1') */
switch (opt) {
case 0:
do_nothing = 0;
if (strcmp(long_options[opt_index].name,"rehash")==0)
rehash = 1;
break;
case 'a':
/* This list should be kept up to date. */
vacuum_db = 1;
purge_deleted = 1;
set_deleted = 1;
dangling_aliases = 1;
check_integrity = 1;
is_header = 1;
do_nothing = 0;
break;
case 'c':
vacuum_db = 1;
do_nothing = 0;
break;
case 'b':
is_header = 1;
do_nothing = 0;
break;
case 'p':
purge_deleted = 1;
do_nothing = 0;
break;
case 'd':
set_deleted = 1;
do_nothing = 0;
break;
case 's':
dangling_aliases = 1;
do_nothing = 0;
break;
case 't':
check_integrity = 1;
do_nothing = 0;
break;
case 'u':
/* deprecated */
break;
case 'l':
check_iplog = 1;
do_nothing = 0;
if (optarg)
timespec_iplog = g_strdup(optarg);
break;
case 'r':
check_replycache = 1;
do_nothing = 0;
if (optarg)
timespec_replycache = g_strdup(optarg);
break;
case 'M':
migrate = 1;
do_nothing = 0;
break;
case 'm':
if (optarg)
migrate_limit = atoi(optarg);
break;
case 'i':
qerrorf("Interactive console is not supported in this release.\n");
return 1;
/* Common options */
case 'h':
show_help = 1;
do_nothing = 0;
break;
case 'n':
no_to_all = 1;
break;
case 'y':
yes_to_all = 1;
break;
case 'q':
/* If we get q twice, be really quiet! */
if (quiet)
reallyquiet = 1;
if (!verbose)
quiet = 1;
break;
case 'f':
if (optarg && strlen(optarg) > 0)
configFile = optarg;
else {
qerrorf("dbmail-util: -f requires a filename\n\n" );
return 1;
}
break;
case 'v':
verbose = 1;
break;
case 'V':
PRINTF_THIS_IS_DBMAIL;
return 1;
default:
printf("unrecognized option [%c]\n", optopt);
show_help = 1;
break;
}
}
if (do_nothing || show_help || (no_to_all && yes_to_all)) {
do_showhelp();
return 1;
}
/* Don't make any changes unless specifically authorized. */
if (!yes_to_all) {
qprintf("Choosing dry-run mode. No changes will be made at this time.\n");
no_to_all = 1;
}
config_read(configFile);
SetTraceLevel("DBMAIL");
GetDBParams();
qverbosef("Opening connection to database... \n");
if (db_connect() != 0) {
qerrorf("Failed. An error occured. Please check log.\n");
return -1;
}
qverbosef("Opening connection to authentication... \n");
if (auth_connect() != 0) {
qerrorf("Failed. An error occured. Please check log.\n");
return -1;
}
qverbosef("Ok. Connected.\n");
if (check_integrity) do_check_integrity();
if (purge_deleted) do_purge_deleted();
if (is_header) do_header_cache();
if (set_deleted) do_set_deleted();
if (dangling_aliases) do_dangling_aliases();
if (check_iplog) do_check_iplog(timespec_iplog);
if (check_replycache) do_check_replycache(timespec_replycache);
if (vacuum_db) do_vacuum_db();
if (rehash) do_rehash();
if (migrate) do_migrate(migrate_limit);
if (!has_errors && !serious_errors) {
qprintf("\nMaintenance done. No errors found.\n");
} else {
qerrorf("\nMaintenance done. Errors were found");
if (serious_errors) {
qerrorf(" but not fixed due to failures.\n");
qerrorf("Please check the logs for further details, "
"turning up the trace level as needed.\n");
// Indicate that something went really wrong
has_errors = 3;
} else if (no_to_all) {
qerrorf(" but not fixed.\n");
qerrorf("Run again with the '-y' option to "
"repair the errors.\n");
// Indicate that the program should be run with -y
has_errors = 2;
} else if (yes_to_all) {
qerrorf(" and fixed.\n");
qerrorf("We suggest running dbmail-util again to "
"confirm that all errors were repaired.\n");
// Indicate that the program should be run again
has_errors = 1;
}
}
auth_disconnect();
db_disconnect();
config_free();
g_mime_shutdown();
return has_errors;
}
bool TryGetNetworkFactory(const ConfigRecordType& config, function<ComputationNetworkPtr(DEVICEID_TYPE)>& createNetworkFn)
{
DEVICEID_TYPE deviceId = DeviceFromConfig(config);
int traceLevel = config(L"traceLevel", 0);
if (config.Exists(L"createNetwork"))
{
createNetworkFn = GetCreateNetworkFn(config); // (we need a separate function needed due to template code)
return true;
}
else if (config.Exists(L"SimpleNetworkBuilder"))
{
const ConfigRecordType& simpleNetworkBuilderConfig(config(L"SimpleNetworkBuilder"));
auto netBuilder = make_shared<SimpleNetworkBuilder<ElemType>>(simpleNetworkBuilderConfig); // parses the configuration and stores it in the SimpleNetworkBuilder object
createNetworkFn = [netBuilder, traceLevel](DEVICEID_TYPE deviceId)
{
auto net = shared_ptr<ComputationNetwork>(netBuilder->BuildNetworkFromDescription()); // this operates based on the configuration saved above
net->SetTraceLevel(traceLevel);
return net;
};
return true;
}
// legacy NDL
else if (config.Exists(L"NDLNetworkBuilder"))
{
const ConfigRecordType& ndlNetworkBuilderConfig(config(L"NDLNetworkBuilder"));
shared_ptr<NDLBuilder<ElemType>> netBuilder = make_shared<NDLBuilder<ElemType>>(ndlNetworkBuilderConfig);
createNetworkFn = [netBuilder, traceLevel](DEVICEID_TYPE deviceId)
{
auto net = shared_ptr<ComputationNetwork>(netBuilder->BuildNetworkFromDescription());
net->SetTraceLevel(traceLevel);
return net;
};
return true;
}
// legacy test mode for BrainScript. Will go away once we fully integrate with BS.
else if (config.Exists(L"BrainScriptNetworkBuilder") || config.Exists(L"ExperimentalNetworkBuilder" /*legacy name*/))
{
// We interface with outer old CNTK config by taking the inner part, which we get as a string, as BrainScript.
// We prepend a few standard definitions, and also definition of deviceId and precision, which all objects will pull out again when they are being constructed.
// BUGBUG: We are not getting TextLocations right in this way! Do we need to inject location markers into the source? Moot once we fully switch to BS
wstring sourceOfNetwork = config.Exists(L"BrainScriptNetworkBuilder") ? config(L"BrainScriptNetworkBuilder") : config(L"ExperimentalNetworkBuilder");
if (sourceOfNetwork.find_first_of(L"([{") != 0)
InvalidArgument("BrainScript network description must be either a BS expression in ( ) or a config record in { }");
// set the include paths to all paths that configs were read from; no additional configurable include paths are supported by BrainScriptNetworkBuilder
auto includePaths = ConfigParameters::GetBrainScriptNetworkBuilderIncludePaths();
// inject additional items into the source code
// We support two ways of specifying the network in BrainScript:
// - BrainScriptNetworkBuilder = ( any BS expression that evaluates to a ComputationNetwork )
// - BrainScriptNetworkBuilder = { constructor parameters for a ComputationNetwork }
// For back-compat, [ ] is allowed and means the same as { }
if (sourceOfNetwork[0] == '{' || sourceOfNetwork[0] == '[') // if { } form then we turn it into ComputationNetwork by constructing a ComputationNetwork from it
sourceOfNetwork = L"new ComputationNetwork " + sourceOfNetwork;
let sourceOfBS = msra::strfun::wstrprintf(L"include \'cntk.core.bs\'\n" // include our core lib. Note: Using lowercase here to match the Linux name of the CNTK exe.
L"deviceId = %d\n" // deviceId as passed in
L"traceLevel = %d\n"
L"precision = '%ls'\n" // 'float' or 'double'
L"network = %ls", // source code of expression that evaluates to a ComputationNetwork
(int)deviceId, traceLevel, ElemTypeName<ElemType>(), sourceOfNetwork.c_str());
let expr = BS::ParseConfigDictFromString(sourceOfBS, L"BrainScriptNetworkBuilder", move(includePaths));
// the rest is done in a lambda that is only evaluated when a virgin network is needed
// Note that evaluating the BrainScript *is* instantiating the network, so the evaluate call must be inside the lambda.
createNetworkFn = [expr](DEVICEID_TYPE /*deviceId*/)
{
// evaluate the parse tree, particularly the top-level field 'network'
// Evaluating it will create the network.
let object = EvaluateField(expr, L"network"); // this comes back as a BS::Object
let network = dynamic_pointer_cast<ComputationNetwork>(object); // cast it
if (!network)
LogicError("BuildNetworkFromDescription: ComputationNetwork not what it was meant to be");
return network;
};
return true;
}
else
return false;
}
/*******************************************************************************
Description:
General function for handling TAPI Ioctls.
Arguments:
pChannel - handle to TAPI_CONNECTION structure
cmd - Ioctl Command
arg - Ioctl Parameter
Return:
IFX_TRUE or IFX_FALSE or requested value.
*******************************************************************************/
IFX_int32_t TAPI_Ioctl(TAPI_CONNECTION *pChannel, IFX_uint32_t cmd,
IFX_uint32_t arg)
{
IFX_int32_t ret = IFX_SUCCESS;
void * parg = (void *)arg;
/* check channel */
switch (cmd)
{
/* Ringing Services */
case IFXPHONE_RING_CONFIG:
{
TAPI_RING_CONFIG tmpRingConfig;
if (copy_from_user (&tmpRingConfig, parg, sizeof(TAPI_RING_CONFIG)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Ring_Config(pChannel, &tmpRingConfig);
}
break;
}
case IFXPHONE_RING_GET_CONFIG:
{
TAPI_RING_CONFIG tmpRingConfig;
ret = TAPI_Phone_Ring_GetConfig(pChannel, &tmpRingConfig);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&tmpRingConfig, sizeof(TAPI_RING_CONFIG)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_RING_CADENCE:
ret = TAPI_Phone_Ring_Cadence(pChannel, arg);
break;
case IFXPHONE_RING_CADENCE_HIGH_RES:
{
TAPI_RING_CADENCE tmpCadence;
if (copy_from_user (&tmpCadence, parg, sizeof(TAPI_RING_CADENCE)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_FALSE;
}
else
{
ret = TAPI_Phone_Ring_Cadence_High_Res(pChannel, &tmpCadence);
}
break;
}
case PHONE_RING_START:
{
TAPI_PHONE_CID *pPhoneCid = NULL;
#ifdef TAPI_CID
TAPI_PHONE_CID tmpPhoneCid;
IFX_uint8_t tmpTransData [TAPI_MAX_CID_PARAMETER] = {0};
if ((arg) && copy_from_user (&tmpPhoneCid, parg,
sizeof(TAPI_PHONE_CID)) == 0)
{
pPhoneCid = &tmpPhoneCid;
/*
We don't know if cid sending is ongoing at this level, so we
better copy the data from user space in a temporary buffer,
from wich processing data will be copied from in case, instead of
copying the data directly in the processing buffer, what can corrupt
data in an ongoing cid transmission. We of course copy data twice,
but we are safe.
*/
if ((tmpPhoneCid.datalen > 0) &&
(tmpPhoneCid.datalen <= TAPI_MAX_CID_PARAMETER) &&
(tmpPhoneCid.pData != NULL))
{
if (copy_from_user (tmpTransData, tmpPhoneCid.pData,
tmpPhoneCid.datalen) == 0)
{
pPhoneCid->pData = tmpTransData;
}
}
}
#endif /* TAPI_CID */
ret = TAPI_Phone_Ring_Start(pChannel, pPhoneCid);
break;
}
case PHONE_RING_STOP:
ret = TAPI_Phone_Ring_Stop(pChannel);
break;
case PHONE_MAXRINGS:
ret = TAPI_Phone_Set_MaxRings(pChannel, arg);
break;
case PHONE_RING:
ret = TAPI_Phone_Ring(pChannel);
break;
/* Operation Control Services */
case IFXPHONE_SET_LINEFEED:
ret = TAPI_Phone_Set_Linefeed(pChannel, arg);
break;
case PHONE_HOOKSTATE:
{
IFX_int32_t nHook;
ret = TAPI_Phone_Hookstate(pChannel, &nHook);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&nHook, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#ifdef TAPI_VOICE
/* Connection Services*/
case IFXPHONE_DATA_ADD:
{
TAPI_DATA_MAPPING tmpPhoneMap;
if (copy_from_user (&tmpPhoneMap, parg, sizeof(TAPI_DATA_MAPPING)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Data_Channel_Add (pChannel, &tmpPhoneMap);
break;
}
case IFXPHONE_DATA_REMOVE:
{
TAPI_DATA_MAPPING tmpPhoneMap;
if (copy_from_user (&tmpPhoneMap, parg, sizeof(TAPI_DATA_MAPPING)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Data_Channel_Remove (pChannel, &tmpPhoneMap);
break;
}
case IFXPHONE_PHONE_ADD:
{
TAPI_PHONE_MAPPING tmpPhonePhoneMap;
if (copy_from_user (&tmpPhonePhoneMap, parg, sizeof(TAPI_PHONE_MAPPING)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Phone_Channel_Add (pChannel, &tmpPhonePhoneMap);
break;
}
case IFXPHONE_PHONE_REMOVE:
{
TAPI_PHONE_MAPPING tmpPhonePhoneMap;
if (copy_from_user (&tmpPhonePhoneMap, parg, sizeof(TAPI_PHONE_MAPPING)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Phone_Channel_Remove (pChannel, &tmpPhonePhoneMap);
break;
}
case IFXPHONE_RTP_CONF:
{
TAPI_RTP_CONF tmpRtpConf;
if (copy_from_user (&tmpRtpConf, parg, sizeof(TAPI_RTP_CONF)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_RtpConf (pChannel, &tmpRtpConf);
break;
}
case IFXPHONE_RTP_PTCONF:
{
TAPI_RTP_PT_CONF tmpRtpPTConf;
if (copy_from_user (&tmpRtpPTConf, parg, sizeof(TAPI_RTP_PT_CONF)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_Rtp_SetPayloadType (pChannel, &tmpRtpPTConf);
break;
}
case IFXPHONE_RTCP_STATISTICS:
{
TAPI_RTCP_DATA tmpRtcpData;
ret = TAPI_LL_Phone_RTCP_GetStatistics(pChannel, &tmpRtcpData);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&tmpRtcpData, sizeof(TAPI_RTCP_DATA)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_RTCP_RESET:
ret = TAPI_LL_Phone_RTCP_Reset (pChannel);
break;
case IFXPHONE_JB_CONF:
{
TAPI_JB_CONF tmpJbConf;
if (copy_from_user (&tmpJbConf, parg, sizeof(TAPI_JB_CONF)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_JB_Set (pChannel, &tmpJbConf);
break;
}
case IFXPHONE_JB_STATISTICS:
{
TAPI_JB_DATA tmpJbData;
ret = TAPI_LL_Phone_JB_GetStatistics(pChannel, &tmpJbData);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpJbData, sizeof(TAPI_JB_DATA)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_JB_RESET:
ret = TAPI_LL_Phone_JB_Reset (pChannel);
break;
case IFXPHONE_AAL_CONF:
{
TAPI_AAL_CONF tmpAalConf;
if (copy_from_user (&tmpAalConf, parg, sizeof(TAPI_AAL_CONF)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_Aal_Set (pChannel, &tmpAalConf);
break;
}
case IFXPHONE_AAL_PROFILE:
{
TAPI_AAL_PROFILE tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_AAL_PROFILE)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_AalProfile (pChannel, &tmp);
}
break;
/* Recording Services */
case PHONE_REC_CODEC:
ret = TAPI_LL_Phone_Set_Rec_Codec (pChannel, arg);
break;
#ifdef TAPI_VOICE
case PHONE_REC_START:
ret = TAPI_LL_Phone_Start_Recording (pChannel);
break;
case PHONE_REC_STOP:
ret = TAPI_LL_Phone_Stop_Recording(pChannel);
break;
#endif /* TAPI_VOICE */
case IFXPHONE_REC_HOLD:
ret = TAPI_Phone_SetRecHold (pChannel, (IFX_int32_t)arg);
break;
case PHONE_REC_DEPTH:
ret = TAPI_Phone_SetRecDepth (pChannel, (IFX_int32_t) arg);
break;
case PHONE_REC_VOLUME:
ret = TAPI_Phone_SetRecVolume (pChannel, (IFX_int32_t)arg);
break;
case PHONE_REC_LEVEL:
{
IFX_int32_t nLevel;
ret = TAPI_Phone_GetRecLevel (pChannel, (IFX_int32_t *)&nLevel);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nLevel, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
/* Play Services not used */
/*
case PHONE_PLAY_CODEC:
ret = TAPI_Phone_Set_Play_Codec(pChannel, arg);
break;
*/
#ifdef TAPI_VOICE
case PHONE_PLAY_START:
ret = TAPI_LL_Phone_Start_Playing(pChannel);
break;
case PHONE_PLAY_STOP:
ret = TAPI_LL_Phone_Stop_Playing(pChannel);
break;
#endif /* TAPI_VOICE */
case IFXPHONE_PLAY_HOLD:
ret = TAPI_Phone_SetPlayHold (pChannel, (IFX_int32_t)arg);
break;
case PHONE_PLAY_DEPTH:
ret = TAPI_Phone_SetPlayDepth (pChannel, (IFX_int32_t) arg);
break;
case PHONE_PLAY_VOLUME:
ret = TAPI_Phone_SetPlayVolume (pChannel, (IFX_int32_t)arg);
break;
case PHONE_PLAY_LEVEL:
{
IFX_int32_t nLevel;
ret = TAPI_Phone_GetPlayLevel (pChannel, (IFX_int32_t *)&nLevel);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nLevel, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_VOICE */
#ifdef TAPI_FAX_T38
/* Fax Services */
case IFXPHONE_FAX_SETMOD:
{
TAPI_FAX_MODDATA tmpFaxMod;
if (copy_from_user (&tmpFaxMod, parg, sizeof(TAPI_FAX_MODDATA)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_FaxT38_SetModulator (pChannel, &tmpFaxMod);
break;
}
case IFXPHONE_FAX_SETDEMOD:
{
TAPI_FAX_DEMODDATA tmpFaxDemod;
if (copy_from_user (&tmpFaxDemod, parg, sizeof(TAPI_FAX_DEMODDATA)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_FaxT38_SetDemodulator (pChannel, &tmpFaxDemod);
break;
}
case IFXPHONE_FAX_DISABLE:
ret = TAPI_LL_FaxT38_DisableDataPump (pChannel);
break;
case IFXPHONE_FAX_STATUS:
{
TAPI_FAX_STATUS tmpFaxStatus;
ret = TAPI_LL_FaxT38_GetStatus (pChannel, &tmpFaxStatus);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpFaxStatus, sizeof(TAPI_FAX_STATUS)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_FAX_T38 */
/* PCM Services */
case IFXPHONE_SET_PCM_CONFIG:
{
TAPI_PCM_CONFIG tmpPCMConfig;
if (copy_from_user (&tmpPCMConfig, parg, sizeof(TAPI_PCM_CONFIG)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_PCM_Set_Config(pChannel, &tmpPCMConfig);
}
break;
}
case IFXPHONE_GET_PCM_CONFIG:
{
TAPI_PCM_CONFIG tmpPCMConfig;
ret = TAPI_Phone_PCM_Get_Config(pChannel, &tmpPCMConfig);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpPCMConfig, sizeof(TAPI_PCM_CONFIG)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_SET_PCM_ACTIVATION:
ret = TAPI_Phone_PCM_Set_Activation(pChannel, arg);
break;
case IFXPHONE_GET_PCM_ACTIVATION:
ret = TAPI_Phone_PCM_Get_Activation(pChannel);
break;
/* Tone Services */
case PHONE_PLAY_TONE:
ret = TAPI_Phone_Tone_Play(pChannel, arg, TAPI_TONE_DST_LOCAL);
break;
case IFXPHONE_TONE_PLAY_NET:
ret = TAPI_Phone_Tone_Play(pChannel, arg, TAPI_TONE_DST_NET);
break;
case PHONE_SET_TONE_ON_TIME:
ret = TAPI_Phone_Tone_Set_On_Time(pChannel, arg);
break;
case PHONE_SET_TONE_OFF_TIME:
ret = TAPI_Phone_Tone_Set_Off_Time(pChannel, arg);
break;
case PHONE_GET_TONE_ON_TIME:
{
IFX_int32_t nDuration;
ret = TAPI_Phone_Tone_Get_On_Time(pChannel, &nDuration);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&nDuration, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_GET_TONE_OFF_TIME:
{
IFX_int32_t nDuration;
ret = TAPI_Phone_Tone_Get_Off_Time(pChannel, &nDuration);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDuration, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_GET_TONE_STATE:
{
IFX_uint32_t nToneState;
ret = TAPI_Phone_Tone_Get_State(pChannel, &nToneState);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nToneState, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_DIALTONE:
ret = TAPI_Phone_Tone_Dial(pChannel);
break;
case PHONE_RINGBACK:
ret = TAPI_Phone_Tone_Ringback(pChannel);
break;
case PHONE_BUSY:
ret = TAPI_Phone_Tone_Busy(pChannel);
break;
case PHONE_CPT_STOP:
ret = TAPI_Phone_Tone_Play(pChannel, arg, TAPI_TONE_DST_LOCAL);
break;
case IFXPHONE_SET_TONE_LEVEL:
{
TAPI_TONE_LEVEL tmpToneLevel;
if (copy_from_user (&tmpToneLevel, parg, sizeof(TAPI_TONE_LEVEL)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Tone_Set_Level(pChannel, &tmpToneLevel);
}
break;
}
/* Dial Services */
case IFXPHONE_GET_PULSE:
{
IFX_int32_t nPulseDigit;
ret = TAPI_Phone_Get_Pulse(pChannel, &nPulseDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nPulseDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_GET_PULSE_ASCII:
{
IFX_int32_t nPulseDigit;
ret = TAPI_Phone_Get_Pulse_ASCII(pChannel, &nPulseDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nPulseDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_PULSE_READY:
{
IFX_int32_t nPulseReady;
ret = TAPI_Phone_Pulse_Ready(pChannel, &nPulseReady);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nPulseReady, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#ifdef TAPI_DTMF
case PHONE_GET_DTMF:
{
IFX_int32_t nDtmfDigit;
ret = TAPI_Phone_Get_DTMF(pChannel, &nDtmfDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_GET_DTMF_ASCII:
{
IFX_int32_t nDtmfDigit;
ret = TAPI_Phone_Get_DTMF_ASCII(pChannel, &nDtmfDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_DTMF_OOB:
ret = TAPI_LL_Phone_Send_DTMF_OOB(pChannel, arg);
break;
case PHONE_DTMF_READY:
{
IFX_int32_t nDtmfReady;
ret = TAPI_Phone_DTMF_Ready(pChannel, &nDtmfReady);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfReady, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_DTMF */
/* Miscellaneous Services */
case IFXPHONE_GET_VERSION:
{
IFX_char_t tmpVersionString[80];
ret = TAPI_Phone_Get_Version(&tmpVersionString[0]);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpVersionString[0], sizeof(tmpVersionString)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case PHONE_EXCEPTION:
ret = TAPI_Phone_Exception(pChannel);
break;
case IFXPHONE_MASK_EXCEPTION:
ret = TAPI_Phone_Mask_Exception(pChannel, arg);
break;
case IFXPHONE_PHONE_STATUS:
{
TAPI_PHONE_STATUS tmpStatus[TAPI_MAX_CHANNELS];
IFX_int32_t ch;
if (arg == 0)
return IFX_ERROR;
ret = copy_from_user (tmpStatus, parg, sizeof(TAPI_PHONE_STATUS));
if (ret != 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: ioctl parameter error\n\r"));
return IFX_ERROR;
}
if ((ch = tmpStatus[0].channels) > TAPI_MAX_CHANNELS) {
TRACE(TAPI_DRV,DBG_LEVEL_HIGH, ("TAPI: IFXPHONE_PHONE_STATUS: Ch%d: invalid parameters\n\r",
pChannel->nChannel - 1));
return IFX_ERROR;
}
if (ch == 0)
ch = 1;
ret = TAPI_Phone_GetStatus(pChannel, tmpStatus);
copy_to_user ( parg, tmpStatus,
sizeof(TAPI_PHONE_STATUS) * ch);
}
break;
case IFXPHONE_INIT:
{
TAPI_INIT tmpInit;
if ((arg != 0) && (copy_from_user (&tmpInit, parg, sizeof(TAPI_INIT)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
if (arg == 0)
{
ret = TAPI_Phone_Init(pChannel, NULL);
}
else
{
ret = TAPI_Phone_Init(pChannel, &tmpInit);
}
}
break;
}
#ifdef TAPI_VOICE
case PHONE_FRAME:
ret = TAPI_LL_Phone_Set_Frame_Length(pChannel, arg);
break;
case IFXPHONE_GET_FRAME:
{
IFX_int32_t length = 0;
ret = TAPI_LL_Phone_Get_Frame_Length(pChannel, &length);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&length, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_VOICE */
case PHONE_VAD:
ret = TAPI_LL_Phone_VAD(pChannel, arg);
break;
case PHONE_CAPABILITIES:
{
IFX_int32_t cap;
cap = TAPI_LL_Phone_Get_Capabilities(pChannel);
copy_to_user( parg, &cap, sizeof(IFX_int32_t));
break;
}
case PHONE_CAPABILITIES_LIST:
{
TAPI_PHONE_CAPABILITY *tmpPhoneCap = NULL;
IFX_int32_t tmpcapsize = TAPI_LL_Phone_Get_Capabilities(pChannel);
tmpPhoneCap = kmalloc(tmpcapsize * sizeof(TAPI_PHONE_CAPABILITY), GFP_KERNEL);
ret = TAPI_LL_Phone_Get_Capability_List(pChannel, tmpPhoneCap);
if ((ret == IFX_SUCCESS) && (copy_to_user( parg,
tmpPhoneCap, sizeof(TAPI_PHONE_CAPABILITY) * tmpcapsize) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
kfree(tmpPhoneCap);
break;
}
case PHONE_CAPABILITIES_CHECK:
{
/* !!! revise code */
TAPI_PHONE_CAPABILITY *tmpPhoneCap = NULL;
tmpPhoneCap = kmalloc(sizeof(TAPI_PHONE_CAPABILITY), GFP_KERNEL);
if (copy_from_user (tmpPhoneCap, parg, sizeof(TAPI_PHONE_CAPABILITY)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Phone_Check_Capability(pChannel, tmpPhoneCap);
if (ret == IFX_SUCCESS || ret == 1)
{
copy_to_user ( parg, tmpPhoneCap, sizeof(TAPI_PHONE_CAPABILITY));
}
}
kfree(tmpPhoneCap);
break;
}
/* Metering Services */
case IFXPHONE_METER_CHAR:
{
TAPI_METER_CONFIG tmpMeterConfig;
if (copy_from_user (&tmpMeterConfig, parg, sizeof(TAPI_METER_CONFIG)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Meter_Config(pChannel, &tmpMeterConfig);
}
break;
}
case IFXPHONE_METER_START:
ret = TAPI_Phone_Meter_Start(pChannel);
break;
case IFXPHONE_METER_STOP:
ret = TAPI_Phone_Meter_Stop(pChannel);
break;
/* Lec Configuration */
case IFXPHONE_LECCONF:
{
TAPI_LECCONF tmpLecConf;
if (copy_from_user (&tmpLecConf, parg, sizeof(TAPI_LECCONF)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_LecConf (pChannel, &tmpLecConf);
}
break;
}
case IFXPHONE_GETLECCONF:
{
TAPI_LECCONF tmpLecConf;
ret = TAPI_Phone_GetLecConf (pChannel, &tmpLecConf);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpLecConf, sizeof(TAPI_LECCONF)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_LECCONF_PCM:
{
TAPI_LECCONF tmpLecConf;
if (copy_from_user (&tmpLecConf, parg, sizeof(TAPI_LECCONF)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_LecConf_Pcm (pChannel, &tmpLecConf);
}
break;
}
case IFXPHONE_GETLECCONF_PCM:
{
TAPI_LECCONF tmpLecConf;
ret = TAPI_Phone_GetLecConf_Pcm (pChannel, &tmpLecConf);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpLecConf, sizeof(TAPI_LECCONF)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
/* AGC Configuration/Enable */
case IFXPHONE_AGC:
ret = TAPI_LL_Phone_AgcEnable (pChannel, (TAPI_AGC_MODE)arg);
#ifdef TAPI_CID
/* Caller ID Transmission service */
case IFXPHONE_CIDCONF:
{
TAPI_CID_CONFIG tmpCidConfig;
if (copy_from_user (&tmpCidConfig, parg, sizeof(TAPI_CID_CONFIG)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_CID_Config (pChannel, &tmpCidConfig);
}
break;
}
case IFXPHONE_GETCIDCONF:
{
TAPI_CID_CONFIG tmpCidConfig;
ret = TAPI_Phone_CID_GetConfig (pChannel, &tmpCidConfig);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&tmpCidConfig, sizeof(tmpCidConfig)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_DTMFCID_CONF:
{
TAPI_DTMFCID tmpDtmfCid;
if (copy_from_user (&tmpDtmfCid, parg, sizeof(TAPI_DTMFCID)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_CID_ConfigDtmf (pChannel, &tmpDtmfCid);
}
break;
}
case IFXPHONE_CID_INFO_TX:
{
TAPI_CID_INFO_t tmpCidInfo;
if (copy_from_user (&tmpCidInfo, parg, sizeof(TAPI_CID_INFO_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
if (tmpCidInfo.nMsgElements == 0)
ret = IFX_ERROR;
else
{
tmpCidInfo.message = TAPI_MapBuffer(tmpCidInfo.message,
tmpCidInfo.nMsgElements * sizeof(TAPI_CID_MSG_ELEMENT_t));
if (tmpCidInfo.message != NULL)
{
ret = TAPI_Phone_CID_Info_Tx (pChannel, &tmpCidInfo);
TAPI_UnmapBuffer(tmpCidInfo.message);
}
else
ret = IFX_ERROR;
}
}
break;
}
/* Caller ID Reception service */
case IFXPHONE_CIDRX_START:
ret = TAPI_Phone_CidRx_Start (pChannel);
break;
case IFXPHONE_CIDRX_STOP:
ret = TAPI_Phone_CidRx_Stop (pChannel);
break;
case IFXPHONE_CIDRX_STATUS:
{
TAPI_CIDRX_STATUS tmpCidRxStatus;
ret = TAPI_LL_Phone_CidRx_Status (pChannel, &tmpCidRxStatus);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpCidRxStatus, sizeof(TAPI_CIDRX_STATUS)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_CIDRX_DATA:
{
TAPI_CIDRX_DATA tmpCidRxData;
ret = TAPI_Phone_Get_CidRxData (pChannel, &tmpCidRxData);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpCidRxData, sizeof(TAPI_CIDRX_DATA)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_CID2_CONF:
{
TAPI_CID2_CONFIG tmpCid2Conf;
if (copy_from_user (&tmpCid2Conf, parg, sizeof(TAPI_CID2_CONFIG)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_CID2_Config (pChannel, &tmpCid2Conf);
}
break;
}
case IFXPHONE_CID2_GETCONF:
{
TAPI_CID2_CONFIG tmpCid2Conf;
ret = TAPI_Phone_CID2_GetConfig (pChannel, &tmpCid2Conf);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&tmpCid2Conf, sizeof(TAPI_CID2_CONFIG)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,
("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFXPHONE_CID2_SEND:
{
TAPI_PHONE_CID tmpPhoneCid;
IFX_uint8_t tmpTransData [TAPI_MAX_CID_PARAMETER] = {0};
if (copy_from_user (&tmpPhoneCid, parg, sizeof(TAPI_PHONE_CID)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,
("TAPI: cannot copy structure from user space\n\r"));
ret = IFX_ERROR;
}
else if ((tmpPhoneCid.datalen > 0) &&
(tmpPhoneCid.datalen <= TAPI_MAX_CID_PARAMETER) &&
(tmpPhoneCid.pData != NULL))
{
/*
We don't know if cid sending is ongoing at this level, so we
better copy the data from user space in a temporary buffer,
from wich processing data will be copied from in case, instead of
copying the data directly in the processing buffer, what can corrupt
data in an ongoing cid transmission. We of course copy data twice,
but we are safe.
*/
if (copy_from_user (tmpTransData, tmpPhoneCid.pData,
tmpPhoneCid.datalen) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,
("TAPI: cannot copy data from user space\n\r"));
ret = IFX_ERROR;
}
else
{
tmpPhoneCid.pData = tmpTransData;
}
}
if (ret != IFX_ERROR)
{
ret = TAPI_Phone_CID2_Send (pChannel, &tmpPhoneCid);
}
break;
}
#endif /* TAPI_CID */
/* Report Level */
case IFXPHONE_REPORT_SET:
SetTraceLevel(TAPI_DRV, arg);
break;
case IFXPHONE_VERSION_CHECK:
{
TAPI_PHONE_VERSION vers;
if (copy_from_user (&vers, parg, sizeof(TAPI_PHONE_VERSION)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Check_Version (&vers);
}
}
break;
case IFXPHONE_VOLUME:
{
TAPI_PHONE_VOLUME tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_PHONE_VOLUME)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_LL_Phone_Volume (pChannel, &tmp);
}
break;
}
case IFXPHONE_PCM_VOLUME:
{
TAPI_PHONE_VOLUME tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_PHONE_VOLUME)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_LL_Phone_Pcm_Volume (pChannel, &tmp);
}
break;
}
case IFXPHONE_HIGH_LEVEL:
return TAPI_LL_Phone_High_Level (pChannel, arg);
case IFXPHONE_ENABLE_SIGDETECT:
{
TAPI_PHONE_SIGDETECTION tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_PHONE_SIGDETECTION)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_LL_Enable_Signal (pChannel, &tmp);
}
break;
}
case IFXPHONE_DISABLE_SIGDETECT:
{
TAPI_PHONE_SIGDETECTION tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_PHONE_SIGDETECTION)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_LL_Disable_Signal (pChannel, &tmp);
}
break;
}
case IFXPHONE_TONETABLE_CONF:
{
TAPI_TONE tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_TONE)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_Phone_Tone_TableConf (pChannel->pTapiDevice->pToneTbl,
&tmp);
}
break;
}
case IFXPHONE_CPTD_START:
{
TAPI_PHONE_CPTD tmp;
if (copy_from_user (&tmp, parg, sizeof(TAPI_PHONE_CPTD)) > 0 )
{
ret = IFX_ERROR;
}
else
{
return TAPI_Phone_DetectToneStart(pChannel, &tmp);
}
break;
}
case IFXPHONE_CPTD_STOP:
{
return TAPI_Phone_DetectToneStop(pChannel);
break;
}
default:
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: Ioctl 0x%08lX not handled by TAPI\n\r", cmd));
ret = IFX_ERROR;
break;
}
return ret;
}
int main(int argc, char *argv[])
{
int opt = 0, opt_prev = 0;
int show_help = 0;
int result = 0, delete_after_dump = 0, recursive = 0;
char *user=NULL, *mailbox=NULL, *outfile=NULL, *basedir=NULL, *search=NULL;
openlog(PNAME, LOG_PID, LOG_MAIL);
setvbuf(stdout, 0, _IONBF, 0);
g_mime_init(0);
/* get options */
opterr = 0; /* suppress error message from getopt() */
while ((opt = getopt(argc, argv,
"-u:m:o:b:s:dDr" /* Major modes */
"f:qvVh" /* Common options */ )) != -1) {
/* The initial "-" of optstring allows unaccompanied
* options and reports them as the optarg to opt 1 (not '1') */
if (opt == 1)
opt = opt_prev;
opt_prev = opt;
switch (opt) {
/* export specific options */
case 'u':
if (optarg && strlen(optarg))
user = optarg;
break;
case 'm':
if (optarg && strlen(optarg))
mailbox = optarg;
break;
case 'b':
if (optarg && strlen(optarg))
basedir = optarg;
break;
case 'o':
if (optarg && strlen(optarg))
outfile = optarg;
break;
case 'd':
delete_after_dump |= 1;
break;
case 'D':
delete_after_dump |= 2;
break;
case 'r':
recursive = 1;
break;
case 's':
if (optarg && strlen(optarg))
search = optarg;
else {
qerrorf("dbmail-mailbox: -s requires a value\n\n");
result = 1;
}
break;
/* Common options */
case 'f':
if (optarg && strlen(optarg) > 0)
configFile = optarg;
else {
qerrorf("dbmail-mailbox: -f requires a filename\n\n");
result = 1;
}
break;
case 'h':
show_help = 1;
break;
case 'q':
/* If we get q twice, be really quiet! */
if (quiet)
reallyquiet = 1;
if (!verbose)
quiet = 1;
break;
case 'v':
if (!quiet)
verbose = 1;
break;
case 'V':
/* Show the version and return non-zero. */
PRINTF_THIS_IS_DBMAIL;
result = 1;
break;
default:
/* printf("unrecognized option [%c], continuing...\n",optopt); */
break;
}
/* If there's a non-negative return code,
* it's time to free memory and bail out. */
if (result)
goto freeall;
}
/* If nothing is happening, show the help text. */
if (!user || (basedir && outfile) || show_help) {
do_showhelp();
result = 1;
goto freeall;
}
/* read the config file */
if (config_read(configFile) == -1) {
qerrorf("Failed. Unable to read config file %s\n", configFile);
result = -1;
goto freeall;
}
SetTraceLevel("DBMAIL");
GetDBParams();
/* open database connection */
if (db_connect() != 0) {
qerrorf ("Failed. Could not connect to database (check log)\n");
result = -1;
goto freeall;
}
/* open authentication connection */
if (auth_connect() != 0) {
qerrorf("Failed. Could not connect to authentication (check log)\n");
result = -1;
goto freeall;
}
/* Loop over all user accounts if there's a wildcard. */
if (strchr(user, '?') || strchr(user, '*')) {
GList *all_users = auth_get_known_users();
GList *matching_users = match_glob_list(user, all_users);
GList *users = g_list_first(matching_users);
if (!users) {
qerrorf("Error: no users matching [%s] were found.\n", user);
g_list_destroy(all_users);
result = -1;
goto freeall;
}
while (users) {
result = do_export(users->data, mailbox,
basedir, outfile, search,
delete_after_dump, recursive);
if (!g_list_next(users))
break;
users = g_list_next(users);
}
g_list_destroy(all_users);
g_list_destroy(matching_users);
} else {
/* No globbing, just run with this one user. */
result = do_export(user, mailbox,
basedir, outfile, search,
delete_after_dump, recursive);
}
/* Here's where we free memory and quit.
* Be sure that all of these are NULL safe! */
freeall:
db_disconnect();
auth_disconnect();
config_free();
g_mime_shutdown();
if (result < 0)
qerrorf("Command failed.\n");
return result;
}
/*******************************************************************************
Description:
General function for handling TAPI Ioctls.
Arguments:
pChannel - handle to TAPI_CONNECTION structure
cmd - Ioctl Command
arg - Ioctl Parameter
Return:
IFX_TRUE or IFX_FALSE or requested value.
*******************************************************************************/
IFX_int32_t TAPI_Ioctl(TAPI_CONNECTION *pChannel, IFX_uint32_t cmd,
IFX_uint32_t arg)
{
IFX_int32_t ret = IFX_SUCCESS;
IFX_void_t *parg = (IFX_void_t *)arg;
IFX_void_t *p_iostack = IFX_NULL;
/* Get hold of memory to process this ioctl */
p_iostack = IFXOS_MALLOC (TAPI_IOCTL_STACKSIZE);
if (p_iostack == IFX_NULL)
return IFX_ERROR;
/* check channel */
switch (cmd)
{
/* Ringing Services */
case IFX_TAPI_RING_CFG_SET:
{
IFX_TAPI_RING_CFG_t *p_tmp = (IFX_TAPI_RING_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_RING_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_RING_CFG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Ring_Config(pChannel, p_tmp);
}
break;
}
case IFX_TAPI_RING_CFG_GET:
{
IFX_TAPI_RING_CFG_t *p_tmp = (IFX_TAPI_RING_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_RING_CFG_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_Ring_GetConfig(pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg, p_tmp,
sizeof(IFX_TAPI_RING_CFG_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_RING_CADENCE_SET:
ret = TAPI_Phone_Ring_Cadence(pChannel, arg);
break;
case IFX_TAPI_RING_CADENCE_HR_SET:
{
IFX_TAPI_RING_CADENCE_t *p_tmp = (IFX_TAPI_RING_CADENCE_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_RING_CADENCE_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_RING_CADENCE_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_FALSE;
}
else
{
ret = TAPI_Phone_Ring_Cadence_High_Res(pChannel, p_tmp);
}
break;
}
case IFX_TAPI_RING_START:
ret = TAPI_Phone_Ring_Start(pChannel);
break;
case IFX_TAPI_RING_STOP:
ret = TAPI_Phone_Ring_Stop(pChannel);
break;
case IFX_TAPI_RING_MAX_SET:
ret = TAPI_Phone_Set_MaxRings(pChannel, arg);
break;
case IFX_TAPI_RING:
ret = TAPI_Phone_Ring(pChannel);
break;
/* Operation Control Services */
case IFX_TAPI_LINE_FEED_SET:
ret = TAPI_Phone_Set_Linefeed(pChannel, arg);
break;
case IFX_TAPI_LINE_HOOK_STATUS_GET:
{
IFX_int32_t nHook;
ret = TAPI_Phone_Hookstate(pChannel, &nHook);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&nHook, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#ifdef TAPI_VOICE
/* Connection Services*/
case IFX_TAPI_MAP_DATA_ADD:
{
IFX_TAPI_MAP_DATA_t *p_tmp = (IFX_TAPI_MAP_DATA_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_DATA_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_DATA_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Data_Channel_Add (pChannel, p_tmp);
break;
}
case IFX_TAPI_MAP_DATA_REMOVE:
{
IFX_TAPI_MAP_DATA_t *p_tmp = (IFX_TAPI_MAP_DATA_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_DATA_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_DATA_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Data_Channel_Remove (pChannel, p_tmp);
break;
}
case IFX_TAPI_MAP_PHONE_ADD:
{
IFX_TAPI_MAP_PHONE_t *p_tmp = (IFX_TAPI_MAP_PHONE_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_PHONE_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_PHONE_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Phone_Channel_Add (pChannel, p_tmp);
break;
}
case IFX_TAPI_MAP_PHONE_REMOVE:
{
IFX_TAPI_MAP_PHONE_t *p_tmp = (IFX_TAPI_MAP_PHONE_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_PHONE_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_PHONE_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_Phone_Channel_Remove (pChannel, p_tmp);
break;
}
case IFX_TAPI_MAP_PCM_ADD:
{
IFX_TAPI_MAP_PCM_t *p_tmp = (IFX_TAPI_MAP_PCM_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_PCM_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_PCM_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_PCM_Channel_Add (pChannel, p_tmp);
break;
}
case IFX_TAPI_MAP_PCM_REMOVE:
{
IFX_TAPI_MAP_PCM_t *p_tmp = (IFX_TAPI_MAP_PCM_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_MAP_PCM_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_MAP_PCM_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_PCM_Channel_Remove (pChannel, p_tmp);
break;
}
case IFX_TAPI_PKT_RTP_CFG_SET:
{
IFX_TAPI_PKT_RTP_CFG_t *p_tmp = (IFX_TAPI_PKT_RTP_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PKT_RTP_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PKT_RTP_CFG_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_RtpConf (pChannel, p_tmp);
break;
}
case IFX_TAPI_PKT_RTP_PT_CFG_SET:
{
IFX_TAPI_PKT_RTP_PT_CFG_t *p_tmp =
(IFX_TAPI_PKT_RTP_PT_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PKT_RTP_PT_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PKT_RTP_PT_CFG_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_Rtp_SetPayloadType (pChannel, p_tmp);
break;
}
case IFX_TAPI_PKT_RTCP_STATISTICS_GET:
{
IFX_TAPI_PKT_RTCP_STATISTICS_t *p_tmp =
(IFX_TAPI_PKT_RTCP_STATISTICS_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PKT_RTCP_STATISTICS_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_LL_Phone_RTCP_GetStatistics(pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg, p_tmp,
sizeof(IFX_TAPI_PKT_RTCP_STATISTICS_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_PKT_RTCP_STATISTICS_RESET:
ret = TAPI_LL_Phone_RTCP_Reset (pChannel);
break;
case IFX_TAPI_JB_CFG_SET:
{
IFX_TAPI_JB_CFG_t *p_tmp = (IFX_TAPI_JB_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_JB_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_JB_CFG_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_JB_Set (pChannel, p_tmp);
break;
}
case IFX_TAPI_JB_STATISTICS_GET:
{
IFX_TAPI_JB_STATISTICS_t *p_tmp =
(IFX_TAPI_JB_STATISTICS_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_JB_STATISTICS_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_LL_Phone_JB_GetStatistics(pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_JB_STATISTICS_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_JB_STATISTICS_RESET:
ret = TAPI_LL_Phone_JB_Reset (pChannel);
break;
case IFX_TAPI_PKT_AAL_CFG_SET:
{
IFX_TAPI_PCK_AAL_CFG_t *p_tmp = (IFX_TAPI_PCK_AAL_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PCK_AAL_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PCK_AAL_CFG_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_Aal_Set (pChannel, p_tmp);
break;
}
case IFX_TAPI_PKT_AAL_PROFILE_SET:
{
IFX_TAPI_PCK_AAL_PROFILE_t *p_tmp =
(IFX_TAPI_PCK_AAL_PROFILE_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PCK_AAL_PROFILE_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PCK_AAL_PROFILE_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_Phone_AalProfile (pChannel, p_tmp);
break;
}
/* Recording Services */
case IFX_TAPI_ENC_TYPE_SET:
ret = TAPI_LL_Phone_Set_Rec_Codec (pChannel, arg);
break;
case IFX_TAPI_ENC_START:
ret = TAPI_LL_Phone_Start_Recording (pChannel);
break;
case IFX_TAPI_ENC_STOP:
ret = TAPI_LL_Phone_Stop_Recording(pChannel);
break;
case IFXPHONE_REC_HOLD:
ret = TAPI_Phone_SetRecHold (pChannel, (IFX_int32_t)arg);
break;
case PHONE_REC_DEPTH:
ret = TAPI_Phone_SetRecDepth (pChannel, (IFX_int32_t) arg);
break;
case IFX_TAPI_ENC_VOLUME_SET:
ret = TAPI_Phone_SetRecVolume (pChannel, (IFX_int32_t)arg);
break;
case IFX_TAPI_ENC_LEVEL_SET:
{
IFX_int32_t nLevel;
ret = TAPI_Phone_GetRecLevel (pChannel, (IFX_int32_t *)&nLevel);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nLevel, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
/* Play Services not used */
/*
case IFX_TAPI_DEC_TYPE_SET:
ret = TAPI_Phone_Set_Play_Codec(pChannel, arg);
break;
*/
case IFX_TAPI_DEC_START:
ret = TAPI_LL_Phone_Start_Playing(pChannel);
break;
case IFX_TAPI_DEC_STOP:
ret = TAPI_LL_Phone_Stop_Playing(pChannel);
break;
case IFXPHONE_PLAY_HOLD:
ret = TAPI_Phone_SetPlayHold (pChannel, (IFX_int32_t)arg);
break;
case PHONE_PLAY_DEPTH:
ret = TAPI_Phone_SetPlayDepth (pChannel, (IFX_int32_t) arg);
break;
case IFX_TAPI_DEC_VOLUME_SET:
ret = TAPI_Phone_SetPlayVolume (pChannel, (IFX_int32_t)arg);
break;
case IFX_TAPI_DEC_LEVEL_GET:
{
IFX_int32_t nLevel;
ret = TAPI_Phone_GetPlayLevel (pChannel, (IFX_int32_t *)&nLevel);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nLevel, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_VOICE */
#ifdef TAPI_FAX_T38
/* Fax Services */
case IFX_TAPI_T38_MOD_START:
{
IFX_TAPI_T38_MOD_DATA_t *p_tmp = (IFX_TAPI_T38_MOD_DATA_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_T38_MOD_DATA_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_T38_MOD_DATA_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_FaxT38_SetModulator (pChannel, p_tmp);
break;
}
case IFX_TAPI_T38_DEMOD_START:
{
IFX_TAPI_T38_DEMOD_DATA_t *p_tmp = (IFX_TAPI_T38_DEMOD_DATA_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_T38_DEMOD_DATA_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_T38_DEMOD_DATA_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
ret = TAPI_LL_FaxT38_SetDemodulator (pChannel, p_tmp);
break;
}
case IFX_TAPI_T38_STOP:
ret = TAPI_LL_FaxT38_DisableDataPump (pChannel);
break;
case IFX_TAPI_T38_STATUS_GET:
{
IFX_TAPI_T38_STATUS_t *p_tmp = (IFX_TAPI_T38_STATUS_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_T38_STATUS_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_LL_FaxT38_GetStatus (pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_T38_STATUS_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_FAX_T38 */
/* PCM Services */
case IFX_TAPI_PCM_CFG_SET:
{
IFX_TAPI_PCM_CFG_t *p_tmp = (IFX_TAPI_PCM_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PCM_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PCM_CFG_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_PCM_Set_Config(pChannel, p_tmp);
}
break;
}
case IFX_TAPI_PCM_CFG_GET:
{
IFX_TAPI_PCM_CFG_t *p_tmp = (IFX_TAPI_PCM_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PCM_CFG_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_PCM_Get_Config(pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg, p_tmp,
sizeof(IFX_TAPI_PCM_CFG_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_PCM_ACTIVATION_SET:
ret = TAPI_Phone_PCM_Set_Activation(pChannel, arg);
break;
case IFX_TAPI_PCM_ACTIVATION_GET:
ret = TAPI_Phone_PCM_Get_Activation(pChannel, (IFX_boolean_t*) arg);
break;
/* Tone Services */
case IFX_TAPI_TONE_LOCAL_PLAY:
ret = TAPI_Phone_Tone_Play(pChannel, arg, TAPI_TONE_DST_LOCAL);
break;
case IFX_TAPI_TONE_NET_PLAY:
ret = TAPI_Phone_Tone_Play(pChannel, arg, TAPI_TONE_DST_NET);
break;
case IFX_TAPI_TONE_ON_TIME_SET:
ret = TAPI_Phone_Tone_Set_On_Time(pChannel, arg);
break;
case IFX_TAPI_TONE_OFF_TIME_SET:
ret = TAPI_Phone_Tone_Set_Off_Time(pChannel, arg);
break;
case IFX_TAPI_TONE_ON_TIME_GET:
{
IFX_int32_t nDuration;
ret = TAPI_Phone_Tone_Get_On_Time(pChannel, &nDuration);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg,
&nDuration, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_TONE_OFF_TIME_GET:
{
IFX_int32_t nDuration;
ret = TAPI_Phone_Tone_Get_Off_Time(pChannel, &nDuration);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDuration, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_TONE_STATUS_GET:
{
IFX_uint32_t nToneState;
ret = TAPI_Phone_Tone_Get_State(pChannel, &nToneState);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nToneState, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_TONE_DIALTONE_PLAY:
ret = TAPI_Phone_Tone_Dial(pChannel);
break;
case IFX_TAPI_TONE_RINGBACK_PLAY:
ret = TAPI_Phone_Tone_Ringback(pChannel);
break;
case IFX_TAPI_TONE_BUSY_PLAY:
ret = TAPI_Phone_Tone_Busy(pChannel);
break;
case IFX_TAPI_TONE_STOP:
ret = TAPI_Phone_Tone_Stop (pChannel, arg);
break;
case IFX_TAPI_TONE_LEVEL_SET:
{
IFX_TAPI_PREDEF_TONE_LEVEL_t *p_tmp =
(IFX_TAPI_PREDEF_TONE_LEVEL_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_PREDEF_TONE_LEVEL_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_PREDEF_TONE_LEVEL_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Tone_Set_Level(pChannel, p_tmp);
}
break;
}
/* Dial Services */
case IFX_TAPI_PULSE_GET:
{
IFX_int32_t nPulseDigit;
ret = TAPI_Phone_Get_Pulse(pChannel, &nPulseDigit);
if ( (ret == IFX_SUCCESS) &&
(copy_to_user (parg, &nPulseDigit, sizeof(IFX_int32_t)) > 0) )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_PULSE_ASCII_GET:
{
IFX_int32_t nPulseDigit;
ret = TAPI_Phone_Get_Pulse_ASCII(pChannel, &nPulseDigit);
if ( (ret == IFX_SUCCESS) &&
(copy_to_user (parg, &nPulseDigit, sizeof(IFX_int32_t)) > 0) )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_PULSE_READY:
{
IFX_int32_t nPulseReady;
ret = TAPI_Phone_Pulse_Ready(pChannel, &nPulseReady);
if ( (ret == IFX_SUCCESS) &&
(copy_to_user ( parg, &nPulseReady, sizeof(IFX_int32_t)) > 0) )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_LINE_HOOK_VT_SET:
{
IFX_TAPI_LINE_HOOK_VT_t *p_tmp = (IFX_TAPI_LINE_HOOK_VT_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LINE_HOOK_VT_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_LINE_HOOK_VT_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Validation_Time(pChannel, p_tmp);
}
break;
}
#ifdef TAPI_DTMF
case IFX_TAPI_TONE_DTMF_GET:
{
IFX_int32_t nDtmfDigit;
ret = TAPI_Phone_Get_DTMF(pChannel, &nDtmfDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_TONE_DTMF_ASCII_GET:
{
IFX_int32_t nDtmfDigit;
ret = TAPI_Phone_Get_DTMF_ASCII(pChannel, &nDtmfDigit);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfDigit, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_PKT_EV_OOB_SET:
ret = TAPI_LL_Phone_Send_DTMF_OOB(pChannel, arg);
break;
case IFX_TAPI_TONE_DTMF_READY_GET:
{
IFX_int32_t nDtmfReady;
ret = TAPI_Phone_DTMF_Ready(pChannel, &nDtmfReady);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg,
&nDtmfReady, sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_DTMF */
/* Miscellaneous Services */
case IFX_TAPI_VERSION_GET:
{
IFX_char_t *p_tmp = (IFX_char_t *)p_iostack;
/* make sure that the stacksize is sufficient */
IFXOS_ASSERT(80 < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_Get_Version(p_tmp);
/* check for ret (string length) > 0 */
if ((ret > 0) && (copy_to_user (parg, p_tmp, 80) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_EXCEPTION_GET:
ret = TAPI_Phone_Exception(pChannel);
break;
case IFX_TAPI_EXCEPTION_MASK:
ret = TAPI_Phone_Mask_Exception(pChannel, arg);
break;
case IFX_TAPI_CH_STATUS_GET:
{
IFX_TAPI_CH_STATUS_t *p_tmp = IFX_NULL;
IFX_int32_t ch;
if (arg == 0)
{
ret = IFX_ERROR;
break;
}
p_tmp = IFXOS_MALLOC(TAPI_MAX_CHANNELS * sizeof(IFX_TAPI_CH_STATUS_t));
if (p_tmp == IFX_NULL)
{
ret = IFX_ERROR;
break;
}
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_CH_STATUS_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: ioctl parameter error\n\r"));
ret = IFX_ERROR;
}
if ((ret == IFX_SUCCESS) && ((ch = p_tmp[0].channels) > TAPI_MAX_CHANNELS))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,
("TAPI: IFX_TAPI_CH_STATUS_GET: Ch%d: invalid parameters\n\r",
pChannel->nChannel - 1));
ret = IFX_ERROR;
}
if (ret == IFX_SUCCESS)
{
if (ch == 0)
ch = 1;
ret = TAPI_Phone_GetStatus(pChannel, p_tmp);
if (copy_to_user (parg, p_tmp, sizeof(IFX_TAPI_CH_STATUS_t) * ch)
> 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
}
IFXOS_FREE (p_tmp);
break;
}
case IFX_TAPI_CH_INIT:
{
IFX_TAPI_CH_INIT_t *p_tmp = (IFX_TAPI_CH_INIT_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CH_INIT_t) < TAPI_IOCTL_STACKSIZE);
if ((arg != 0) && (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_CH_INIT_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
if (arg == 0)
{
ret = TAPI_Phone_Init(pChannel, NULL);
}
else
{
ret = TAPI_Phone_Init(pChannel, p_tmp);
}
}
break;
}
#ifdef TAPI_VOICE
case IFX_TAPI_ENC_FRAME_LEN_SET:
ret = TAPI_LL_Phone_Set_Frame_Length(pChannel, arg);
break;
case IFX_TAPI_ENC_FRAME_LEN_GET:
{
IFX_int32_t length = 0;
ret = TAPI_LL_Phone_Get_Frame_Length(pChannel, &length);
if ((ret == IFX_SUCCESS) && (copy_to_user (parg, &length,
sizeof(IFX_int32_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_VOICE */
case IFX_TAPI_ENC_VAD_CFG_SET:
ret = TAPI_LL_Phone_VAD(pChannel, arg);
break;
case IFX_TAPI_CAP_NR:
{
IFX_int32_t cap;
cap = TAPI_LL_Phone_Get_Capabilities(pChannel);
copy_to_user( parg, &cap, sizeof(IFX_int32_t));
break;
}
case IFX_TAPI_CAP_LIST:
{
IFX_TAPI_CAP_t *p_tmp = IFX_NULL;
IFX_uint32_t tmpcapsize;
tmpcapsize = TAPI_LL_Phone_Get_Capabilities(pChannel);
p_tmp = IFXOS_MALLOC(tmpcapsize * sizeof(IFX_TAPI_CAP_t));
if (p_tmp == IFX_NULL)
{
ret = IFX_ERROR;
break;
}
ret = TAPI_LL_Phone_Get_Capability_List(pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user( parg, p_tmp,
sizeof(IFX_TAPI_CAP_t) * tmpcapsize) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
IFXOS_FREE(p_tmp);
break;
}
case IFX_TAPI_CAP_CHECK:
{
IFX_TAPI_CAP_t *p_tmp = (IFX_TAPI_CAP_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CAP_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_CAP_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Phone_Check_Capability(pChannel, p_tmp);
if (ret == IFX_SUCCESS || ret == 1)
{
copy_to_user (parg, p_tmp, sizeof(IFX_TAPI_CAP_t));
}
}
break;
}
/* Metering Services */
case IFX_TAPI_METER_CFG_SET:
{
IFX_TAPI_METER_CFG_t *p_tmp = (IFX_TAPI_METER_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_METER_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_METER_CFG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Meter_Config(pChannel, p_tmp);
}
break;
}
case IFX_TAPI_METER_START:
ret = TAPI_Phone_Meter_Start(pChannel);
break;
case IFX_TAPI_METER_STOP:
ret = TAPI_Phone_Meter_Stop(pChannel);
break;
/* Lec Configuration */
case IFX_TAPI_LEC_PHONE_CFG_SET:
{
IFX_TAPI_LEC_CFG_t *p_tmp = (IFX_TAPI_LEC_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LEC_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_LEC_CFG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_LecConf (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_LEC_PHONE_CFG_GET:
{
IFX_TAPI_LEC_CFG_t *p_tmp = (IFX_TAPI_LEC_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LEC_CFG_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_GetLecConf (pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_LEC_CFG_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_LEC_PCM_CFG_SET:
{
IFX_TAPI_LEC_CFG_t *p_tmp = (IFX_TAPI_LEC_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LEC_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_LEC_CFG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_LecConf_Pcm (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_LEC_PCM_CFG_GET:
{
IFX_TAPI_LEC_CFG_t *p_tmp = (IFX_TAPI_LEC_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LEC_CFG_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_GetLecConf_Pcm (pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_LEC_CFG_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#ifdef TAPI_CID
/* Caller ID Transmission service */
case IFX_TAPI_CID_CFG_SET:
{
IFX_TAPI_CID_CFG_t *p_tmp = (IFX_TAPI_CID_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CID_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_CID_CFG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_CID_SetConfig (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_CID_TX_INFO_START:
case IFX_TAPI_CID_TX_SEQ_START:
{
IFX_TAPI_CID_MSG_t *p_tmp = (IFX_TAPI_CID_MSG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CID_MSG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_CID_MSG_t)) > 0 )
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
if (cmd == IFX_TAPI_CID_TX_INFO_START)
ret = TAPI_Phone_CID_Info_Tx (pChannel, p_tmp);
else
ret = TAPI_Phone_CID_Seq_Tx (pChannel, p_tmp);
}
break;
}
/* Caller ID Reception service */
case IFX_TAPI_CID_RX_START:
ret = TAPI_Phone_CidRx_Start (pChannel);
break;
case IFX_TAPI_CID_RX_STOP:
ret = TAPI_Phone_CidRx_Stop (pChannel);
break;
case IFX_TAPI_CID_RX_STATUS_GET:
{
IFX_TAPI_CID_RX_STATUS_t *p_tmp = (IFX_TAPI_CID_RX_STATUS_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CID_RX_STATUS_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_LL_Phone_CidRx_Status (pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_CID_RX_STATUS_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
case IFX_TAPI_CID_RX_DATA_GET:
{
IFX_TAPI_CID_RX_DATA_t *p_tmp = (IFX_TAPI_CID_RX_DATA_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_CID_RX_DATA_t) < TAPI_IOCTL_STACKSIZE);
ret = TAPI_Phone_Get_CidRxData (pChannel, p_tmp);
if ((ret == IFX_SUCCESS) && (copy_to_user ( parg, p_tmp,
sizeof(IFX_TAPI_CID_RX_DATA_t)) > 0))
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: cannot copy to user space\n\r"));
ret = IFX_ERROR;
}
break;
}
#endif /* TAPI_CID */
/* Report Level */
case IFX_TAPI_DEBUG_REPORT_SET:
SetTraceLevel(TAPI_DRV, arg);
break;
case IFX_TAPI_VERSION_CHECK:
{
IFX_TAPI_VERSION_t *p_vers = (IFX_TAPI_VERSION_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_VERSION_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_vers, parg, sizeof(IFX_TAPI_VERSION_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_Check_Version (p_vers);
}
break;
}
case IFX_TAPI_PHONE_VOLUME_SET:
{
IFX_TAPI_LINE_VOLUME_t *p_tmp = (IFX_TAPI_LINE_VOLUME_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LINE_VOLUME_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_LINE_VOLUME_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Phone_Volume (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_PCM_VOLUME_SET:
{
IFX_TAPI_LINE_VOLUME_t *p_tmp = (IFX_TAPI_LINE_VOLUME_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_LINE_VOLUME_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_LINE_VOLUME_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Phone_Pcm_Volume (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_LINE_LEVEL_SET:
{
ret = TAPI_LL_Phone_High_Level (pChannel, arg);
break;
}
case IFX_TAPI_SIG_DETECT_ENABLE:
{
IFX_TAPI_SIG_DETECTION_t *p_tmp = (IFX_TAPI_SIG_DETECTION_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_SIG_DETECTION_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_SIG_DETECTION_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Enable_Signal (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_SIG_DETECT_DISABLE:
{
IFX_TAPI_SIG_DETECTION_t *p_tmp = (IFX_TAPI_SIG_DETECTION_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_SIG_DETECTION_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_SIG_DETECTION_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Disable_Signal (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_TONE_TABLE_CFG_SET:
{
IFX_TAPI_TONE_t *p_tmp = (IFX_TAPI_TONE_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_TONE_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_TONE_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
if (pChannel->pTapiDevice->pToneTbl)
{
ret = TAPI_Phone_Tone_TableConf (pChannel->pTapiDevice->pToneTbl,
p_tmp);
}
else /* reluctant success indication */
ret = IFX_SUCCESS;
}
break;
}
case IFX_TAPI_TONE_CPTD_START:
{
IFX_TAPI_TONE_CPTD_t *p_tmp = (IFX_TAPI_TONE_CPTD_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_TONE_CPTD_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_TONE_CPTD_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_Phone_DetectToneStart(pChannel, p_tmp);
}
break;
}
case IFX_TAPI_TONE_CPTD_STOP:
{
ret = TAPI_Phone_DetectToneStop(pChannel);
break;
}
case IFX_TAPI_ENC_AGC_CFG:
{
IFX_TAPI_ENC_AGC_CFG_t *p_tmp = (IFX_TAPI_ENC_AGC_CFG_t *)p_iostack;
IFXOS_ASSERT(sizeof(IFX_TAPI_ENC_AGC_CFG_t) < TAPI_IOCTL_STACKSIZE);
if (copy_from_user (p_tmp, parg, sizeof(IFX_TAPI_ENC_AGC_CFG_t)) > 0 )
{
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_Phone_AGC_Cfg (pChannel, p_tmp);
}
break;
}
case IFX_TAPI_ENC_AGC_ENABLE:
{
TAPI_LL_Phone_AGC_Enable (pChannel, arg);
break;
}
/* case IFX_TAPI_TEST_HOOKGEN:
ret = TAPI_LL_Test_HookGen (pChannel, (IFX_boolean_t) arg);*/
case IFX_TAPI_TEST_LOOP:
{
IFX_TAPI_TEST_LOOP_t testLoop;
if (copy_from_user (&testLoop, parg, sizeof(IFX_TAPI_TEST_LOOP_t)) > 0)
{
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: IFX_TAPI_TEST_LOOP: "
"cannot copy from user space\n\r"));
ret = IFX_ERROR;
}
else
{
ret = TAPI_LL_TestLoop (pChannel, &testLoop);
}
break;
}
default:
TRACE(TAPI_DRV,DBG_LEVEL_HIGH,("TAPI: Ioctl 0x%08lX not handled by TAPI\n\r", cmd));
ret = IFX_ERROR;
break;
}
IFXOS_FREE(p_iostack);
return ret;
}
