/**
* Function: main()
*
* Description: This function initializes the API and Devices/Lines.
* It also starts the "alarmHandle" function to be called at a periodic rate.
*/
int main(void)
{
VpStatusType status;
struct itimerval timeStruct, timeOldVal;
uint8 lineNum = 0;
/* ZTAP board initialization (platform specific) */
BoardInit(); /* See "../common/board.c" */
VpSysInit();
/*
* The following structure is specific to Linux. It sets up a timed call
* to a user specified function. For the purpose of this demo, the timing
* is 20mS and the function that will be called is "alarmHandle". The timer
* and function call does not start until "setitimer()" and "signal()" are
* called (below).
*/
timeStruct.it_interval.tv_sec = 0L;
timeStruct.it_interval.tv_usec = 19990L;
timeStruct.it_value.tv_sec = 0L;
timeStruct.it_value.tv_usec = 19990L;
timeOldVal.it_interval.tv_sec = 0L;
timeOldVal.it_interval.tv_usec = 0L;
timeOldVal.it_value.tv_sec = 0L;
timeOldVal.it_value.tv_usec = 0L;
/* Make the objects (1 device, 2 lines) */
#if (SUPPLY_CONFIGURATION == ABS_SUPPLY)
status = VpMakeDeviceObject(VP_DEV_886_SERIES, deviceId, &devCtx, &devObj);
#else
status = VpMakeDeviceObject(VP_DEV_887_SERIES, deviceId, &devCtx, &devObj);
#endif
if (status != VP_STATUS_SUCCESS) {
QS_DEBUG("Error making the device object: %s\n", MapStatus(status));
exit(-1);
}
for (; lineNum < NB_LINE; lineNum++) {
status = VpMakeLineObject(VP_TERM_FXS_LOW_PWR, lineNum, &lineCtx[lineNum], &lineObj[lineNum], &devCtx);
if (status != VP_STATUS_SUCCESS) {
QS_DEBUG("Error calling VpMakeLineObject on lineNum %i: %s\n", lineNum, MapStatus(status));
exit(-1);
}
QS_DEBUG("--- Created lineNum %i---\n", lineNum);
}
/* Start VpInitDevice and wait for the event VP_DEV_EVID_DEV_INIT_CMP */
#if (SUPPLY_CONFIGURATION == FLY_BACK_SUPPLY)
status = VpInitDevice(&devCtx, FB_DEV_PROFILE, FB_AC_600_FXS, FB_DC_25MA_CC, FB_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL);
#elif (SUPPLY_CONFIGURATION == INVERTING_BOOST_SUPPLY)
status = VpInitDevice(&devCtx, IB_DEV_PROFILE, IB_AC_600_FXS, IB_DC_25MA_CC, IB_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL);
#elif (SUPPLY_CONFIGURATION == ABS_SUPPLY)
status = VpInitDevice(&devCtx, ABS_DEV_PROFILE, ABS_AC_600_FXS, ABS_DC_23MA_CC, ABS_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL);
#else
#error "SUPPLY_CONFIGURATION is incorrectly set"
#endif
if (status != VP_STATUS_SUCCESS) {
QS_DEBUG("Device not properly initialized: %s\n", MapStatus(status));
exit(-1);
} else {
QS_DEBUG("\nDevice Initialization started\n");
}
/*
* The following two function calls were described above as Linux specific.
* They are used to call a user defined function at set increments. The
* user may have several other methods to perform the same.
*/
signal(SIGVTALRM, alarmHandle);
setitimer(ITIMER_VIRTUAL, &timeStruct, &timeOldVal);
/*
* Once the "tick" is setup, the main program can enter a "while(1)" loop
* and the user specified function will take over the application (with the
* help of the Linux OS)
*/
while(1);
return 0;
}
/*
** API : zarlinkInitDevice()
** Desp : Init Zarlink device
** input : Realtek device obj pointer
** return : SUCCESS/FAILED
*/
BOOL zarlinkInitDevice( RTKDevObj *pDev )
{
int ch;
BOOL rtn;
VpProfilePtrType dev_profile;
VpStatusType status;
VpTermType term_type;
PRINT_MSG("Initializing device 0x%x\n", pDev->dev_id);
/* Create the API-2 device */
status = VpMakeDeviceObject( pDev->VpDevType,
(VpDeviceIdType) pDev->dev_id,
pDev->pDevCtx,
pDev->pDevObj
);
if ( status != VP_STATUS_SUCCESS ) {
PRINT_R("Error: VpMakeDeviceObject (status %d) \n", status);
return FAILED;
}
for (ch=0; ch < pDev->max_line; ch++) {
if (pDev->pLine[ch]->line_type == LINE_FXS )
term_type = VP_TERM_FXS_GENERIC;
else term_type = VP_TERM_FXO_GENERIC;
/* Create line objects */
status = VpMakeLineObject( term_type,
pDev->pLine[ch]->channelId,
pDev->pLine[ch]->pLineCtx,
pDev->pLine[ch]->pLineObj,
pDev->pDevCtx
);
if ( status != VP_STATUS_SUCCESS ) {
PRINT_R("Error: VpMakeLineObject ch %d term=%d(status %d) \n",
ch, term_type, status);
return FAILED;
}
}
dev_profile = pDev->pDev_profile;
PRINT_MSG("tick rate %d ms\n", dev_profile[DEVICE_PROFILE_TICK_RATE_IDX]);
/* Avoid taking to long to init device */
#ifdef CONFIG_RTL865X_WTDOG
plat_disable_watchdog();
PRINT_MSG("Disable watchdog\n" );
#elif defined( CONFIG_RTL_WTDOG )
bsp_disable_watchdog();
PRINT_MSG("Disable watchdog\n" );
#endif
/* Initialize the device */
status = VpInitDevice( pDev->pDevCtx,
pDev->pDev_profile,
pDev->pAC_profile,
pDev->pDC_profile,
pDev->pRing_profile,
pDev->pACFxoLC_profile,
pDev->pFxoDial_profile
);
if ( status != VP_STATUS_SUCCESS ) {
PRINT_R("Error: VpInitDevice (status %d)\n", status );
goto DONE;
}
/* Check if VP_DEV_EVID_DEV_INIT_CMP occurred */
if( TRUE != zarlinkWaitForEvent( pDev->pDevCtx,
VP_EVCAT_RESPONSE, VP_DEV_EVID_DEV_INIT_CMP ) ) {
PRINT_R("Error: Device %d initialization was not complete\n",pDev->dev_id);
status = VP_STATUS_FAILURE;
goto DONE;
}
PRINT_MSG("DEV%x initialized OK\n",pDev->dev_id);
pDev->dev_st = DEV_S_READY;
/* Initialize API-2 line settings */
for (ch=0; ch < pDev->max_line; ch++) {
if (pDev->pLine[ch]->line_type == LINE_FXS) {
rtn = RtkInitFxsLine(pDev->pLine[ch]);
} else if (pDev->pLine[ch]->line_type == LINE_FXO) {
rtn = RtkInitFxoLine(pDev->pLine[ch]);
} else {
PRINT_R("Error: unknow line_type %d\n",pDev->pLine[ch]->line_type);
goto DONE;
}
}
DONE:
#ifdef CONFIG_RTL865X_WTDOG
plat_enable_watchdog();
PRINT_MSG("Enable watchdog\n");
#elif defined( CONFIG_RTL_WTDOG )
bsp_enable_watchdog();
PRINT_MSG("Enable watchdog\n");
#endif
if ( status != VP_STATUS_SUCCESS ) return FAILED;
return SUCCESS;
}
static int vpapi_init_device(unsigned long arg)
{
VpApiModInitDeviceType data;
VpDeviceIdType deviceId;
VpProfileDataType devProfile[MAX_PROFILE_SIZE];
VpProfileDataType acProfile[MAX_PROFILE_SIZE];
VpProfileDataType dcProfile[MAX_PROFILE_SIZE];
VpProfileDataType ringProfile[MAX_PROFILE_SIZE];
VpProfileDataType fxoAcProfile[MAX_PROFILE_SIZE];
VpProfileDataType fxoCfgProfile[MAX_PROFILE_SIZE];
VpProfilePtrType pDevProfile = NULL, pAcProfile = NULL;
VpProfilePtrType pDcProfile = NULL, pRingProfile = NULL;
VpProfilePtrType pFxoAcProfile = NULL, pFxoCfgProfile = NULL;
u16 devProfileSize, acProfileSize, dcProfileSize;
u16 ringProfileSize, fxoAcProfileSize, fxoCfgProfileSize;
/* Get user data */
if(copy_from_user(&data, (void*)arg, sizeof(VpApiModInitDeviceType))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
deviceId = data.deviceId;
devProfileSize = data.devProfileSize;
acProfileSize = data.acProfileSize;
dcProfileSize = data.dcProfileSize;
ringProfileSize = data.ringProfileSize;
fxoAcProfileSize = data.fxoAcProfileSize;
fxoCfgProfileSize = data.fxoCfgProfileSize;
if(devProfileSize) {
/* Get device profile */
if(copy_from_user(devProfile, (void*)data.pDevProfile, (sizeof(VpProfileDataType)*devProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pDevProfile = devProfile;
}
if(acProfileSize) {
/* Get AC profile */
if(copy_from_user(acProfile, (void*)data.pAcProfile, (sizeof(VpProfileDataType)*acProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pAcProfile = acProfile;
}
if(dcProfileSize) {
/* Get DC profile */
if(copy_from_user(dcProfile, (void*)data.pDcProfile, (sizeof(VpProfileDataType)*dcProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pDcProfile = dcProfile;
}
if(ringProfileSize) {
/* Get ring profile */
if(copy_from_user(ringProfile, (void*)data.pRingProfile, (sizeof(VpProfileDataType)*ringProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pRingProfile = ringProfile;
}
if(fxoAcProfileSize) {
/* Get FXO AC profile */
if(copy_from_user(fxoAcProfile, (void*)data.pFxoAcProfile, (sizeof(VpProfileDataType)*fxoAcProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pFxoAcProfile = fxoAcProfile;
}
if(fxoCfgProfileSize) {
/* Get FXO configuration profile */
if(copy_from_user(fxoCfgProfile, (void*)data.pFxoCfgProfile,
(sizeof(VpProfileDataType)*fxoCfgProfileSize))) {
printk("%s: copy_from_user failed\n", __func__);
return -EFAULT;
}
pFxoCfgProfile = fxoCfgProfile;
}
data.status = VpInitDevice(&pDevCtx[deviceId], pDevProfile, pAcProfile, pDcProfile, pRingProfile,
pFxoAcProfile, pFxoCfgProfile);
if(data.status == VP_STATUS_SUCCESS) {
total_devs++;
REGISTER_DEVICE(deviceId);
if(!atomic_read(&vpapi_init)) {
#if defined(SLIC_TIMER_EVENT_SUPPORT)
memset(&vpapi_timer, 0, sizeof(struct timer_list));
init_timer(&vpapi_timer);
vpapi_timer.function = vpapi_tick_handler;
vpapi_timer.data = -1;
vpapi_timer.expires = jiffies + VPAPI_TICK_TIMER_PERIOD;
add_timer(&vpapi_timer);
#endif
atomic_set(&vpapi_init, 1);
}
}
/* Copy status back to user */
if(copy_to_user((void*)arg, &data, sizeof(VpApiModInitDeviceType))) {
printk("%s: copy_to_user failed\n", __func__);
return -EFAULT;
}
return 0;
}
