/****************************************************************************
 *
 * Copy right:   2024-, Copyrigths of EigenComm Ltd.
 * File name:    api_scr.c
 * Description:  ec7xx openHAL screen entry source file
 * History:      Rev1.0   2024-02-02
 *
 ****************************************************************************/
#ifdef FEATURE_HAL_SCREEN_ENABLE
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include DEBUG_LOG_HEADER_FILE
#include "devicemanager.h"
#include "api_comm.h"
#include "api_scr.h"

#include "osasys.h"
#include "bsp.h"
#include "bsp_custom.h"
#include "lspi.h"
#include "lcdDrv.h"
#include "lcdComm.h"
#include "timer.h"
#define LCD_REG_STAS_MASK           (0x00000004)

#define EPAT_LOG(subId, debugLevel, format, ...)  \
    ECPLAT_PRINTF(UNILOG_OPEN_HAL, subId, debugLevel, format, ##__VA_ARGS__)

#include "lcdDrv.h"
lcdDrvFunc_t* lcdDev = NULL;

extern lspiRes_t *lspiResGet(void);

static uint32_t s_scrUsrIdList[EC_SCR_INDEX_LIMIT] = {0};
static uint16_t s_scrUsrIdSeed[EC_SCR_INDEX_LIMIT] = {0};
static DmaDescriptor_t __ALIGNED(16) descriptor[40];
static osEventFlagsId_t scrEventFlags = NULL;
static osMutexId_t lspiMutex = NULL;
static api_scr_inf screen_device;
static int32_t dispDmaCh = 0;
static dma_data_t dmaData;
/**
  \fn
  \brief
  \return
*/
static IsrFunc user_spi_cb = NULL;
static void spiEventHandler(void)
{
    LSPI2->STAS |= (1<<31);
    uint32_t status = (LSPI2->STAS & ~(LCD_REG_STAS_MASK));
    if(status){
        EPAT_LOG(spiEventHandler, P_ERROR, "%d,0x%X",osKernelGetTickCount(),status);
    }
    else if(user_spi_cb != NULL){
        user_spi_cb(LSPI2->STAS);
    }
}
static IsrFunc user_dma_cb = NULL;
static void dmaEventHandler(uint32_t event)
{
    if(event == DMA_EVENT_END){
        if(user_dma_cb != NULL) user_dma_cb(event);
    }
    else {
        EPAT_LOG(dmaEventHandler, P_ERROR, "0x%X",event);
    }
}
/**
  \fn
  \brief
  \return
*/
static uint32_t usrId_to_index(uint32_t usrId)
{ 
    uint32_t index = (uint32_t)(usrId & OPEN_HAL_PORT_MUSK); 
    if(index == (s_scrUsrIdList[index] & OPEN_HAL_PORT_MUSK))
    {
        return index;
    }
    return EC_SCR_INDEX_LIMIT;
}
/**
  \fn
  \brief
  \return
*/
static int32_t spiSend(lspiRes_t *lspi,void *dataOut,uint32_t num)
{
    uint8_t     *dataListIndex  = &(lspi->info->prePareSendInfo.dataListIndex);
    uint8_t     *dataLen        = &(lspi->info->prePareSendInfo.dataLen);
    uint32_t    *tmp            = &(lspi->info->prePareSendInfo.tmp);
    uint32_t    *dataList       = lspi->info->prePareSendInfo.dataList;
    if (*dataLen % 4 != 0){
        dataList[*dataListIndex] = *tmp;
        *dataListIndex += 1;
    }
    for (int i = 0; i < *dataListIndex; i++){
        lspi->reg->TFIFO = dataList[i];
    }
    lspi->reg->LSPI_CCTRL = 1 | *dataLen<<8;
    // wait until finish
    while (!lspi->reg->LSPI_STAT);
    memset(dataList, 0, *dataListIndex * 4);
    lspi->info->prePareSendInfo.dataListIndex = 0;
    lspi->info->prePareSendInfo.tmp = 0;
    lspi->info->prePareSendInfo.trans = 0;
    lspi->info->prePareSendInfo.dataLen = 0;
    return ARM_DRIVER_OK;
}
/**
  \fn
  \brief
  \return
*/
static void spiData(lspiRes_t *lspi,uint8_t data)
{
    uint8_t *dataListIndex  = &(lspi->info->prePareSendInfo.dataListIndex);
    uint8_t *trans  = &(lspi->info->prePareSendInfo.trans);
    uint8_t *dataLen    = &(lspi->info->prePareSendInfo.dataLen);
    uint32_t    *tmp    = &(lspi->info->prePareSendInfo.tmp);
    uint32_t    *dataList   = lspi->info->prePareSendInfo.dataList;
    *tmp |= data << *trans;
    *dataLen += 1;
    *trans += 8;
    if (*trans == 32) {
        dataList[*dataListIndex] = *tmp;
        *dataListIndex += 1;
        *trans = 0;
        *tmp = 0;
    }
}
/**
  \fn
  \brief
  \return
*/
static int dispConfig(uint16_t *regs)
{
    if(regs[0] == 0xFFFF || (regs[0] & 0xC000) == 0){
        return 0;
    }
    uint16_t num = (regs[0] & 0x3FFF);
    lspiRes_t *lspi = lspiResGet();
    uint8_t value = 0;
    int cmd_len = 0;
    for (uint16_t i = 1; i <= num; i++){
        uint16_t cmd = regs[i];
        switch(((cmd >> 8) & 0xFF)) {
            case OS_DELAY:
                osDelay(cmd & 0xFF);    //ms
                break;
            case HAL_DELAY:
                delay_us(cmd & 0xFF);   //us
                break;
            case LCD_CMD_WRITE:
                if (cmd_len) {
                    spiSend(lspi,NULL,0);
                }else if (i!=0) {
                    spiData(lspi,0);
                    spiSend(lspi,NULL,0);
                }
                lspi->reg->LSPI_CADDR = (uint8_t)(cmd & 0xFF);
                cmd_len = 0;
                break;
            case LCD_CMD_CONTINUE:
                spiData(lspi,(cmd & 0xFF));
                cmd_len++;
                break;
            case INF_COLOROUT:
                lspiCtrl.colorModeOut = (uint8_t)(cmd & 0xFF);
                lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                break;
            case INF_BUS_MCLK:
                value = (uint8_t)(cmd & 0xFF);
                if(value<52 && value>1){
                    uint8_t div = (uint8_t)(102/(value+1));
                    *(uint32_t*)0x4f00007c = div << 16U; //1 = 51MHz
                }
                break;
            case INF_DATALANE:
                value = (uint8_t)(cmd & 0xFF);
                #ifdef TYPE_EC718M
                if(value>1){
                    lspiCtrl.dspiEn = 1;
                }
                else lspiCtrl.dspiEn = 0;
                #else
                if(value>1){
                    lspiCtrl.data2Lane = 1;
                }
                else lspiCtrl.data2Lane = 0;
                #endif
                lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                break;
            case INF_BUS_TYPE:
                switch((uint8_t)(cmd & 0xFF)) {
                    case INF_SPI_3W_I:
                        #ifdef TYPE_EC718M
                        lspiCmdAddr.busType = 0;
                        #else
                        lspiCtrl.busType = 0;
                        #endif
                        lspiCtrl.line4 = 0;
                        lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                        break;
                    case INF_SPI_3W_II:
                        #ifdef TYPE_EC718M
                        lspiCmdAddr.busType = 1;
                        #else
                        lspiCtrl.busType = 1;
                        #endif
                        lspiCtrl.line4 = 0;
                        lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                        break;
                    case INF_SPI_4W_I:
                        #ifdef TYPE_EC718M
                        lspiCmdAddr.busType = 0;
                        #else
                        lspiCtrl.busType = 0;
                        #endif
                        lspiCtrl.line4 = 1;
                        lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                        break; 
                    case INF_SPI_4W_II:
                        #ifdef TYPE_EC718M
                        lspiCmdAddr.busType = 1;
                        #else
                        lspiCtrl.busType = 1;
                        #endif
                        lspiCtrl.line4 = 1;
                        lspi->reg->LSPI_CTRL = *(uint32_t*)&lspiCtrl;
                        break; 
                }
            default:
                if(cmd != 0xFFFF && (cmd & 0xC000) && (cmd & 0xC000)< 0xC000){
                    if((cmd & 0xC000) == 0x8000) lspiInfo.frameHeight = (cmd & 0x3FFF);
                    else if((cmd & 0xC000) == 0x4000) lspiInfo.frameWidth = (cmd & 0x3FFF);
                    lspi->reg->LSPFINFO = *(uint32_t*)&lspiInfo;
                }
                break;
        }
    }
    if(cmd_len==0) spiData(lspi,0);
    spiSend(lspi,NULL,0);
    return num;
}
/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_query(uint32_t usrId)
{
    uint32_t index = usrId_to_index(usrId);
    if(index >= EC_SCR_INDEX_START && index < EC_SCR_INDEX_LIMIT)
    {
        if(s_scrUsrIdList[index] == OPEN_HAL_STAT_UNUSED)
        {
            return OPEN_HAL_FREE;
        }
        else if(s_scrUsrIdList[index] & OPEN_HAL_STAT_MUSK)
        {
            return OPEN_HAL_USED;
        }
        else{
            return OPEN_HAL_IDLE;
        }
    }
    return OPEN_HAL_NONE;
}
/**
  \fn
  \brief
  \return
*/
static uint32_t scr_set_idle(uint32_t index)
{
    uint32_t ret = 0;
    if(s_scrUsrIdList[index] == OPEN_HAL_STAT_UNUSED){
        s_scrUsrIdList[index] = index;
        s_scrUsrIdSeed[index] ++;
        s_scrUsrIdList[index] |= (uint32_t)(s_scrUsrIdSeed[index] << 16);
        ret = s_scrUsrIdList[index];
    }
    else if(s_scrUsrIdList[index] & OPEN_HAL_STAT_MUSK){
        s_scrUsrIdList[index] &= ~(OPEN_HAL_STAT_MUSK);
        ret = s_scrUsrIdList[index];
    }
    return ret;
}
/**
  \fn
  \brief
  \return
*/
static uint32_t scr_set_used(uint32_t usrId)
{
    api_ret_t stat = api_scr_query(usrId);
    if(stat != OPEN_HAL_IDLE){
        return 0;
    }
    uint32_t index = usrId_to_index(usrId);
    s_scrUsrIdList[index] |= OPEN_HAL_STAT_MUSK;
    return 1;
}
/**
  \fn
  \brief
  \return
*/
static uint32_t scr_set_free(uint32_t index)
{
    if(index >= EC_SCR_INDEX_START && index < EC_SCR_INDEX_LIMIT)
    {
        s_scrUsrIdList[index] = OPEN_HAL_STAT_UNUSED;
        return 1;
    }
    return 0;
}
/**
  \fn          
  \brief     LCD上电初始化接口，用于默认创建 
  \return
*/
int api_scr_startup(void* para)
{
    for(int i=EC_SCR_INDEX_START;i<EC_SCR_INDEX_LIMIT;i++)
    {
        scr_set_free(i);
    }
}
/**
  \fn
  \brief
  \return
*/
static uint32_t dispArray(dma_data_t *array, uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, void* address)
{
    uint8_t ret = 0;
    array->cmds[ret++] = 0xC000;
    array->cmds[ret++] = 0x022a;
    array->cmds[ret++] = (sx>>8) + 0x0300;
    array->cmds[ret++] = (sx & 0x00ff) + 0x0300;
    array->cmds[ret++] = (ex>>8) + 0x0300;
    array->cmds[ret++] = (ex & 0x00ff) + 0x0300;
    array->cmds[ret++] = 0x022b;
    array->cmds[ret++] = (sy>>8) + 0x0300;
    array->cmds[ret++] = (sy & 0x00ff) + 0x0300;
    array->cmds[ret++] = (ey>>8) + 0x0300;
    array->cmds[ret++] = (ey & 0x00ff) + 0x0300;
    array->cmds[ret++] = 0x022c;
    array->cmds[0] |= (ret-1);
    array->totalBytes = (ey-sy+1)*(ex-sx+1)*2;
    #ifdef TYPE_EC718M
    if(lspiCtrl.dspiEn){
        array->dataLen = (array->totalBytes)/2;
    }
    #else
    if(lspiCtrl.data2Lane){
        array->dataLen = (array->totalBytes)/2;
    }
    #endif
    else array->dataLen = (array->totalBytes);
    if(address){
        array->data = address;
    }
    array->dmaTrans.sourceAddress = array->data;
    array->dmaTrans.targetAddress = (void *)&(LSPI2->TFIFO);
    array->dmaTrans.flowControl = DMA_FLOW_CONTROL_TARGET;
    array->dmaTrans.addressIncrement = DMA_ADDRESS_INCREMENT_SOURCE;
    array->dmaTrans.dataWidth = DMA_DATA_WIDTH_FOUR_BYTES;
    array->dmaTrans.burstSize = DMA_BURST_32_BYTES;

    uint32_t res = array->totalBytes;
    if(array->totalBytes%4) res += (4-(array->totalBytes)%4);
    uint32_t patch = DMA_BULK_NUM - res%DMA_BULK_NUM;
    int cnt = (res+patch)/DMA_BULK_NUM;
    uint32_t package = DMA_BULK_NUM;
    if(patch%cnt == 0) {
        package -= (patch / cnt);
        array->dmaTrans.totalLength = package;  
        DMA_buildDescriptorChain(descriptor, &(array->dmaTrans), cnt, true, true, true);
    } else {
        cnt -= 1;
        res -= cnt * DMA_BULK_NUM;
        array->dmaTrans.totalLength = res;
        DMA_buildDescriptorChain(descriptor, &(array->dmaTrans), 1, false, false, false);
        array->dmaTrans.sourceAddress = (void *)(array->data) + res;
        array->dmaTrans.totalLength = DMA_BULK_NUM;
        DMA_buildDescriptorChain(descriptor+1, &(array->dmaTrans), cnt, true, true, true);
    }
    return array->totalBytes;
}
/**
  \fn
  \brief
  \return
*/
static int dispTrans(dma_data_t *array,uint32_t timeout)
{
    lspiRes_t *lspi = lspiResGet();
    dispConfig(array->cmds);
    lspiDmaCtrl.txDmaReqEn = 1;
    lspi->reg->DMACTL = *(uint32_t*)&lspiDmaCtrl;
    lspiCmdCtrl.wrRdn = 1;
    lspiCmdCtrl.ramWr = 1;
    lspiCmdCtrl.dataLen = array->dataLen;
    lspi->reg->LSPI_CCTRL = *(uint32_t*)&lspiCmdCtrl;
    DMA_loadChannelDescriptorAndRun(DMA_INSTANCE_MP, dispDmaCh, descriptor);
    EPAT_LOG(dispTran, P_INFO, "%d,%d",dispDmaCh,lspiCmdCtrl.dataLen);
}
/**
  \fn
  \brief
  \return
*/
static uint32_t api_scr_fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, void* buf, uint32_t timeout)
{
    if(lspiMutex == NULL) return 0;
    if (osMutexAcquire(lspiMutex, timeout) == osOK)
    {
        dispArray(&dmaData, sx, sy, ex, ey, buf);
        dispTrans(&dmaData, timeout);
        osMutexRelease(lspiMutex);
    }
}
/**
  \fn
  \brief
  \return
*/
api_scr_infp api_scr_default(screenSupportList_e type)
{
    screen_device.clockDiv = 1U;
    lspiCtrl.datSrc = 1;
    lspiCtrl.enable = 1;
    lspiCtrl.colorModeIn = 3;   // RGB565
    lspiCtrl.colorModeOut = 1;  // RGB565
    screen_device.spiCtrl = *(uint32_t*)&lspiCtrl;
    lspiIntCtrl.lspiRamWrEndEn = 1;
    screen_device.intCtrl = *(uint32_t*)&lspiIntCtrl;
    lspiDataFmt.wordSize = 31;
    lspiDataFmt.txPack = 0;
    screen_device.dataFmt = *(uint32_t*)&lspiDataFmt;
    screen_device.fill = api_scr_fill;
    screen_device.dmaISR = NULL;
    screen_device.spiISR = NULL;
    switch(type)
    {
        case HAL_SCR_ST7789:
            break;
        case HAL_SCR_AXS15231:
            break;
        case HAL_SCR_ST77922:
            break;
        default:
            EPAT_LOG(api_scr_default, P_ERROR, "invalid type %d",type);
    }
    return &screen_device;
}

/**
  \fn
  \brief
  \return
*/
uint32_t api_scr_create(screenSupportList_e type,void *cfg)
{
    uint32_t usrId = 0;
    if(type < HAL_SCR_TOTAL)
    {
        if(scrEventFlags == NULL){
            scrEventFlags = osEventFlagsNew(NULL);
        }
        if(lspiMutex == NULL){
            lspiMutex = osMutexNew(NULL);
            osMutexRelease(lspiMutex);
        }
        usrId = scr_set_idle(type);
        if(cfg != NULL){
            api_scr_infp screen_infp = (api_scr_infp)cfg;
            lspiRes_t *lspi = lspiResGet();
            EPAT_LOG(scr_create_cfg, P_INFO, "[0x%x]lspi 0x%x,div%d,spiISR 0x%x",usrId,lspi,screen_infp->clockDiv,screen_infp->spiISR);
            if(screen_infp->spiISR != NULL){
                user_spi_cb = screen_infp->spiISR;
            }
            switch(type)
            {
                #if (LCD_ST7789_ENABLE == 1)
                case HAL_SCR_ST7789:
                    lcdDev = lcdOpen(0x7789, user_spi_cb, NULL);
                    break;
                #endif
                #if (LCD_AXS15231_ENABLE == 1)
                case HAL_SCR_AXS15231:
                    lcdDev = lcdOpen(0x15231, user_spi_cb, NULL);
                    break;
                #endif
                #if (LCD_ST77922_ENABLE == 1)
                case HAL_SCR_ST77922:
                    lcdDev = lcdOpen(0x77922, user_spi_cb, NULL);
                    break;
                #endif
                default:
                    EPAT_LOG(api_scr_default, P_ERROR, "invalid type %d",type);
            }
        }
    }
end:
    EPAT_LOG(api_scr_create, P_INFO, "usrId 0x%x,dispDmaCh 0x%x",usrId,dispDmaCh);
    return usrId;
}

/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_delete(uint32_t usrId)
{
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_IDLE && index < EC_SCR_INDEX_LIMIT)
    {
        if(scr_set_free(index))
        {
        }
        ret = OPEN_HAL_DONE;
    }
end:
    EPAT_LOG(api_scr_delete, P_INFO, "usrId 0x%X,index %d,ret %d",usrId,index,ret);
    return ret;
}
/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_open(uint32_t usrId,void *cfg,size_t timeout)
{
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_IDLE && index < EC_SCR_INDEX_LIMIT)
    {
        if(cfg != NULL)
        {
            uint8_t *value = *(uint8_t *)cfg;
            lcdBackLight(lcdDev, value); // open backlight
            // uint16_t init_regs_num = dispConfig(lcd_init_reg);
            // EPAT_LOG(api_scr_open_regs, P_INFO, "num %d",init_regs_num);
        }
        scr_set_used(usrId);
        ret = OPEN_HAL_DONE;
    }
end:
    EPAT_LOG(api_scr_open, P_INFO, "usrId 0x%X,index %d,ret %d",usrId,index,ret);
    return ret;
}

/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_close(uint32_t usrId)
{
    // ASSERT(usrId > 0);
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    // ASSERT(index < EC_SCR_INDEX_LIMIT);
    if(ret == OPEN_HAL_USED && index < EC_SCR_INDEX_LIMIT)
    {  
        scr_set_idle(index);
        lcdBackLight(lcdDev, 0);
        ret = OPEN_HAL_DONE;
    }
end:
    EPAT_LOG(api_scr_close, P_INFO, "index %d,usrId 0x%X,0x%X,ret%d",index,usrId,s_scrUsrIdList[index],ret);
    return ret;
}
/**
  \fn          
  \brief   不同LCD的相关控制寄存器及配置方式不同，此处只针对ST7789进行设置（理论在LCD驱动层配置接口）     
  \return
*/
static uint8_t s_MADCTL = 0x0;  //初始默认值需要和LCD初始化配置同步
static uint8_t api_scr_direction(lcdDrvFunc_t *lcd,uint8_t cmd,DisDirection_e Dir)
{
    switch(Dir)
    {
        case DIS_MIRROR_X:  
            s_MADCTL ^= BIT(6);
            break;
        case DIS_MIRROR_Y:  
            s_MADCTL ^= BIT(7);
            break;   
        case DIS_SWAP_XY:   
            s_MADCTL ^= 0xC0;
            break; 
        case DIS_DIR_LRTB: 
            s_MADCTL &= ~(BIT(2));   
            s_MADCTL &= ~(BIT(4)); 
            s_MADCTL &= ~(BIT(5));
            break;
        case DIS_DIR_LRBT: 
            s_MADCTL &= ~(BIT(2)); 
            s_MADCTL &= ~(BIT(5)); 
            s_MADCTL |= BIT(4);
            break;   
        case DIS_DIR_RLTB:   
            s_MADCTL &= ~(BIT(4)); 
            s_MADCTL &= ~(BIT(5)); 
            s_MADCTL |= BIT(2);
            break; 
        case DIS_DIR_RLBT: 
            s_MADCTL &= ~(BIT(5));
            s_MADCTL |=  BIT(4);  
            s_MADCTL |=  BIT(2); 
            break; 
        case DIS_DIR_TBLR: 
            s_MADCTL &= ~(BIT(2)); 
            s_MADCTL &= ~(BIT(4));
            s_MADCTL |= BIT(5);  
            break; 
        case DIS_DIR_BTLR:  
            s_MADCTL &= ~(BIT(2));
            s_MADCTL |= BIT(4); 
            s_MADCTL |= BIT(5);   
            break; 
        case DIS_DIR_TBRL:  
            s_MADCTL &= ~(BIT(4));
            s_MADCTL |= BIT(2); 
            s_MADCTL |= BIT(5);
            break; 
        case DIS_DIR_BTRL: 
            s_MADCTL |= BIT(2); 
            s_MADCTL |= BIT(4); 
            s_MADCTL |= BIT(5);  
            break; 
    }
    lspiRes_t *lspi = lspiResGet();
    lspi->reg->LSPI_CADDR = cmd;
    spiData(lspi,s_MADCTL);
    spiSend(lspi,NULL,0);
    return s_MADCTL;
}
/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_ioctl(uint32_t usrId, api_scr_ioctl_t type, void *para)
{
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_USED)
    {
        uint8_t value = *(uint8_t *)para;
        switch (type) {
            case SCREEN_BACKLIGHT:
                if(value>99) value = 99;
                if(value<4) value = 4;
                lcdBackLight(lcdDev,value);
                break;
            case SCREEN_DIRECTION:
                // lcdDev->direction(lcdDev,value);     //理论上添加
                api_scr_direction(lcdDev,0x36,value);   //实际上添加
                break;
            default:
                break;
        }
        ret = OPEN_HAL_DONE;
    }
end:
    EPAT_LOG(api_scr_ioctl, P_INFO, "index %d,usrId 0x%X,type%d,ret%d",index,usrId,type,ret);
    return ret;
}
/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_pmctl(uint32_t usrId, open_hal_pm_t *cfg, size_t count)
{
    // ASSERT(usrId > 0);
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_USED)
    {
        if(cfg != NULL){
            if(count==0){
                // SYSLOG_INFO("[0x%08X]read\r\n",usrId);
            }
            else if(cfg->runtime == RUNTIME_SUSPEND){
                if(cfg->mode == PM_LOWPOW){
                    // SYSLOG_INFO("[0x%08X]set\r\n",usrId);
                }
            }
            ret = OPEN_HAL_DONE;
        }
    }
end:
    EPAT_LOG(api_scr_pmctl, P_INFO, "index %d,0x%X,ret%d",index,usrId,ret);
    return ret;
}

/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_write(uint32_t usrId, void* buf, size_t count)
{
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_USED)
    {
        if(buf != NULL){
            api_screen_fill_t *bulk = (api_screen_fill_t*)buf;
            // EPAT_LOG(scr_write_data, P_INFO, "sx%d,sy%d,ex%d,ey%d,0x%x",bulk->sx, bulk->sy, bulk->ex, bulk->ey, bulk->data);
            uint32_t fillLen = lcdSetWindow(lcdDev, bulk->sx, bulk->sy, bulk->ex, bulk->ey);
            lcdFill(lcdDev, fillLen, bulk->data);
        }
        ret = OPEN_HAL_DONE;
    }
end:
    // EPAT_LOG(api_scr_write, P_INFO, "index %d,usrId 0x%X,ret%d",index,usrId,ret);
    return ret;
}

/**
  \fn
  \brief
  \return
*/
api_ret_t api_scr_read(uint32_t usrId, void* buf, size_t count)
{
    api_ret_t ret = api_scr_query(usrId);
    uint32_t index = usrId_to_index(usrId);
    if(ret == OPEN_HAL_USED)
    {
        if(buf != NULL){
        }
        ret = OPEN_HAL_DONE;
    }
end:
    EPAT_LOG(api_scr_read, P_INFO, "usrId 0x%X,index %d,ret%d",usrId,index,ret);
    return ret;
}
#endif