[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/app/ccapp/slic_inf.c b/ap/app/ccapp/slic_inf.c
new file mode 100644
index 0000000..8733725
--- /dev/null
+++ b/ap/app/ccapp/slic_inf.c
@@ -0,0 +1,858 @@
+/***********************************************************************
+ *Project Linux H100
+ *Modual USRLINE
+ *FileName slc_inf.c
+ *Description user line driver interface
+ *-----------------------------------------------------------------------
+ *modify History:
+ *
+ * Data author version modify description
+ * 2004/12/10 jiang.yuelong 1.0 create
+ ************************************************************************/
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+/*lint -save -esym(18, LONG) */
+/*lint -restore */
+
+#include "slic_inf.h"
+#include "112.h"
+#include "libzte_log.h"
+
+static LONG SLIC_Fd;
+static S8 *SLIC_DeviceName = (S8 *)"/dev/slic";
+
+DWORD SLIC_Initial(VOID)
+{
+
+ SLIC_Fd = open(SLIC_DeviceName, O_RDONLY);
+ if(SLIC_Fd < 0)
+ {
+ printf("slctool: open device error.\n");
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+VOID SLIC_Release(VOID)
+{
+ close(SLIC_Fd);
+}
+
+VOID SLIC_DebugLevel(WORD wLevel)
+{
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+
+ //Tmp.unPara.wLevel = wLevel;
+
+ if (ioctl(SLIC_Fd, SLIC_DEBUG_LEVEL, (DWORD)&Tmp) < 0) {//cov m
+ printf("SLIC_DebugLevel ioctl fail\n");
+ }
+}
+
+DWORD SLIC_ResetPort(WORD wPort, BYTE bType)
+{
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (ioctl(SLIC_Fd, SLIC_PORT_RESET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Port_Lock(WORD wPort, BYTE bType)
+{
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (ioctl(SLIC_Fd, SLIC_PORT_LOCK, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Port_UnLock(WORD wPort, BYTE bType)
+{
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (ioctl(SLIC_Fd, SLIC_PORT_UNLOCK, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_FXS_PolarityReverse(WORD wPort)
+{
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+
+ if (ioctl(SLIC_Fd, SLIC_POLARITY_REVERSE, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+extern int get_polarity_reversal_flag(void);
+
+DWORD SLIC_PolarityReverse(WORD wPort, int is_active)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_POLARITY_REVERSE, (WORD) is_active) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ #else
+
+ SLIC_IOCTL_DATA Tmp;
+
+ if(get_polarity_reversal_flag()==0)
+ return SLIC_SUCCESS;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ Tmp.dwSize = (WORD)is_active;
+
+ if (ioctl(SLIC_Fd, SLIC_POLARITY_REVERSE, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+
+ return SLIC_SUCCESS;
+}
+
+
+DWORD SLIC_Play_Signal(WORD wPort, BYTE bType, SIGNAL_DATA *pSig)
+{
+#ifdef USE_SLIC_TW
+ if (!pSig)
+ {
+ return SLIC_FAIL;
+ }
+
+ if (ioctl(SLIC_Fd, SLIC_SIGNAL_START, (DWORD) pSig) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ #else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+
+ if (!pSig)
+ {
+ return SLIC_FAIL;
+ }
+
+ Tmp.pData = pSig;
+ Tmp.dwSize = sizeof(SIGNAL_DATA);
+
+ if (ioctl(SLIC_Fd, SLIC_SIGNAL_START, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+
+#endif
+ return SLIC_SUCCESS;
+
+}
+
+DWORD SLIC_Stop_Signal(WORD wPort, BYTE bType)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_SIGNAL_STOP, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (ioctl(SLIC_Fd, SLIC_SIGNAL_STOP, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+
+#endif
+ return SLIC_SUCCESS;
+}
+DWORD SLIC_Start_PCM()
+{
+ printf("ccapp:SLIC_Start_PCM! \n");
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_PCM_OPEN, NULL) < 0)
+ {
+ printf("ccapp:SLIC_Start_PCM fail!\n");
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ if (ioctl(SLIC_Fd, SLIC_PCM_OPEN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Stop_PCM()
+{
+ printf("[ccapp_debug]:SLIC_Stop_PCM!\n");
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_PCM_CLOSE, NULL) < 0)
+ {
+ printf("[ccapp_debug]:SLIC_Stop_PCM fail!\n");
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ if (ioctl(SLIC_Fd, SLIC_PCM_CLOSE, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_PCM_Set_NB()
+{
+ printf("ccapp:SLIC_PCM_Set_NB!\n");
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_PCM_SET_NB, NULL) < 0)
+ {
+ printf("ccapp:SLIC_PCM_Set_NB fail! \n");
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ if (ioctl(SLIC_Fd, SLIC_PCM_SET_NB, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ #endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_PCM_Set_WB()
+{
+#ifdef USE_SLIC_TW
+ printf("ccapp:SLIC_PCM_Set_WB!\n");
+ if (ioctl(SLIC_Fd, SLIC_PCM_SET_WB, NULL) < 0)
+ {
+ printf("ccapp:SLIC_PCM_Set_WB fail! \n");
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ if (ioctl(SLIC_Fd, SLIC_PCM_SET_WB, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+
+DWORD SLIC_SelectTimeSlot(WORD wPort, BYTE bType, BYTE bTX, BYTE bRX)
+{
+#ifdef USE_SLIC_TW
+#if 0
+ if (bType > 1)
+ {
+ return SLIC_FAIL;
+ }
+
+ if (ioctl(SLIC_Fd, SLIC_TIMESLOT_SET, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+
+ VpOptionTimeslotType timeslot={0};
+ timeslot.rx=bRX;
+ timeslot.tx=bTX;
+
+
+ if (ioctl(SLIC_Fd, SLIC_TIMESLOT_SET, (DWORD) ×lot) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+ //Tmp.unPara.stTimeSlot.bTx = bTX;
+ //Tmp.unPara.stTimeSlot.bRx = bRX;
+
+
+ if (bType > 1)
+ {
+ return SLIC_FAIL;
+ }
+
+ if (ioctl(SLIC_Fd, SLIC_TIMESLOT_SET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_ReleaseTimeSlot(WORD wPort, BYTE bType)
+{
+#ifdef USE_SLIC_TW
+ if (bType > 1)
+ {
+ return SLIC_FAIL;
+ }
+
+ if (ioctl(SLIC_Fd, SLIC_TIMESLOT_RELEASE, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (bType > 1)
+ {
+ return SLIC_FAIL;
+ }
+
+ if (ioctl(SLIC_Fd, SLIC_TIMESLOT_RELEASE, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_MsgRev(BYTE *bEvent, DWORD *pPayLoad)
+{
+#ifdef USE_SLIC_TW
+ LONG rev = 0;
+ MSG_DATA msg;
+ memset((VOID *)&msg,0,sizeof(msg));
+ rev = ioctl(SLIC_Fd, SLIC_MSG_REV, (DWORD) &msg);
+ if (rev < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ LONG rev = 0;
+ SLIC_IOCTL_DATA Tmp;
+ MSG_DATA msg;
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ memset((VOID *)&msg,0,sizeof(msg));
+
+ Tmp.pData = &msg;
+ Tmp.dwSize = sizeof(MSG_DATA);
+
+ rev = ioctl(SLIC_Fd, SLIC_MSG_REV, (DWORD) &Tmp);
+ if (rev < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ //*wPort = msg.wPort;
+ *bEvent = msg.bMsgId;
+ *pPayLoad = msg.dPayLoad;
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_MsgClr(VOID)
+{
+ if (ioctl(SLIC_Fd, SLIC_MSG_CLR, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_HookLowTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_HOOK_LOWLEN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_HOOK_LOWLEN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ #endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_HookHighTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_HOOK_HIGLEN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_HOOK_HIGLEN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_PreHookHighTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_PREHOOK_HIGLEN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_PREHOOK_HIGLEN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_FlashLowMinTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_LMIN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_LMIN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_FlashLowMaxTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_LMAX, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_LMAX, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_FlashHighFixTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_HFIX, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_FLASH_HFIX, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_DialLowMinTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_LMIN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_LMIN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_DialLowMaxTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_LMAX, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_LMAX, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_DialHighMinTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_HMIN, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_HMIN, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_DialHighFixTime(WORD wPort, WORD wTime)
+{
+#ifdef USE_SLIC_TW
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_HMAX, NULL) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = PORT_TYPE_FXS;
+ //Tmp.unPara.wTime= wTime;
+
+ if (ioctl(SLIC_Fd, SLIC_CFG_DIAL_HMAX, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Read_Codec(BYTE *pParm)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_Read_Codec not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+
+ Tmp.pData = pParm;
+ Tmp.dwSize = 2;
+
+ if (ioctl(SLIC_Fd, SLIC_CODEC_GET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+DWORD SLIC_Read_Codec_ALL(VOID)
+{
+#ifdef USE_SLIC_TW
+ int ret = 0;
+ ret = ioctl(SLIC_Fd, SLIC_CODEC_GETALL, NULL) ;
+ if (ret< 0)
+ {
+ printf("SLIC_Read_Codec_ALL error ret=%d \n", ret);
+
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+DWORD SLIC_Cfg_Codec(BYTE *pParm)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_Cfg_Codec not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ Tmp.pData = pParm;
+ Tmp.dwSize = 2;
+
+ if (ioctl(SLIC_Fd, SLIC_CODEC_SET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_112TestStart(WriteCmd_t *pCmd)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_LINE_TEST_START not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+
+ //Tmp.wPort = pCmd->port;
+ //Tmp.bPortType = pCmd->port_type;
+ //Tmp.pData = pCmd;
+ //Tmp.dwSize = sizeof(WriteCmd_t);
+
+ if (ioctl(SLIC_Fd, SLIC_LINE_TEST_START, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_112TestAbort( WORD wPort, BYTE bType )
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_LINE_TEST_ABORT not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (ioctl(SLIC_Fd, SLIC_LINE_TEST_ABORT, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_112TestRead( WORD wPort, BYTE bType, TestResult_t *pResBuf)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_LINE_TEST_READ not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (NULL == pResBuf)
+ {
+ return SLIC_FAIL;
+ }
+
+ Tmp.pData = pResBuf;
+ Tmp.dwSize = sizeof(TestResult_t);
+
+ if (ioctl(SLIC_Fd, SLIC_LINE_TEST_READ, (DWORD)&Tmp) < 0)
+ {
+ printf("Read error!!\n");
+ return SLIC_FAIL;
+ }
+ #endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Dev_Init()
+{
+ if (ioctl(SLIC_Fd, SLIC_DEV_INIT, 0) < 0)
+ {
+ return SLIC_FAIL;
+ }
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Read_Ram(BYTE *pParm)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_RAM_GET not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+
+ Tmp.pData = pParm;
+ Tmp.dwSize = 2;
+
+ if (ioctl(SLIC_Fd, SLIC_RAM_GET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+
+DWORD SLIC_Cfg_Ram(BYTE *pParm)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_RAM_SET not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ Tmp.pData = pParm;
+ Tmp.dwSize = 2;
+
+ if (ioctl(SLIC_Fd, SLIC_RAM_SET, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}
+
+DWORD SLIC_Cfg_Electric(WORD wPort, BYTE bType, ELECTRIC_CFG_CUSTOMIZED *pElec)
+{
+#ifdef USE_SLIC_TW
+ printf(" SLIC_ELECTRIC_CFG not support!\n");
+ return SLIC_FAIL;
+#else
+ SLIC_IOCTL_DATA Tmp;
+
+ memset((VOID *)&Tmp,0,sizeof(Tmp));
+ //Tmp.wPort = wPort;
+ //Tmp.bPortType = bType;
+
+ if (NULL == pElec)
+ {
+ return SLIC_FAIL;
+ }
+
+ Tmp.pData = pElec;
+ Tmp.dwSize = sizeof(ELECTRIC_CFG_CUSTOMIZED);
+
+ if (ioctl(SLIC_Fd, SLIC_ELECTRIC_CFG, (DWORD) &Tmp) < 0)
+ {
+ return SLIC_FAIL;
+ }
+#endif
+ return SLIC_SUCCESS;
+}