mbtk/lynq_lib/src/lynq_sleep.c

#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 "mbtk_type.h"
#include "mbtk_log.h"
#include "mbtk_info_api.h"

/*
该模块是系统睡眠，锁存在的时候系统无法休眠
验证是否在睡眠状态，则需要测试功耗
电源管理原则，只要有一个wakelock锁存在，系统就不会进入Suspend状态
所以名字可以随便取，表示需要这样的一个锁，所以系统就不会进行睡眠
*/
#define MTBK_POWERIND           "/system/etc/powerind"      //1806
//#define MTBK_POWERIND           "/etc/powerind"             //1803

static bool call_Off  = FALSE;
static bool nw_off = FALSE;
static bool sms_off = FALSE;
static bool data_off = FALSE;

pthread_t lpm_t;
static int edge_t = 0;

typedef struct{
    qser_lpm_wakeupin_data_t wakeupin;
    qser_lpm_wakeupout_data_t wakeupout;
}lynq_wake_t;

static lynq_wake_t lpm_init;


static int powerrind_get()
{
    char buffer[50];
    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;
}



typedef struct
{
    int fd;
    char name[128];
} lock_name;

lock_name lynq_lock_name[512]={0};
static bool autosleep_enable = FALSE;

static mbtk_info_handle_t* whitelist_info_handle = NULL;


int qser_autosuspend_enable(char enable)
{
    //UNUSED(enable);

    if(enable == 1)
    {
        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(!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;
        }
    }

    return 0;
}

int qser_wakelock_create(const char* name , size_t len)
{
    //UNUSED(name);
    //UNUSED(len);

    if(!autosleep_enable) {
        LOGE("Autosleep not enable.");
        return -1;
    }

    if(name != NULL && len < 127)
    {
        int i;
        for(i=0;i<512;i++)
        {
            if(lynq_lock_name[i].fd == 0)
                break;
        }
        memcpy(lynq_lock_name[i].name, name, strlen(name)+1);
        lynq_lock_name[i].fd = i;
        return lynq_lock_name[i].fd;
    }
    else
        return -1;

    return 0;
}

int qser_wakelock_lock(int fd)
{
    //UNUSED(fd);

    if(!autosleep_enable) {
        LOGE("Autosleep not enable.");
        return -1;
    }

    int i;
    for(i=0;i<512;i++)
    {
        if(lynq_lock_name[i].fd == fd)
            break;
    }
    if(i == 512)
        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
    {
        printf("/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=0;i<512;i++)
    {
        if(lynq_lock_name[i].fd == fd)
            break;
    }
    if(i == 512)
        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
    {
        printf("/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=0;i<512;i++)
    {
        if(lynq_lock_name[i].fd == fd)
        break;
    }
    if(i == 512)
        return -1;
    else
    {
        lynq_lock_name[i].fd = 0;
        memset(lynq_lock_name[i].name, 0, 128);
        return 0;
    }

    return 0;
}

void *threadFunction(void *arg)
{
    int pinValue;
    

    edge_t = pinValue;
    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);

    lpm_init.wakeupin.wakeupin_pin = qser_lpm_cfg->wakeupin.wakeupin_pin;
    printf(">>pin = %d",lpm_init.wakeupin.wakeupin_pin);
    lpm_init.wakeupin.wakeupin_edge = qser_lpm_cfg->wakeupin.wakeupin_edge;
    printf(">>edge = %d",lpm_init.wakeupin.wakeupin_edge);
    edge_t = qser_lpm_cfg->wakeupin.wakeupin_edge;//保留原始状态值 0 or 1

    //pthread_attr_t thread_attr;
    //pthread_attr_init(&thread_attr);
    /*
    if(pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED))
    {
        printf("pthread_attr_setdetachstate() fail\n");
        return -1;
    }
    */
    //if(pthread_create(&lpm_t, &thread_attr, threadFunction, NULL))
    if(pthread_create(&lpm_t, NULL, threadFunction, NULL))
    {
        printf("qser_lpm_init can't create thread\n");
        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)
{

    if(pthread_cancel(lpm_t) != 0)
    {
        printf("qser_lpm_deinit pthread_cancel err\n");
        return -1;
    }

    if(pthread_join(lpm_t,NULL) != 0)
    {
        printf("qser_lpm_deinit pthread_join err\n");
        return -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


白名单的状态由四位数字组成，第一位代表是否屏蔽电话唤醒，第二
位代表是否屏蔽网络注册状态唤醒，第三位代表是否屏蔽数据业务唤
醒，第四位代表是否屏蔽短信唤醒。其中 1 代表屏蔽，其他不会屏
蔽。
第一位：1：打开电话唤醒，其他：屏蔽电话唤醒
第二位：1：打开网络注册状态唤醒，其他：屏蔽网络注册状态唤醒
第三位：1：打开数据业务唤醒，其他：屏蔽数据业务唤醒
第四位：1：打开短信唤醒，其他屏蔽短信唤醒
当四位都不为 1 时（比如默认的状态：0000），则代表白名单为空，
所有唤醒都不会屏蔽。

从左往右判断

*/

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)
    {
        printf("whitelish num error num=[%d]\n",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 = 2;//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 = 31 - (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)
        {
            printf("creat whitelist_info_handle is success\n");
        }
        else
        {
            printf("creat whitelist_info_handle is fail\n");
            return -1;
        }
    }

    int err = mbtk_wakeup_state_set(whitelist_info_handle, on);
    if(err)
    {
        printf("Error : %d\n", err);
        return -1;
    }
    else
    {
        printf("wakeup set success.\n");
    }


    return 0;
}


int qser_whitelist_get(char* whitelish)
{
    //UNUSED(whitelish);
    char list[10]={0};
    int call_t, nw_t, data_t, sms_t;

    if (call_Off == TRUE)
        call_t = 1;
    else
        call_t = 0;
    
    if (nw_off == TRUE)
        nw_t = 1;
    else
        nw_t = 0;
    
    if (data_off == TRUE)
        data_t = 1;
    else
        data_t = 0;
    
    if (sms_off == TRUE)
        sms_t = 1;
    else
        sms_t = 0;

    sprintf(list, "%d%d%d%d", call_t, nw_t, data_t, sms_t);
    //printf(">>>whitelist: %s\n",list);
    strncpy(whitelish, list, strlen(list));

    if(whitelist_info_handle != NULL)
    {
        mbtk_info_handle_free(&whitelist_info_handle);
        printf("deinit whitelist_info_handle is succuess\n");
    }

    return 0;
}