| #include "lynq-qser-autosuspend.h"
|
|
|
| #include <stdio.h>
|
| #include <unistd.h>
|
| #include <stddef.h>
|
| #include <sys/types.h>
|
| #include <sys/stat.h>
|
| #include <fcntl.h>
|
| #include <pthread.h>
|
| #include <string.h>
|
| #include <stdlib.h>
|
| #include <errno.h>
|
| #include <sys/epoll.h>
|
| #include <linux/input.h>
|
|
|
| #include "mbtk_type.h"
|
| #include "mbtk_log.h"
|
| #include "mbtk_info_api.h"
|
| #include "mbtk_power.h"
|
|
|
| /*
|
| This module is system sleep, the system cannot sleep when the lock exists
|
| To verify whether it is in sleep state, it is necessary to test the power consumption
|
| Power management principle, as long as a wakelock lock exists, the system will not enter the Suspend state
|
| So the name can be arbitrarily chosen to indicate that such a lock is needed so that the system does not sleep
|
| */
|
| #if defined(MBTK_PLATFORM_KERNEL_5)
|
| #define MTBK_POWERIND "/system/etc/powerind" //1806
|
| #elif defined(MBTK_PLATFORM_KERNEL_3)
|
| #define MTBK_POWERIND "/etc/powerind" //1803
|
| #endif
|
|
|
| static bool call_Off = FALSE;
|
| static bool nw_off = FALSE;
|
| static bool sms_off = FALSE;
|
| static bool data_off = FALSE;
|
|
|
| static pthread_t lpm_t;
|
| static int edge_t = 0;
|
| static int epoll_fd_t = -1;
|
| static int fd_t = -1;
|
| static int socket_t[2];
|
|
|
| typedef struct{
|
| qser_lpm_wakeupin_data_t wakeupin;
|
| qser_lpm_wakeupout_data_t wakeupout;
|
| qser_lpm_Handler_t wakehandle;
|
| }lynq_wake_t;
|
|
|
| static lynq_wake_t lpm_init;
|
|
|
|
|
| typedef struct
|
| {
|
| int fd;
|
| char name[64];
|
| } lock_name;
|
|
|
| #define LOCK_MAX_SIZE 129
|
|
|
| lock_name lynq_lock_name[LOCK_MAX_SIZE]={0};
|
| static bool autosleep_enable = FALSE;
|
|
|
| static mbtk_info_handle_t* whitelist_info_handle = NULL;
|
|
|
|
|
| #define EPOLL_SIZE_HINT 128
|
| int mEpollFd = -1;
|
| mbtk_info_callback_func g_sleep_timer_cb;
|
|
|
|
|
|
|
| static int powerrind_get()
|
| {
|
| char buffer[4];
|
| int ret = 0;
|
|
|
| int fd = open(MTBK_POWERIND, O_RDWR | O_SYNC, 0662);
|
| if (fd != -1)
|
| {
|
| read(fd, buffer, strlen(buffer)+1);
|
| close(fd);
|
| }
|
|
|
| ret = atoi(buffer);
|
|
|
| return ret;
|
| }
|
|
|
| #if 1
|
| static int sleep_epoll_deregister(int epoll_fd,int fd )
|
| {
|
| int ret;
|
| do {
|
| ret = epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL );
|
| } while (ret < 0 && errno == EINTR);
|
| return ret;
|
| }
|
|
|
| static int sleep_epoll_register(int epoll_fd, int fd)
|
| {
|
| struct epoll_event ev;
|
| int ret, flags;
|
|
|
| /* important: make the fd non-blocking */
|
| flags = fcntl(fd, F_GETFL);
|
| fcntl(fd, F_SETFL, flags | O_NONBLOCK);
|
|
|
| ev.events = EPOLLIN;
|
| ev.data.fd = fd;
|
| do {
|
| ret = epoll_ctl( epoll_fd, EPOLL_CTL_ADD, fd, &ev );
|
| } while (ret < 0 && errno == EINTR);
|
|
|
| return ret;
|
| }
|
| #endif
|
|
|
| int qser_autosuspend_enable(char enable)
|
| {
|
| //UNUSED(enable);
|
|
|
| if((enable == 1) || enable == '1')
|
| {
|
| //if(!mbtk_system_sleep())
|
| if(!access("/sys/power/autosleep", W_OK))
|
| {
|
| system("echo mem > /sys/power/autosleep");
|
| autosleep_enable = TRUE;
|
| return 0;
|
| }
|
| else
|
| {
|
| LOGE("/sys/power/autosleep can not write.");
|
| return -1;
|
| }
|
| }
|
| else if((enable == 0) || enable == '0')
|
| {
|
| if(!access("/sys/power/autosleep", W_OK))
|
| {
|
| system("echo off > /sys/power/autosleep");
|
| autosleep_enable = FALSE;
|
| return 0;
|
| }
|
| else
|
| {
|
| LOGE("/sys/power/autosleep can not write.");
|
| return -1;
|
| }
|
| }
|
| else
|
| {
|
| LOGE("qser_autosuspend_enablecan enable err.");
|
| return -1;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int qser_wakelock_create(const char* name , size_t len)
|
| {
|
| //UNUSED(name);
|
| //UNUSED(len);
|
| int len_t;
|
| /*
|
| if(!autosleep_enable) {
|
| LOGE("Autosleep not enable.");
|
| return -1;
|
| }
|
| */
|
| len_t = strlen(name);
|
|
|
| if((name != NULL) && (len < 33) && (len_t < 33))
|
| {
|
| int i;
|
| //name
|
| for(i=1 ;i<LOCK_MAX_SIZE;i++)
|
| {
|
| if(strcmp(lynq_lock_name[i].name, name) == 0)
|
| {
|
| LOGE("Repeated names.");
|
| return -1;
|
| }
|
| }
|
|
|
| for(i=1 ;i<LOCK_MAX_SIZE;i++)
|
| {
|
| if(lynq_lock_name[i].fd == 0)
|
| break;
|
| }
|
|
|
| if (i >= LOCK_MAX_SIZE)
|
| {
|
| LOGE("Fd is full.");
|
| return -1;
|
| }
|
|
|
| memcpy(lynq_lock_name[i].name, name, strlen(name)+1);
|
| lynq_lock_name[i].fd = i;
|
| return lynq_lock_name[i].fd -1;//Starting from scratch
|
| }
|
| else
|
| return -1;
|
|
|
| return -1;
|
| }
|
|
|
| int qser_wakelock_lock(int fd)
|
| {
|
| //UNUSED(fd);
|
| /*
|
| if(!autosleep_enable) {
|
| LOGE("Autosleep not enable.");
|
| return -1;
|
| }
|
| */
|
| int i;
|
| for(i=1;i<LOCK_MAX_SIZE;i++)
|
| {
|
| if(lynq_lock_name[i].fd -1 == fd)
|
| break;
|
| }
|
| if(i == LOCK_MAX_SIZE)
|
| {
|
| LOGE("LOCK_MAX_SIZE is full\n");
|
| return -1;
|
| }
|
|
|
| if(!access("/sys/power/wake_lock", W_OK))
|
| {
|
| char cmd[128]={0};
|
| sprintf(cmd, "echo %s > /sys/power/wake_lock", lynq_lock_name[i].name);
|
| system(cmd);
|
| return 0;
|
| }
|
| else
|
| {
|
| LOGE("/sys/power/wake_lock can not write.");
|
| return -1;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int qser_wakelock_unlock(int fd)
|
| {
|
| //UNUSED(fd);
|
| /*
|
| if(!autosleep_enable) {
|
| LOGE("Autosleep not enable.");
|
| return -1;
|
| }
|
| */
|
| int i;
|
| for(i=1;i<LOCK_MAX_SIZE;i++)
|
| {
|
| if(lynq_lock_name[i].fd -1 == fd)
|
| break;
|
| }
|
| if(i == LOCK_MAX_SIZE)
|
| {
|
| LOGE("LOCK_MAX_SIZE is full\n");
|
| return -1;
|
| }
|
|
|
| if(!access("/sys/power/wake_unlock", W_OK))
|
| {
|
| char cmd[128]={0};
|
| sprintf(cmd, "echo %s > /sys/power/wake_unlock", lynq_lock_name[i].name);
|
| system(cmd);
|
| return 0;
|
| }
|
| else
|
| {
|
| LOGE("/sys/power/wake_unlock can not write.");
|
| return -1;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| int qser_wakelock_destroy(int fd)
|
| {
|
| //UNUSED(fd);
|
| /*
|
| if(!autosleep_enable) {
|
| LOGE("Autosleep not enable.");
|
| return -1;
|
| }
|
| */
|
| int i;
|
| for(i=1;i<LOCK_MAX_SIZE;i++)
|
| {
|
| if(lynq_lock_name[i].fd -1 == fd)
|
| break;
|
| }
|
|
|
| if(i == LOCK_MAX_SIZE)
|
| {
|
| LOGE("LOCK_MAX_SIZE is full\n");
|
| return -1;
|
| }
|
| else
|
| {
|
| lynq_lock_name[i].fd = 0;
|
| memset(lynq_lock_name[i].name, 0, 64);
|
| return 0;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| void *threadFunction(void *arg)
|
| {
|
| int pinValue;
|
| int i;
|
| char buf[8] = {0};
|
| struct input_event ev_input = { 0 };
|
| const int size = sizeof(struct input_event);
|
|
|
| epoll_fd_t = epoll_create(2);
|
| /*
|
| struct epoll_event event;
|
| memset(&event, 0, sizeof(struct epoll_event));
|
| event.events = EPOLLIN | EPOLLET;
|
| event.data.fd = open("/dev/input/event0", O_RDONLY); // 根据实际情况指定正确的GPIO设备文件名
|
|
|
| fd_t = event.data.fd;
|
| if (epoll_ctl(epoll_fd_t, EPOLL_CTL_ADD, event.data.fd, &event) == -1)
|
| {
|
| LOGE("Failed to add GPIO device file.");
|
| return NULL;
|
| }
|
|
|
| memset(&event, 0, sizeof(struct epoll_event));
|
| event.events = EPOLLIN | EPOLLET;
|
| event.data.fd = socket_t[0];
|
| LOGE("threadFunction event.data.fd =[%d] ", event.data.fd);
|
|
|
| if (epoll_ctl(epoll_fd_t, EPOLL_CTL_ADD, event.data.fd, &event) == -1)
|
| {
|
| LOGE("Failed to add GPIO device file.");
|
| return NULL;
|
| }
|
| */
|
|
|
| #if defined(MBTK_SG_SUPPORT)
|
| fd_t = open("/dev/input/event1", O_RDONLY);
|
| LOGI("init pthread_event1");
|
| #else
|
| fd_t = open("/dev/input/event2", O_RDONLY);
|
| LOGI("init pthread_event2");
|
| #endif
|
|
|
| sleep_epoll_register(epoll_fd_t, fd_t);
|
| sleep_epoll_register(epoll_fd_t, socket_t[1]);
|
|
|
| while (true)
|
| {
|
| struct epoll_event events[2];
|
| struct epoll_event ev;
|
| int cmd = 0;
|
|
|
| int numEvents = epoll_wait(epoll_fd_t, events, 2, -1);
|
|
|
| for (i = 0; i < numEvents; ++i)
|
| {
|
| if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP))
|
| {
|
| LOGE("Error on GPIO device.");
|
| return NULL;
|
| }
|
| else if ((events[i].events & EPOLLIN) || (events[i].events & EPOLLET))
|
| {
|
| //handleInterrupt(events[i].data.fd);
|
| if (events[i].data.fd == socket_t[1])
|
| {
|
| memset(buf, 0, sizeof(buf));
|
| read(socket_t[1], buf, sizeof(buf));
|
| if (1 == atoi(buf))
|
| {
|
| if(close(fd_t) == 0)
|
| LOGI("close(fd_t)ing");
|
|
|
| sleep_epoll_deregister(epoll_fd_t, socket_t[1]);
|
| sleep_epoll_deregister(epoll_fd_t, fd_t);
|
| /*
|
| memset(&ev, 0, sizeof(struct epoll_event));
|
| ev.events = EPOLLIN | EPOLLET;
|
| ev.data.fd = socket_t[1];
|
| epoll_ctl( epoll_fd_t, EPOLL_CTL_DEL, ev.data.fd, &ev);
|
|
|
| memset(&ev, 0, sizeof(struct epoll_event));
|
| ev.events = EPOLLIN | EPOLLET;
|
| ev.data.fd = fd_t;
|
| epoll_ctl( epoll_fd_t, EPOLL_CTL_DEL, ev.data.fd, &ev);
|
| */
|
| LOGI("do pthread_exit");
|
| return NULL;
|
| }
|
| }
|
| else if (events[i].data.fd == fd_t)
|
| {
|
| LOGI("go pthread_event");
|
| memset(&ev_input, 0x00, size);
|
| read(fd_t, &ev_input, size);
|
| LOGI("ev_input type = %x, code = %x, value = %x", ev_input.type, ev_input.code,ev_input.value);
|
| #if defined(MBTK_SG_SUPPORT)
|
| if (ev_input.code == 2)
|
| {
|
| LOGI(">>>>ev_input.value = [%d]",ev_input.value);
|
| pinValue = (int)ev_input.value;
|
| edge_t = pinValue;
|
| lpm_init.wakehandle(edge_t);
|
| }
|
| #else
|
| if (ev_input.type == 4 && ev_input.code == 3)
|
| {
|
| LOGI(">>>>ev_input.value = [%d]",ev_input.value);
|
| pinValue = (int)ev_input.value;
|
| edge_t = pinValue;
|
| lpm_init.wakehandle(edge_t);
|
| }
|
| #endif
|
|
|
| }
|
| else
|
| {
|
| LOGE("Unknown events[i].data.fd = %d", events[i].data.fd);
|
| }
|
| }
|
| }
|
| }
|
| return NULL;
|
| }
|
|
|
| int qser_lpm_init(qser_lpm_Handler_t qser_lpm_handler, qser_pm_cfg_t *qser_lpm_cfg)
|
| {
|
| //UNUSED(qser_lpm_handler);
|
| //UNUSED(qser_lpm_cfg);
|
| if (socketpair( AF_LOCAL, SOCK_STREAM, 0, socket_t ) < 0 )
|
| {
|
| LOGE("[qser_lpm_init] could not create thread control socket pair: %s", strerror(errno));
|
|
|
| /*close the control socket pair && Retry again.*/
|
| if(socket_t[0] > 0)
|
| {
|
| close(socket_t[0] );
|
| socket_t[0] = -1;
|
| }
|
|
|
| if(socket_t[1] > 0)
|
| {
|
| close(socket_t[1] );
|
| socket_t[1] = -1;
|
| }
|
| return -1;
|
| }
|
| lpm_init.wakeupin.wakeupin_pin = qser_lpm_cfg->wakeupin.wakeupin_pin;
|
| LOGI(">>pin = %d",lpm_init.wakeupin.wakeupin_pin);
|
| lpm_init.wakeupin.wakeupin_edge = qser_lpm_cfg->wakeupin.wakeupin_edge;
|
| LOGI(">>edge = %d",lpm_init.wakeupin.wakeupin_edge);
|
| edge_t = qser_lpm_cfg->wakeupin.wakeupin_edge;//保留原始状态值 0 or 1
|
| lpm_init.wakehandle = qser_lpm_handler;
|
|
|
| pthread_attr_t thread_attr;
|
| pthread_attr_init(&thread_attr);
|
|
|
| if(pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED))
|
| {
|
| LOGE("pthread_attr_setdetachstate() fail");
|
| return -1;
|
| }
|
|
|
| if(pthread_create(&lpm_t, &thread_attr, threadFunction, NULL))
|
| //if(pthread_create(&lpm_t, NULL, threadFunction, NULL))
|
| {
|
| LOGE("qser_lpm_init can't create thread");
|
| return -1;
|
| }
|
|
|
| pthread_attr_destroy(&thread_attr);
|
|
|
| //if (edge_t != qser_lpm_cfg->wakeupin.wakeupin_edge)//说明有变化，并且和原来的值不相同
|
| //qser_lpm_handler(edge_t);
|
|
|
| return 0;
|
| }
|
|
|
| int qser_lpm_deinit(void)
|
| {
|
| char buf[4]={0};
|
|
|
| if (fd_t == -1)
|
| return 0;
|
|
|
| if (fd_t != -1)
|
| {
|
| //char cmd = 1;
|
| strcpy(buf, "1");
|
| void* dummy = NULL;
|
| write( socket_t[0], buf, sizeof(buf) );
|
| //pthread_join(lpm_t, &dummy);
|
|
|
| sleep(1);
|
| // close the control socket pair
|
| if(socket_t[0] > 0)
|
| {
|
| close(socket_t[0] );
|
| socket_t[0] = -1;
|
| }
|
| if(socket_t[1] > 0)
|
| {
|
| close(socket_t[1] );
|
| socket_t[1] = -1;
|
| }
|
|
|
| //重置还原
|
| fd_t = -1;
|
|
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| /*
|
| 例如AT*POWERIND=31，就相当于设置NETWORK、SIM、SMS、CS CALL、PS DATA变化时都不主动上报，
|
| 其中PS DATA目前暂时不支持，只是保留了这个标志位；
|
| AP power state: 1~31 means suspend, bitmap: bit0 - NETWORK;bit1 - SIM;bit2 - SMS;bit3 - CS CALL;bit4 - PS DATA
|
| 0 means resume all.
|
| 目标文件"/system/etc/powerind"
|
| 如果bit0-bit3都配置可以采用的值是1-15，如果是当前采用NETWORK SMS CALL 则值的取值是 1 4 8 5 9 12 13
|
|
|
| */
|
|
|
| int qser_whitelist_set(char* whitelish)
|
| {
|
| //UNUSED(whitelish);
|
| uint32 on = 0;
|
| int call_t, nw_t, data_t, sms_t, tmp;
|
|
|
| int len = strlen(whitelish);
|
|
|
| if (len != 4)
|
| {
|
| LOGE("whitelish num error num=[%d]",len);
|
| return -1;
|
| }
|
|
|
| tmp = atoi(whitelish);
|
|
|
| call_t = tmp/1000;
|
| nw_t = tmp%1000/100;
|
| data_t = tmp%1000%100/10;
|
| sms_t = tmp%1000%100%10;
|
|
|
| if (call_t == 1)
|
| call_Off = TRUE;
|
| else
|
| call_Off = FALSE;
|
|
|
| if (nw_t == 1)
|
| nw_off = TRUE;
|
| else
|
| nw_off = FALSE;
|
|
|
| if (data_t == 1)
|
| data_off = TRUE;
|
| else
|
| data_off = FALSE;
|
|
|
| if (sms_t == 1)
|
| sms_off = TRUE;
|
| else
|
| sms_off = FALSE;
|
|
|
| if (call_Off == FALSE && nw_off == FALSE && data_off == FALSE && sms_off == FALSE)
|
| {
|
| on = 29;//0000的情况,所有上报源都屏蔽，SIM的上报会一直被包含在内
|
| }
|
| else
|
| {
|
| if (call_Off == TRUE)
|
| call_t = 8;
|
| else
|
| call_t = 0;
|
|
|
| if (nw_off == TRUE)
|
| nw_t = 1;
|
| else
|
| nw_t = 0;
|
|
|
| if (data_off == TRUE)
|
| data_t = 16;
|
| else
|
| data_t = 0;
|
|
|
| if (sms_off == TRUE)
|
| sms_t = 4;
|
| else
|
| sms_t = 0;
|
|
|
| on = 29 - (call_t + nw_t + data_t + sms_t);//SIM的上报会一直被包含在内
|
| }
|
|
|
| if(whitelist_info_handle == NULL)
|
| {
|
| whitelist_info_handle = mbtk_info_handle_get();
|
| if(whitelist_info_handle)
|
| {
|
| LOGI("creat whitelist_info_handle is success");
|
| }
|
| else
|
| {
|
| LOGE("creat whitelist_info_handle is fail");
|
| return -1;
|
| }
|
| }
|
|
|
| int err = mbtk_wakeup_state_set(whitelist_info_handle, on);
|
| if(err)
|
| {
|
| LOGE("whitelist_info_handle Error : %d", err);
|
| return -1;
|
| }
|
|
|
| return 0;
|
| }
|
|
|
|
|
| int qser_whitelist_get(char* whitelish)
|
| {
|
| //UNUSED(whitelish);
|
| char list[10]={0};
|
| int call_t, nw_t, data_t, sms_t;
|
| int get_tmp;
|
|
|
| get_tmp = powerrind_get();
|
| //LOGI(">>>get_tmp: %d",get_tmp);
|
|
|
| //call 8 nw 1 data 16 sms 4 SIM的上报会一直被包含在内
|
| switch(get_tmp)
|
| {
|
| case 0:
|
| sprintf(list, "%d%d%d%d", 1, 1, 1, 1);
|
| break;
|
| case 8:
|
| sprintf(list, "%d%d%d%d", 0, 1, 1, 1);
|
| break;
|
| case 1:
|
| sprintf(list, "%d%d%d%d", 1, 0, 1, 1);
|
| break;
|
| case 16:
|
| sprintf(list, "%d%d%d%d", 1, 1, 0, 1);
|
| break;
|
| case 4:
|
| sprintf(list, "%d%d%d%d", 1, 1, 1, 0);
|
| break;
|
|
|
| case 9:
|
| sprintf(list, "%d%d%d%d", 0, 0, 1, 1);
|
| break;
|
| case 24:
|
| sprintf(list, "%d%d%d%d", 0, 1, 0, 1);
|
| break;
|
| case 12:
|
| sprintf(list, "%d%d%d%d", 0, 1, 1, 0);
|
| break;
|
| case 17:
|
| sprintf(list, "%d%d%d%d", 1, 0, 0, 1);
|
| break;
|
| case 5:
|
| sprintf(list, "%d%d%d%d", 1, 0, 1, 0);
|
| break;
|
| case 20:
|
| sprintf(list, "%d%d%d%d", 1, 1, 0, 0);
|
| break;
|
|
|
| case 25:
|
| sprintf(list, "%d%d%d%d", 0, 0, 0, 1);
|
| break;
|
| case 13:
|
| sprintf(list, "%d%d%d%d", 0, 0, 1, 0);
|
| break;
|
| case 28:
|
| sprintf(list, "%d%d%d%d", 0, 1, 0, 0);
|
| break;
|
| case 21:
|
| sprintf(list, "%d%d%d%d", 1, 0, 0, 0);
|
| break;
|
|
|
| case 29:
|
| sprintf(list, "%d%d%d%d", 0, 0, 0, 0);
|
| break;
|
|
|
| default :
|
| LOGE("qser_whitelist_get is error");
|
| break;
|
| }
|
|
|
| //LOGI(">>>get list: %s",list);
|
| strncpy(whitelish, list, strlen(list));
|
|
|
| if(whitelist_info_handle != NULL)
|
| {
|
| mbtk_info_handle_free(&whitelist_info_handle);
|
| LOGI("deinit whitelist_info_handle is succuess");
|
| }
|
|
|
| return 0;
|
| }
|
|
|
| static void* suspend_timer_thread_run(void* arg)
|
| { |
| struct epoll_event eventItems[EPOLL_SIZE_HINT]; |
| int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_SIZE_HINT, -1); |
| |
| int timerFd = -1; |
| int eventIndex = 0; |
| uint64_t readCounter; |
| |
| if (eventCount < 0) { |
| LOGE("Poll failed with an unexpected error: %s\n", strerror(errno));
|
| return -1; |
| } |
| |
| for (; eventIndex < eventCount; ++eventIndex) { |
| timerFd = eventItems[eventIndex].data.fd; |
| |
| int retRead = read(timerFd, &readCounter, sizeof(uint64_t)); |
| if (retRead < 0) { |
| LOGE("read %d failed...\n", timerFd);
|
| |
| continue; |
| } else { |
|
|
| g_sleep_timer_cb(NULL, 0);
|
| qser_autosuspend_enable(0);
|
| LOGI("suspend_timer_success\n");
|
| } |
| } |
| |
| return 0; |
| }
|
|
|
|
|
|
|
| int suspend_timer_timer_init(void)
|
| {
|
| int ret = -1;
|
|
|
|
|
| pthread_attr_t thread_attr;
|
| pthread_t net_led_thread_id;
|
| pthread_t status_led_thread_id;
|
| pthread_attr_init(&thread_attr);
|
| if(pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED))
|
| {
|
| LOGE("[suspend] pthread_attr_setdetachstate() fail.");
|
| return -1;
|
| }
|
|
|
| if(pthread_create(&net_led_thread_id, &thread_attr, suspend_timer_thread_run, NULL))
|
| {
|
| LOGE("[suspend] pthread_create() fail.");
|
| return -1;
|
| }
|
|
|
| pthread_attr_destroy(&thread_attr);
|
| return 0;
|
| }
|
|
|
|
|
| int qser_suspend_timer_set(int time, mbtk_info_callback_func cb)
|
| {
|
| mEpollFd = epoll_create(EPOLL_SIZE_HINT);
|
| |
| int fd = timerfd_create(CLOCK_BOOTTIME_ALARM, 0); |
| if (fd < 0) { |
| LOGE("Could not create timer fd: %s\n", strerror(errno));
|
| return 0; |
| } |
| |
| struct itimerspec timerSet; |
| timerSet.it_interval.tv_sec = 0; |
| timerSet.it_interval.tv_nsec = 0; |
| timerSet.it_value.tv_sec = time;
|
| timerSet.it_value.tv_nsec = 0; |
| if (timerfd_settime(fd, 0, &timerSet, NULL) != 0) { |
| LOGE("timerfd_settime failed: %s\n", strerror(errno));
|
| close(fd); |
| return 0; |
| } |
| |
| struct epoll_event eventItem; |
| memset(&eventItem, 0, sizeof(eventItem)); |
| eventItem.events = EPOLLIN | EPOLLET; |
| eventItem.data.fd = fd; |
| int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem); |
| if (result != 0) { |
| LOGE("Could not add timer fd(%d) to epoll instance: %s\n", fd, strerror(errno));
|
| } |
|
|
| qser_autosuspend_enable(1);
|
| g_sleep_timer_cb = cb;
|
| suspend_timer_timer_init();
|
|
|
|
|
| return 0;
|
| }
|
|
|
|
|