int main(int argc, char *argv[])
{
KeypadBK_REQ req;
KeypadBK_CNF cnf;
BOOL r;
if (argc < 3)
return 0;
req.onoff = atoi(argv[1]);
req.DIV = atoi(argv[2]);
req.DUTY = atoi(argv[3]);
r = Meta_KeypadBK_Init();
if (!r) {
META_LOG("kpd: Meta_KeypadBK_Init() failed\n");
return 0;
}
cnf = Meta_KeypadBK_OP(req);
if (cnf.status)
META_LOG("kpd: Meta_KeypadBK_OP() successful\n");
else
META_LOG("kpd: Meta_KeypadBK_OP() failed\n");
Meta_KeypadBK_Deinit();
return 0;
}
void UsbPort::update()
{
if (!isReady())
{
if(m_usbFlag)
{
close();
}
m_usbFlag = 0;
META_LOG("[Meta]USB cable plus out!");
}
else
{
if(!m_usbFlag)
{
sleep(1);
if (pthread_mutex_lock (&META_USBPort_Mutex))
{
META_LOG( "[Meta]META_MAIN META_USBPort_Mutex lock error!\n");
}
m_fd = open(m_devPath);
if(m_fd != NULL_FILE_DESCRIPTOR)
{
m_usbFlag = 1;
}
if (pthread_mutex_unlock (&META_USBPort_Mutex))
{
META_LOG( "[Meta]META_Main META_USBPort_Mutex unlock error!\n");
}
}
}
}
static int is_lv_done_before(const char * pVol)
{
DIR *autok_data_dir;
struct dirent *autok_file;
char *filename;
static char sname[AUTOK_S_BUF_LEN] = "";
if(strlen(sname) > 0){
if(is_file_valid(sname) > 0){
META_LOG("[AUTOK]Cache LV Done");
return true;
}
else {
META_LOG("[AUTOK]Cache LV not done");
memset(sname, 0, AUTOK_S_BUF_LEN);
return false;
}
}
autok_data_dir = opendir(AUTOK_RES_PATH);
while((autok_file = readdir(autok_data_dir)) != NULL) {
filename = autok_file->d_name;
if(strstr(filename, "autok")!= NULL &&
strstr(filename, pVol)!=NULL &&
strstr(filename, "_log")==NULL){
memset(sname, 0, AUTOK_S_BUF_LEN);
snprintf(sname, AUTOK_S_BUF_LEN, "%s/%s", AUTOK_RES_PATH, filename);
META_LOG("[AUTOK]Non-Cached LV check exist");
return true;
}
}
closedir(autok_data_dir);
return false;
}
static int mnl_write_attr(const char *name, unsigned char attr)
{
int err, fd = open(name, O_RDWR);
char buf[] = {attr + '0'};
if (fd == -1) {
META_LOG("open %s err = %s\n", name, strerror(errno));
return -errno;
}
do { err = write(fd, buf, sizeof(buf) ); }
while (err < 0 && errno == EINTR);
if (err != sizeof(buf)) {
META_LOG("write fails = %s\n", strerror(errno));
err = -errno;
} else {
err = 0; /*no error*/
}
if (close(fd) == -1) {
META_LOG("close fails = %s\n", strerror(errno));
err = (err) ? (err) : (-errno);
}
META_LOG("write '%d' to %s okay\n", attr, name);
return err;
}
KeypadBK_CNF Meta_KeypadBK_OP(KeypadBK_REQ req)
{
int r;
struct kpd_ledctl ledctl;
KeypadBK_CNF cnf = { .status = false, };
if (kpd_fd < 0) {
META_LOG("kpd: uninitialized kpd_fd\n");
return cnf;
}
if (req.onoff)
{
if (write(kpd_fd,"1",1) == -1) {
LOGE("Can't write %d\n", req.onoff);
}
}else if (write(kpd_fd, "0",1) == -1) {
LOGE("Can't write %d\n", req.onoff);
}
cnf.status = true;
return cnf;
}
BOOL Meta_KeypadBK_Deinit(void)
{
if (kpd_fd < 0) {
META_LOG("kpd: uninitialized kpd_fd\n");
return false;
}
close(kpd_fd);
return true;
}
static int turn_off_6630()
{
char *off_cmd[5] = {"7 0 0", "7 1 0", "7 2 0", "7 3 0", "7 5 0"};
const char *wmt_node = "/proc/driver/wmt_dbg";
int fd_wmt = -1;
char cmd_line[AUTOK_BUF_LEN] = "";
int i;
int ret;
ret = 0;
fd_wmt = open(wmt_node, O_RDWR, 0);
if(fd_wmt < 0){
META_LOG("[AUTOK]Open %s fail", wmt_node);
return -1;
}
for(i=0; i<sizeof(off_cmd)/sizeof(off_cmd[0]); i++){
ret = write(fd_wmt, off_cmd[i], strlen(off_cmd[i]));
if(ret < 0){
META_LOG("[AUTOK]Write %s to %s error[%d]", off_cmd[i], wmt_node, ret);
goto EXIT_TURN_OFF_6630;
}
ret = 0;
}
EXIT_TURN_OFF_6630:
if(fd_wmt > -1)
close(fd_wmt);
return ret;
}
FT_PMIC_REG_WRITE_CNF META_PMICW_OP ( FT_PMIC_REG_WRITE *req )
{
FT_PMIC_REG_WRITE_CNF pmic_cnf;
int ret=0;
memset(&pmic_cnf, 0, sizeof(FT_PMIC_REG_WRITE_CNF));
/* open file */
meta_pmic_fd = open("/dev/MT6326-pmic",O_RDWR, 0);
if (meta_pmic_fd == -1) {
printf("Open /dev/MT6326-pmic : ERROR \n");
META_LOG("Open /dev/MT6326-pmic : ERROR \n");
pmic_cnf.m_rWmCmdWriteResult.status = false;
return pmic_cnf;
}
pmic_in_data[0] = req->m_rWmCmdWriteReq.registernumber;
pmic_in_data[1] = req->m_rWmCmdWriteReq.registervalue;
ret = ioctl(meta_pmic_fd, PMIC_WRITE, pmic_in_data);
if (ret == -1)
{
pmic_cnf.m_rWmCmdWriteResult.status = false;
}
else
{
pmic_cnf.m_rWmCmdWriteResult.status = true;
}
printf("\nMETA_PMICW_OP : Write %x to Reg[%x]\n", pmic_in_data[1], pmic_in_data[0]);
META_LOG("\nMETA_PMICW_OP : Write %x to Reg[%x]\n", pmic_in_data[1], pmic_in_data[0]);
close(meta_pmic_fd);
return pmic_cnf;
}
int UsbPort::isReady() const
{
int type = 0;
char buf[11];
int bytes_read = 0;
int res = 0;
int fd = ::open("/sys/class/android_usb/android0/state", O_RDONLY);
if (fd != -1)
{
memset(buf, 0, 11);
while (bytes_read < 10)
{
res = ::read(fd, buf + bytes_read, 10);
if (res > 0)
bytes_read += res;
else
break;
}
::close(fd);
type = strcmp(buf,"CONFIGURED");
META_LOG("[Meta]Query usb state OK.");
}
else
{
META_LOG("[Meta]Failed to open:/sys/class/android_usb/android0/state");
}
return (type == 0);
}
BOOL FM_Low_Power(BOOL bOn)
{
int tmp=0;
int ret=0;
BOOL dPmicErrCode=false;
printf("Enter FM_Low_Power function in Factory Mode!\n");
META_LOG("Enter FM_Low_Power function in Factory Mode!\n");
/* open file */
meta_pmic_fd = open("/dev/MT6326-pmic",O_RDWR, 0);
if (meta_pmic_fd == -1) {
printf("Open /dev/MT6326-pmic : ERROR \n");
META_LOG("Open /dev/MT6326-pmic : ERROR \n");
return dPmicErrCode;
}
for(tmp=0;tmp<0x7D;tmp++){
if(bOn)
{
pmic_in_data[0] = (0x1A + tmp);
pmic_in_data[1] = g_pmic_power_up[tmp];
ret = ioctl(meta_pmic_fd, PMIC_WRITE, pmic_in_data);
if (ret == -1)
dPmicErrCode = false;
else
dPmicErrCode = true;
//printf("FM_Low_Power : Power Up Device in Factory Mode!\n");
}
else
{
pmic_in_data[0] = (0x1A + tmp);
pmic_in_data[1] = g_pmic_power_down[tmp];
ret = ioctl(meta_pmic_fd, PMIC_WRITE, pmic_in_data);
if (ret == -1)
dPmicErrCode = false;
else
dPmicErrCode = true;
//printf("FM_Low_Power : Power Done Device in Factory Mode!\n");
}
if(dPmicErrCode == false)
{
printf("FM_Low_Power : Write Register Failed!\n");
META_LOG("FM_Low_Power : Write Register Failed!\n");
break;
}
}
printf("Leave FM_Low_Power function in Factory Mode!\n");
META_LOG("Leave FM_Low_Power function in Factory Mode!\n");
close(meta_pmic_fd);
return dPmicErrCode;
}
void *GPS_MetaThread(void *arg)
{
int read_leng = 0;
int cnt = 0;
char *ptr;
unsigned char buf[10240];
cnt = 0;
while(1)
{
memset(buf, 0, sizeof(buf));
read_leng = 0;
read_leng = read(sockfd, buf, sizeof(buf));
if (read_leng < 0)
{
META_LOG("ERROR reading from socket");
return (void *)(-1);
}
else if(read_leng > 0)
{
ptr=strtok(buf, "\r\n");
if(ptr == NULL)
{
continue;
}
do
{
/*if(strncmp(ptr, "$PMTK", 5) == 0)
{
if((ptr[5] >= '0' && ptr[5] <= '9') &&
(ptr[6] >= '0' && ptr[6] <= '9') &&
(ptr[7] >= '0' && ptr[7] <= '9')) // $PMTK000~$PMTK999*/
//{
META_LOG("GPS_MetaThread: %s", ptr);
strncpy(&gps_cnf2.gps_ack.buff[cnt], ptr, (sizeof(gps_cnf2.gps_ack.buff) - cnt));
cnt += strlen(ptr);
gps_cnf2.gps_ack.buff[cnt++] = '\r';
gps_cnf2.gps_ack.buff[cnt++] = '\n';
// }
//}
}while((ptr=strtok(NULL, "\r\n")) != NULL);
if(cnt > 0)
{
gps_cnf2.gps_ack.len = cnt;
gps_cnf2.gps_status = TRUE;
gps_cnf2.status = META_SUCCESS;
META_LOG("GPS_MetaThread, status:%d, gps_cnf.gps_ack.len:%d\r\n", gps_cnf2.status, gps_cnf2.gps_ack.len);
WriteDataToPC(&gps_cnf2, sizeof(GPS_CNF), NULL, 0);
cnt = 0;
}
}
}
return (void *)0;
}
void Meta_AUXADC_OP(AUXADC_REQ *req, char *peer_buff, unsigned short peer_len)
{
AUXADC_CNF ADCMetaReturn;
int ret;
memset(&ADCMetaReturn, 0, sizeof(ADCMetaReturn));
ADCMetaReturn.header.id=req->header.id+1;
ADCMetaReturn.header.token=req->header.token;
ADCMetaReturn.status=META_SUCCESS;
ADCMetaReturn.ADCStatus=TRUE;
/* open file */
meta_adc_fd = open("/dev/mtk-adc-cali",O_RDWR, 0);
if (meta_adc_fd == -1) {
printf("Open /dev/mtk-adc-cali : ERROR \n");
META_LOG("Open /dev/mtk-adc-cali : ERROR \n");
ADCMetaReturn.status=META_FAILED;
goto ADC_Finish;
}
adc_in_data[0] = req->dwChannel;
adc_in_data[1] = req->dwCount;
ret = ioctl(meta_adc_fd, ADC_CHANNEL_READ, adc_in_data);
if (ret == -1)
{
ADCMetaReturn.dwData = 0;
ADCMetaReturn.status = META_FAILED;
}
else
{
if (adc_in_data[1]==0) {
ADCMetaReturn.dwData = adc_in_data[0];
ADCMetaReturn.status = META_SUCCESS;
}
else {
ADCMetaReturn.dwData = 0;
ADCMetaReturn.status = META_FAILED;
}
}
printf("Meta_AUXADC_OP : CH[%d] in %d times : %d\n", req->dwChannel, req->dwCount, adc_in_data[0]);
META_LOG("Meta_AUXADC_OP : CH[%d] in %d times : %d\n", req->dwChannel, req->dwCount, adc_in_data[0]);
META_LOG("Meta_AUXADC_OP : CH[%d] in %d times : %d : dwdata\n", req->dwChannel, req->dwCount, ADCMetaReturn.dwData);
close(meta_adc_fd);
ADC_Finish:
if (false == WriteDataToPC(&ADCMetaReturn,sizeof(ADCMetaReturn),NULL,0)) {
printf("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
META_LOG("Meta_AUXADC_OP : WriteDataToPC() fail 2\n");
}
printf("Meta_AUXADC_OP : Finish !\n");
META_LOG("Meta_AUXADC_OP : Finish !\n");
}
int main(int argc, char *argv[])
{
WatchDog_REQ req;
WatchDog_CNF cnf;
cnf = META_RTCRead_OP(req);
if (cnf.status) {
META_LOG("rtc: time is %u/%02u/%02u (%u) %02u:%02u:%02u\n",
cnf.rtc_year, cnf.rtc_mon, cnf.rtc_day, cnf.rtc_wday,
cnf.rtc_hour, cnf.rtc_min, cnf.rtc_sec);
} else {
META_LOG("rtc: META_RTCRead_OP() failed\n");
}
return 0;
}
void META_GPS_Close()
{
int err;
META_LOG("META_GPS_Close() 1\n");
// close GPS_MetaThread
#if 0
if ((err = pthread_kill(gps_meta_thread_handle, SIGUSR1)))
{
META_LOG("META_GPS_Close: pthread_kill 1 error(%d) \n", err);
}
META_LOG("META_GPS_Close() 2\n");
if ((err = pthread_join(gps_meta_thread_handle, NULL)))
{
META_LOG("META_GPS_Close: pthread_kill 2 error(%d) \n", err);
}
META_LOG("META_GPS_Close() 3\n");
#endif
// disconnect to gps driver
if(sockfd != C_INVALID_SOCKET)
{
close(sockfd);
sockfd = C_INVALID_SOCKET;
}
META_LOG("META_GPS_Close() 4\n");
// kill gps driver (libmnlp)
if(mnl_pid != C_INVALID_PID)
{
kill(mnl_pid, SIGKILL);
}
META_LOG("META_GPS_Close() 5\n");
// power off GPS chip
err = mnl_write_attr("/sys/class/gpsdrv/gps/pwrctl", 0);
if(err != 0)
{
META_LOG("GPS power-off error: %d\n", err);
}
META_LOG("META_GPS_Close() 6\n");
unlink(GPS_PROPERTY);
META_LOG("META_GPS_Close() 7\n");
return;
}
signed int SerPort::open(const char *path)
{
signed int fd = ::open(path, O_RDWR|O_NOCTTY);
META_LOG("[Meta] Open serPort. m_fd = %d", fd);
if (fd != NULL_FILE_DESCRIPTOR)
{
META_LOG("[Meta] Open serport:(%s) success.", path);
initTermIO(fd);
}
else
{
META_LOG("[Meta] Open serport:(%s) fail, error code = %d", path, errno);
}
return fd;
}
BOOL Meta_KeypadBK_Init(void)
{
kpd_fd = open(KPD_BKL_PATH, O_WRONLY);
if (kpd_fd < 0) {
META_LOG("kpd: open %s failed\n", KPD_BKL_PATH);
return false;
}
return true;
}
bool SamplePlugin::Hook_ClientConnect(edict_t *pEntity,
const char *pszName,
const char *pszAddress,
char *reject,
int maxrejectlen)
{
META_LOG(g_PLAPI, "Hook_ClientConnect(%d, \"%s\", \"%s\")", IndexOfEdict(pEntity), pszName, pszAddress);
return true;
}
bool SamplePlugin::Hook_LevelInit(const char *pMapName,
char const *pMapEntities,
char const *pOldLevel,
char const *pLandmarkName,
bool loadGame,
bool background)
{
META_LOG(g_PLAPI, "Hook_LevelInit(%s)", pMapName);
return true;
}
unsigned char META_Lock_OP()
{
unsigned int iMagicNum=META_LOCK_MAGIC_NUM;
int result=0;
META_LOG("[META_LOCK]:enter meta_lock_op\r\n");
result=META_Lock_WriteFlash(iMagicNum);
if(result==0)
return META_FAILED;
return META_SUCCESS;
}
static int restore_meta_screen()
{
int fb_fd = open("/dev/graphics/fb0", O_RDWR);
if(fb_fd >= 0){
ioctl(fb_fd, MTKFB_META_SHOW_BOOTLOGO, 0);
close(fb_fd);
}else{
META_LOG("fail to open display driver error:%d, errorstr:%s",
errno, strerror(errno));
}
return 0;
}
/********************************************************************************
//FUNCTION:
// META_NFC_CMD
//DESCRIPTION:
// SEND MESSAGE to NFC driver
// RECEIVE MESSAGE to NFC driver
//PARAMETERS:
// void
//RETURN VALUE:
// void
//
********************************************************************************/
void META_NFC_CMD(ilm_struct* nfc_ilm_req_ptr)
{
int ret = 0;
int rec_bytes = 0;
int rety_count = 0;
META_LOG("META_NFC_CMD:write CMD");
// Write request command
ret = write(nfc_service_sockfd, (const char*)nfc_ilm_req_ptr, sizeof(ilm_struct));
if ( ret <= 0)
{
META_LOG("META_NFC_CMD:write failure,%d",ret);
return;
}
else
{
META_LOG("META_NFC_CMD:write CMD done,%d",ret);
}
return;
}
mBOOL MPluginList::load() {
int i, n;
if (!ini_startup()) {
META_ERROR("Problem loading plugins.ini: %s", inifile);
// meta_errno should be already set in ini_startup()
return(mFALSE);
}
META_LOG("dll: Loading plugins...");
for(i=0, n=0; i < endlist; i++) {
if(plist[i].status < PL_VALID)
continue;
if(plist[i].load(PT_STARTUP) == mTRUE)
n++;
else
// all plugins should be loadable at startup...
META_ERROR("dll: Failed to load plugin '%s'", plist[i].file);
}
META_LOG("dll: Finished loading %d plugins", n);
return(mTRUE);
}
FT_PMIC_REG_READ_CNF META_PMICR_OP ( FT_PMIC_REG_READ *req )
{
FT_PMIC_REG_READ_CNF pmic_cnf;
int ret=0;
memset(&pmic_cnf, 0, sizeof(FT_PMIC_REG_READ_CNF));
/* open file */
meta_pmic_fd = open("/dev/MT6326-pmic",O_RDWR, 0);
if (meta_pmic_fd == -1) {
printf("Open /dev/MT6326-pmic : ERROR \n");
META_LOG("Open /dev/MT6326-pmic : ERROR \n");
pmic_cnf.m_rWmCmdReadResult.value = 0xff;
pmic_cnf.m_rWmCmdReadResult.status = false;
return pmic_cnf;
}
pmic_out_data[0] = req->m_rWmCmdReadReq.registernumber;
ret = ioctl(meta_pmic_fd, PMIC_READ, pmic_out_data);
if (ret == -1)
{
pmic_cnf.m_rWmCmdReadResult.value = 0xff;
pmic_cnf.m_rWmCmdReadResult.status = false;
}
else
{
pmic_cnf.m_rWmCmdReadResult.value = pmic_out_data[0];
pmic_cnf.m_rWmCmdReadResult.status = true;
}
printf("\nMETA_PMICR_OP : Read Reg[%d] = %d \n", req->m_rWmCmdReadReq.registernumber, pmic_cnf.m_rWmCmdReadResult.value);
META_LOG("\nMETA_PMICR_OP : Read Reg[%d] = %d \n", req->m_rWmCmdReadReq.registernumber, pmic_cnf.m_rWmCmdReadResult.value);
close(meta_pmic_fd);
return pmic_cnf;
}
signed int CCCI::open(const char *path)
{
int retry = 100;
signed int fd = NULL_FILE_DESCRIPTOR;
while(fd == NULL_FILE_DESCRIPTOR && retry != 0)
{
fd = ::open(path, O_RDWR|O_NOCTTY);
META_LOG("[Meta]Open CCCI. m_fd = %d", fd);
if (fd != NULL_FILE_DESCRIPTOR)
{
META_LOG("[Meta] Open CCCI port:(%s) success.", path);
break;
}
else
{
META_LOG("[Meta] Open CCCI port:(%s) fail.", path);
usleep(100*1000);
retry--;
}
}
return fd;
}
static int should_do_dvfs_autok()
{
int fd = 0 ;
char buf[AUTOK_BUF_LEN] = {0};
int ret = -1 ;
int i = 0;
char * p = NULL;
fd = open("/sys/power/vcorefs/pwr_ctrl",O_RDONLY);
if(fd < 0){
META_LOG("[AUTOK]Open /sys/power/vcorefs/pwr_ctrl error");
return 0;
}
ret = read(fd, buf, AUTOK_BUF_LEN);
close(fd);
if(ret < 0){
META_LOG("[AUTOK]Read suggest_vol file error !");
return 0;
}
p = strstr(buf, "lv_autok_trig = 1");
if(p!=NULL)
return 1;
else
return 0;
}
/********************************************************************************
//FUNCTION:
// META_NFC_deinit
//DESCRIPTION:
// NFC deinit for META test.
//
//PARAMETERS:
// void
//RETURN VALUE:
// void
//
********************************************************************************/
void META_NFC_deinit()
{
int err=0;
/* stop RX thread */
bStop_ReadThread = 1;
/* wait until thread exist */
pthread_join(read_cnf_thread_handle, NULL);
/* Close socket port */
if (nfc_service_sockfd > 0)
{
close (nfc_service_sockfd);
nfc_service_sockfd = -1;
}
// kill service process
META_LOG("META_NFC_deinit: kill: %s\n", "/system/xbin/nfcservice");
err = execl("kill /system/xbin/nfcservice", "nfcservice", NULL);
if (err == -1)
{
META_LOG("META_NFC_init: kill error: %s\n", strerror(errno));
}
return;
}
bool SamplePlugin::Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlen, bool late)
{
PLUGIN_SAVEVARS();
GET_V_IFACE_CURRENT(GetEngineFactory, engine, IVEngineServer, INTERFACEVERSION_VENGINESERVER);
GET_V_IFACE_CURRENT(GetEngineFactory, gameevents, IGameEventManager2, INTERFACEVERSION_GAMEEVENTSMANAGER2);
GET_V_IFACE_CURRENT(GetEngineFactory, helpers, IServerPluginHelpers, INTERFACEVERSION_ISERVERPLUGINHELPERS);
GET_V_IFACE_CURRENT(GetEngineFactory, icvar, ICvar, CVAR_INTERFACE_VERSION);
GET_V_IFACE_ANY(GetServerFactory, server, IServerGameDLL, INTERFACEVERSION_SERVERGAMEDLL);
GET_V_IFACE_ANY(GetServerFactory, gameclients, IServerGameClients, INTERFACEVERSION_SERVERGAMECLIENTS);
GET_V_IFACE_ANY(GetServerFactory, playerinfomanager, IPlayerInfoManager, INTERFACEVERSION_PLAYERINFOMANAGER);
gpGlobals = ismm->GetCGlobals();
META_LOG(g_PLAPI, "Starting plugin.");
/* Load the VSP listener. This is usually needed for IServerPluginHelpers. */
if ((vsp_callbacks = ismm->GetVSPInfo(NULL)) == NULL)
{
ismm->AddListener(this, this);
ismm->EnableVSPListener();
}
SH_ADD_HOOK_MEMFUNC(IServerGameDLL, LevelInit, server, this, &SamplePlugin::Hook_LevelInit, true);
SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, server, this, &SamplePlugin::Hook_ServerActivate, true);
SH_ADD_HOOK_MEMFUNC(IServerGameDLL, GameFrame, server, this, &SamplePlugin::Hook_GameFrame, true);
SH_ADD_HOOK_MEMFUNC(IServerGameDLL, LevelShutdown, server, this, &SamplePlugin::Hook_LevelShutdown, false);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientActive, gameclients, this, &SamplePlugin::Hook_ClientActive, true);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, gameclients, this, &SamplePlugin::Hook_ClientDisconnect, true);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, gameclients, this, &SamplePlugin::Hook_ClientPutInServer, true);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, SetCommandClient, gameclients, this, &SamplePlugin::Hook_SetCommandClient, true);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, gameclients, this, &SamplePlugin::Hook_ClientSettingsChanged, false);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, gameclients, this, &SamplePlugin::Hook_ClientConnect, false);
SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, gameclients, this, &SamplePlugin::Hook_ClientCommand, false);
ENGINE_CALL(LogPrint)("All hooks started!\n");
#if SOURCE_ENGINE >= SE_ORANGEBOX
g_pCVar = icvar;
ConVar_Register(0, &s_BaseAccessor);
#else
ConCommandBaseMgr::OneTimeInit(&s_BaseAccessor);
#endif
return true;
}
int main(int argc, const char** argv)
{
NFC_REQ req;
memset(&req, 0, sizeof(NFC_REQ));
META_NFC_Register(nfc_info_callback);
if (META_NFC_init() != 0) {
META_LOG("META_NFC_init Failure\n");
return -1;
}
sleep(1);
nfc_cnf.header.id = FT_NFC_CNF_ID;
nfc_cnf.header.token = req->header.token;
nfc_cnf.op = req->op;
req.cmd.m_setting_req.debug_enable = 1;
req.cmd.m_setting_req.get_capabilities = 1;
req.cmd.m_setting_req.nfc_enable = 1;
req.cmd.m_setting_req.sw_protocol = 1;
req.header.id = 1;
req.header.token = 1;
req.op = NFC_OP_SETTING;
META_NFC_OP(&req, NULL, 0);
sleep(10);
META_NFC_OP(&req, NULL, 0);
sleep(1);
META_NFC_deinit();
META_NFC_Register(NULL);
return 0;
}
int FT_GetModemCapability(MODEM_CAPABILITY_LIST * modem_capa)
{
int modem_type = 0;
int active_modem_id = 0;
int mode_mnumber = 0;
mode_mnumber = FT_GetModemType(&active_modem_id,&modem_type);
if((modem_type & 0x01) == 0x01)
{
modem_capa->modem_cap[0].md_service = FT_MODEM_SRV_TST;
modem_capa->modem_cap[0].ch_type = FT_MODEM_CH_NATIVE_TST;
}
if((modem_type & 0x02) == 0x02)
{
modem_capa->modem_cap[1].md_service = FT_MODEM_SRV_TST;
modem_capa->modem_cap[1].ch_type = FT_MODEM_CH_NATIVE_TST;
}
if((modem_type & 0x10) == 0x10)
{
#ifdef MTK_LTE_SUPPORT
modem_capa->modem_cap[4].md_service = FT_MODEM_SRV_DHL;
modem_capa->modem_cap[4].ch_type = FT_MODEM_CH_TUNNELING;
#else
modem_capa->modem_cap[4].md_service = FT_MODEM_SRV_TST;
modem_capa->modem_cap[4].ch_type = FT_MODEM_CH_NATIVE_TST;
#endif
META_LOG("modem_cap[4]%d,%d",modem_capa->modem_cap[4].md_service,modem_capa->modem_cap[4].ch_type);
}
return 1;
}
void META_GPS_OP(GPS_REQ *req, char *peer_buff, unsigned short peer_len)
{
memset(&gps_cnf1, 0, sizeof(GPS_CNF));
gps_cnf1.header.id = FT_GPS_CNF_ID;
gps_cnf1.header.token = req->header.token;
gps_cnf1.op = req->op;
memset(&gps_cnf2, 0, sizeof(GPS_CNF));
gps_cnf2.header.id = FT_GPS_CNF_ID;
gps_cnf2.header.token = req->header.token;
gps_cnf2.op = req->op;
META_LOG("META_GPS_OP() 1, (%d)\n", req->op);
switch(req->op)
{
case GPS_OP_OPEN:
META_LOG("META_GPS_OP(), GPS_OP_OPEN 1\n");
if(META_GPS_Open() != 0) // open fail
{
META_LOG("META_GPS_OP(), GPS_OP_OPEN fail\n");
META_GPS_Close();
META_LOG("Can't open gps driver \r\n");
gps_cnf1.gps_status = FALSE;
gps_cnf1.status = META_FAILED;
}
else
{
META_LOG("META_GPS_OP(), GPS_OP_OPEN OK\n");
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
}
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), GPS_OP_OPEN 2\n");
break;
case GPS_OP_CLOSE:
META_LOG("META_GPS_OP(), GPS_OP_CLOSE 1\n");
META_GPS_Close();
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), GPS_OP_CLOSE 2\n");
break;
case GPS_OP_SEND_CMD:
META_LOG("META_GPS_OP(), GPS_OP_SEND_CMD\n");
if(sockfd != C_INVALID_SOCKET)
{
int n = write(sockfd, req->cmd.buff, req->cmd.len);
if (n < 0)
{
META_LOG("ERROR writing to socket\r\n");
}
META_LOG("META_GPS_OP(), GPS_OP_SEND_CMD: %s\r\n", req->cmd.buff);
}
gps_cnf1.gps_status = TRUE;
gps_cnf1.status = META_SUCCESS;
META_LOG("GPS_OP_SEND_CMD, gps_cnf.status:%d\r\n", gps_cnf1.status);
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
break;
default:
META_LOG("META_GPS_OP(), default 1\n");
gps_cnf1.gps_status = FALSE;
gps_cnf1.status = META_FAILED;
WriteDataToPC(&gps_cnf1, sizeof(GPS_CNF), NULL, 0);
META_LOG("META_GPS_OP(), default 2\n");
break;
}
META_LOG("META_GPS_OP() 2\n");
}
int META_GPS_Open()
{
int err;
pid_t pid;
int portno;
struct sockaddr_in serv_addr;
struct hostent *server;
char *argv[] = {"/system/xbin/libmnla", "libmnlp"};
chip_detector();
META_LOG("META_GPS_Open() 1\n");
// power on GPS chip
err = mnl_write_attr("/sys/class/gpsdrv/gps/pwrctl", 4);
if(err != 0)
{
META_LOG("META_GPS_Open: GPS power-on error: %d\n", err);
return (-1);
}
// run gps driver (libmnlp)
if ((pid = fork()) < 0)
{
META_LOG("META_GPS_Open: fork fails: %d (%s)\n", errno, strerror(errno));
return (-2);
}
else if (pid == 0) /*child process*/
{
char chip_id[100]={0};
int fd;
if((fd = open(GPS_PROPERTY, O_RDONLY)) == -1)
MND_ERR("open % error, %s\n", GPS_PROPERTY, strerror(errno));
if(read(fd, chip_id, sizeof(chip_id)) == -1)
MND_ERR("open % error, %s\n", GPS_PROPERTY, strerror(errno));
close(fd);
unlink(GPS_PROPERTY);
MND_MSG("chip_id is %s\n", chip_id);
if (strcmp(chip_id, "0x6620") ==0 )
{
MND_MSG("we get MT6620\n");
char *mnl6620 = "/system/xbin/libmnlp_mt6620";
argv[0] = mnl6620;
}
else if(strcmp(chip_id, "0x6628") == 0)
{
MND_MSG("we get MT6628\n");
char *mnl6628 = "/system/xbin/libmnlp_mt6628";
argv[0] = mnl6628;
}
else if(strcmp(chip_id, "0x6630") == 0)
{
MND_MSG("we get MT6630\n");
char *mnl6630 = "/system/xbin/libmnlp_mt6630";
argv[0] = mnl6630;
}
else if(strcmp(chip_id, "0x6572") == 0)
{
MND_MSG("we get MT6572\n");
char *mnl6572 = "/system/xbin/libmnlp_mt6572";
argv[0] = mnl6572;
}
else if(strcmp(chip_id, "0x6582") == 0)
{
MND_MSG("we get MT6582\n");
char *mnl6582 = "/system/xbin/libmnlp_mt6582";
argv[0] = mnl6582;
}
else if(strcmp(chip_id, "0x6592") == 0)
{
MND_MSG("we get MT6592\n");
char *mnl6592 = "/system/xbin/libmnlp_mt6592";
argv[0] = mnl6592;
}
else if(strcmp(chip_id, "0x3332") == 0)
{
MND_MSG("we get MT3332\n");
char *mnl3332 = "/system/xbin/libmnlp_mt3332";
argv[0] = mnl3332;
}
else
{
MND_ERR("chip is unknown, chip id is %s\n", chip_id);
return -1;
}
MND_MSG("execute: %s \n", argv[0]);
err = execl(argv[0], "libmnlp", "1Hz=y", NULL);
if (err == -1){
MND_MSG("execl error: %s\n", strerror(errno));
return -1;
}
return 0;
}
else /*parent process*/
{
mnl_pid = pid;
META_LOG("META_GPS_Open: mnl_pid = %d\n", pid);
}
// create socket connection to gps driver
portno = 7000;
/* Create a socket point */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
META_LOG("META_GPS_Open: ERROR opening socket");
return (-4);
}
/* server = gethostbyname("127.0.0.1");
if (server == NULL) {
META_LOG("META_GPS_Open: ERROR, no such host\n");
return (-5);
}
*/
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
// bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
serv_addr.sin_addr.s_addr = htons(INADDR_ANY);
serv_addr.sin_port = htons(portno);
sleep(3); // sleep 5sec for libmnlp to finish initialization
/* Now connect to the server */
if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
META_LOG("META_GPS_Open: ERROR connecting");
return (-6);
}
// run GPS_MetaThread
if (pthread_create(&gps_meta_thread_handle, NULL, GPS_MetaThread, NULL))
{
META_LOG("META_GPS_Open: error creating dsp thread \n");
return (-7);
}
META_LOG("META_GPS_Open() 2\n");
return 0;
}
