mbtk/libmbtk_factory/mbtk_power.c

#if 1
#include <fcntl.h>
#include <stdint.h>
#include <libubox/blobmsg_json.h>
#include <libubus.h>

#include "mbtk_power.h"
/****************************DEFINE***************************************/
#define MBTK_POWER_RESULT_FAIL -1
#define MBTK_POWER_RESULT_SUCCESS 0


#define MBTK_POWER_CLOSE_FAIL -1
#define MBTK_POWER_CLOSE_SUCCESS 0

/****************************DEFINE***************************************/

/****************************VARIABLE***************************************/
const struct blobmsg_policy mbtk_power_cb_policy1[] = {
    [0] = {
        .name = "event",
        .type = BLOBMSG_TYPE_INT32,
    },
};
/****************************VARIABLE***************************************/

/****************************FUNC***************************************/
static void mbtk_power_gnss_callback(struct ubus_request *req, int type, struct blob_attr *msg)
{
    UNUSED(type);

    struct blob_attr *tb[1];
    struct blob_attr *cur;
    unsigned int event;
    int *ubus_gnss_result = (int *)req->priv;
    int rc;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    rc = blobmsg_parse(mbtk_power_cb_policy1, 1, tb, blob_data(msg), blob_len(msg));
    if (rc < 0)
    {
        LOGE("[MBTK_POWER] blobmsg_parse fail.");
        //printf("blobmsg_parse fail\n");
        *ubus_gnss_result = MBTK_POWER_CLOSE_FAIL;
        return;
    }

    /*parse first parameter*/
    cur = tb[0];
    if (!cur)
    {
        LOGE("[MBTK_POWER] missing parameter.");
        //printf("missing parameter\n");
        *ubus_gnss_result = MBTK_POWER_CLOSE_FAIL;
        return;
    }

    event = blobmsg_get_u32(cur);
    LOGE("[MBTK_POWER] get event = [%d].", event);
    //printf("get event = [%d].\n", event);

#if defined(MBTK_PROJECT_T108)
    if(event != 0)
#else
    if(event != 7)
#endif
    {
        *ubus_gnss_result = MBTK_POWER_CLOSE_FAIL;
    }

    return ;
}

static int mbtk_power_ubus_uloop_init(struct ubus_context **ctx)
{
    int ret = -1;
    if(ctx == NULL)
    {
        LOGE("[MBTK_POWER] ctx is NULL");
        return MBTK_POWER_RESULT_FAIL;
    }
    
    ret = uloop_init();
    if(ret != 0)
    {
        LOGE("[MBTK_POWER] uloop_init fail.ret = [%d]", ret);
        return MBTK_POWER_RESULT_FAIL;
    }

    if(*ctx != NULL)
    {
        LOGE("[MBTK_POWER] mbtk_gnss_ctx not NULL.");
        return MBTK_POWER_RESULT_FAIL;
    }

    *ctx = ubus_connect(NULL);
    if( !(*ctx) )
    {
        LOGE("[MBTK_POWER] ubus_connect fail.");
        return MBTK_POWER_RESULT_FAIL;
    }

    ubus_add_uloop(*ctx);

    return MBTK_POWER_RESULT_SUCCESS;
}

static int mbtk_power_ubus_uloop_deinit(struct ubus_context *ctx)
{
    if(ctx != NULL)
    {
        ubus_free(ctx);
        ctx = NULL;
    }

    uloop_done();

    return MBTK_POWER_RESULT_SUCCESS;
}

static int mbtk_power_invoke_reply_data_cb(const char *service, const char *method, struct blob_attr *msg,
                         ubus_data_handler_t cb, void *cb_param, int timeout, struct ubus_context *ctx)
{
	int rc = -1;
	uint32_t id;
	struct ubus_request req;

	/* Look up the target object id by the object path */
    rc = ubus_lookup_id(ctx, service, &id);
	if(rc)
    {
        LOGE("[MBTK_POWER] ubus_lookup_id fail.rc = [%d]", rc);
		return MBTK_POWER_RESULT_FAIL;
    }

	rc = ubus_invoke(ctx, id, method, msg, cb, cb_param, timeout);
    if(rc)
    {
        LOGE("[MBTK_POWER] ubus_invoke fail.rc = [%d]", rc);
		return MBTK_POWER_RESULT_FAIL;
    }
	return MBTK_POWER_RESULT_SUCCESS;
}


static int mbtk_power_gnss_close(void)
{
    int ret = 0;
    int ubus_gnss_result = MBTK_POWER_CLOSE_SUCCESS;
    struct ubus_context *mbtk_power_ctx = NULL;
    ret = mbtk_power_ubus_uloop_init(&mbtk_power_ctx);
    if(ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_gnss_ubus_uloop_init() fail.");
        return MBTK_POWER_CLOSE_FAIL;
    }

    struct blob_buf outBlob;
    memset(&outBlob, 0, sizeof(outBlob));

    blob_buf_init(&outBlob, 0);
    blobmsg_add_u32(&outBlob, "gnss_init_param", 0);
#if defined(MBTK_PROJECT_T108)
    ret = mbtk_power_invoke_reply_data_cb("mbtk_gnss", "gnss_deinit", outBlob.head,
                                    (ubus_data_handler_t *)mbtk_power_gnss_callback, &ubus_gnss_result, 8000, mbtk_power_ctx);
#else
    ret = mbtk_power_invoke_reply_data_cb("gps", "gnss_deinit", outBlob.head,
                                    (ubus_data_handler_t *)mbtk_power_gnss_callback, &ubus_gnss_result, 8000, mbtk_power_ctx);
#endif
    blob_buf_free(&outBlob);
    
    if (ret != 0)
    {
        LOGE("[MBTK_POWER] mbtk_invoke_reply_data_cb() fail.");
        return MBTK_POWER_CLOSE_FAIL;
    }

    if(ubus_gnss_result != MBTK_POWER_CLOSE_SUCCESS)
    {
        return MBTK_POWER_CLOSE_FAIL;
    }

    mbtk_power_ubus_uloop_deinit(mbtk_power_ctx);
    return MBTK_POWER_CLOSE_SUCCESS;
}

static int gpio_direct_set(char *value,int gpio)
{
    char buffer[50]= {0};
    int file =-1;
    int result =-1;

    memset(buffer,0,50);
    sprintf(buffer,"/sys/class/gpio/gpio%d/direction", gpio);
    file = open(buffer, O_WRONLY);
    if(file == -1)
    {
        LOGE("[MBTK_POWER] Open gpio[%d] direct fail.", gpio);
        return MBTK_POWER_RESULT_FAIL;
    }

    result = write(file,value,strlen(value));
    if(result != strlen(value))
    {
        LOGE("[MBTK_POWER] Set gpio[%d] direct fail.", gpio);
        close(file);
        return MBTK_POWER_RESULT_FAIL;
    }
    close(file);

    return MBTK_POWER_RESULT_SUCCESS;
}

static int gpio_value_set(int value, int gpio)
{
    char buffer[50]= {0};
    int file =-1;
    int result =-1;

    memset(buffer,0,50);
    sprintf(buffer,"/sys/class/gpio/gpio%d/value", gpio);
    file = open(buffer,O_WRONLY);
    if(file == -1)
    {
        LOGE("[MBTK_POWER] Open gpio[%d] value fail.", gpio);
        return MBTK_POWER_RESULT_FAIL;
    }
    if(value == 0) {
        result = write(file,"0",1);
    } else {
        result = write(file,"1",1);
    }
    if(result != 1)
    {
        LOGE("[MBTK_POWER] Set gpio[%d] value fail.", gpio);
        close(file);
        return MBTK_POWER_RESULT_FAIL;
    }
    close(file);

    return MBTK_POWER_RESULT_SUCCESS;
}

//type:0 value 0
//type:1 value 1
//type:2 direction "out"
//type:3 direction "in"

static int one_gpio_export(int gpio, int type)
{
    int index=0;
    int file=-1;
    int file1=-1;
    int result =-1;
    char pin_index_buffer[5]= {0};
    char buffer[50]= {0};
    int ret =0;

    file = open("/sys/class/gpio/export",O_WRONLY);
    if(file == -1)
    {
        LOGE("[MBTK_POWER] Open gpio export file fail.");
        return MBTK_POWER_RESULT_FAIL;
    }

    memset(buffer,0,50);
    sprintf(buffer,"/sys/class/gpio/gpio%d", gpio);
    file1 = open(buffer,O_RDONLY);
    if(file1 != -1)
    {
        //file is created
        close(file1);
    }
    else
    { // create gpio
        memset(pin_index_buffer,0,5);
        sprintf(pin_index_buffer,"%d",gpio);
        result = write(file,pin_index_buffer,strlen(pin_index_buffer));
        if(result < 0)
        {
            LOGE("[MBTK_POWER] Gpio[%d] export fail.", gpio);
            return MBTK_POWER_RESULT_FAIL;
        }
    }

    close(file);


    switch(type)
    {
        case 0 :
        {
            ret = gpio_value_set(0, gpio);
            break;
        }
        case 1:
        {
            ret = gpio_value_set(1, gpio);
            break;
        }
        case 2:
        {
            ret = gpio_direct_set("out", gpio);
            break;
        }
        case 3:
        {
            ret = gpio_direct_set("in", gpio);
            break;
        }
        default:
        {
            break;
        }
    }


    return ret;
}

/****************************FUNC***************************************/

/****************************API***************************************/
#if defined(MBTK_PROJECT_T108)
int mbtk_system_sleep(void)
{
    int ubus_ret = 0;
    
    ubus_ret = mbtk_power_gnss_close();
    if(ubus_ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_power_gnss_close() fail.");
        return MBTK_POWER_RESULT_GNSS_CLOSE_FAIL;
    }

    // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep
    // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl

    if(!access("/sys/power/autosleep", W_OK))
    {
        system("echo mem > /sys/power/autosleep");
    }
    else
    {
        LOGE("[MBTK_POWER] /sys/power/autosleep can not write.");
        //printf("/sys/power/autosleep can not write.");
        return MBTK_POWER_RESULT_NO_SLEEP_NODE;
    }

    return MBTK_POWER_RESULT_SUCCESS;
}

#elif defined(MBTK_PROJECT_L508_X6)
int mbtk_system_sleep(void)
{
    int ubus_ret = 0;
    
    ubus_ret = mbtk_power_gnss_close();
    if(ubus_ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_power_gnss_close() fail.");
        return MBTK_POWER_RESULT_GNSS_CLOSE_FAIL;
    }

    // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep
    // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl
    //close Ldo6
    system("i2cset -y -f 2 0x31 0x18 0x0f");
    //GPS_WAKE_HOST to GPIO
    system("hwacc w 0xd401e198 0x1040");
    //HOST_WAKE_GPS to GPIO
    //system("hwacc w 0xd401e0c0 0x1040");
    //gpio34 to GPIO
#if 1
    system("hwacc w 0xd401e164 0x1040");
	system("hwacc w 0xd401e166 0x1040");
	system("hwacc w 0xd401e1b4 0x1040");
	
    system("hwacc w 0xd401e2ec 0xa441");
    system("hwacc w 0xd401e2f0 0xa441");
    system("hwacc w 0xd401e2f4 0xa441");
    system("hwacc w 0xd401e2f8 0xa441");
    system("hwacc w 0xd401e2fc 0xa441");
    system("hwacc w 0xd401e300 0xa441");
#endif
    one_gpio_export(117, 2);
    one_gpio_export(117, 0);

    one_gpio_export(119, 2);
    one_gpio_export(119, 0);

    one_gpio_export(127, 2);
    one_gpio_export(127, 0);

    one_gpio_export(33, 2);
    one_gpio_export(33, 0);

    one_gpio_export(34, 2);
    one_gpio_export(34, 0);

    one_gpio_export(54, 2);
    one_gpio_export(54, 0);
    
    one_gpio_export(21, 2);
    one_gpio_export(21, 0);
    
    one_gpio_export(118, 2);
    one_gpio_export(118, 0);
    
    if(!access("/sys/power/autosleep", W_OK))
    {
        system("echo mem > /sys/power/autosleep");
    }
    else
    {
        LOGE("[MBTK_POWER] /sys/power/autosleep can not write.");
        //printf("/sys/power/autosleep can not write.");
        return MBTK_POWER_RESULT_NO_SLEEP_NODE;
    }

    return MBTK_POWER_RESULT_SUCCESS;
}

#elif defined(MBTK_PROJECT_L509)
int mbtk_system_sleep(void)
{
    int ubus_ret = 0;
    
    ubus_ret = mbtk_power_gnss_close();
    if(ubus_ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_power_gnss_close() fail.");
        return MBTK_POWER_RESULT_GNSS_CLOSE_FAIL;
    }

    // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep
    // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl

    one_gpio_export(120, 2);
    one_gpio_export(120, 0);

    one_gpio_export(21, 2);
    one_gpio_export(21, 0);
    
    one_gpio_export(118, 2);
    one_gpio_export(118, 0);
    
    if(!access("/sys/power/autosleep", W_OK))
    {
        system("echo mem > /sys/power/autosleep");
    }
    else
    {
        LOGE("[MBTK_POWER] /sys/power/autosleep can not write.");
        //printf("/sys/power/autosleep can not write.");
        return MBTK_POWER_RESULT_NO_SLEEP_NODE;
    }

    return MBTK_POWER_RESULT_SUCCESS;
}

#elif defined(MBTK_PROJECT_L508)
int mbtk_system_sleep(void)
{
    int ubus_ret = 0;
    
    ubus_ret = mbtk_power_gnss_close();
    if(ubus_ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_power_gnss_close() fail.");
        return MBTK_POWER_RESULT_GNSS_CLOSE_FAIL;
    }

    // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep
    // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl

    one_gpio_export(119, 2);
    one_gpio_export(119, 0);

    one_gpio_export(21, 2);
    one_gpio_export(21, 0);
    
    one_gpio_export(118, 2);
    one_gpio_export(118, 0);
    
    if(!access("/sys/power/autosleep", W_OK))
    {
        system("echo mem > /sys/power/autosleep");
    }
    else
    {
        LOGE("[MBTK_POWER] /sys/power/autosleep can not write.");
        //printf("/sys/power/autosleep can not write.");
        return MBTK_POWER_RESULT_NO_SLEEP_NODE;
    }

    return MBTK_POWER_RESULT_SUCCESS;
}

#elif defined(MBTK_PROJECT_PN1803)
int mbtk_system_sleep(void)
{
    int ubus_ret = 0;
    
    ubus_ret = mbtk_power_gnss_close();
    if(ubus_ret < 0)
    {
        LOGE("[MBTK_POWER] mbtk_power_gnss_close() fail.");
        return MBTK_POWER_RESULT_GNSS_CLOSE_FAIL;
    }

    // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep
    // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl

    one_gpio_export(119, 2);
    one_gpio_export(119, 0);

    one_gpio_export(21, 2);
    one_gpio_export(21, 0);
    
    one_gpio_export(118, 2);
    one_gpio_export(118, 0);
    
    if(!access("/sys/power/autosleep", W_OK))
    {
        system("echo mem > /sys/power/autosleep");
    }
    else
    {
        LOGE("[MBTK_POWER] /sys/power/autosleep can not write.");
        //printf("/sys/power/autosleep can not write.");
        return MBTK_POWER_RESULT_NO_SLEEP_NODE;
    }

    return MBTK_POWER_RESULT_SUCCESS;
}

#else
int mbtk_system_sleep(void)
{
    return MBTK_POWER_RESULT_SUCCESS;
}
#endif
/****************************API***************************************/
#endif