EVE_CoCmd_IO.c

Go to the documentation of this file.

 
#include "EVE_Platform.h"
 
EVE_HAL_EXPORT bool EVE_CoCmd_memCrc(EVE_HalContext *phost, uint32_t ptr, uint32_t num, uint32_t *result)
{
    uint16_t resAddr;
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_MEMCRC, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_MEMCRC);
    EVE_Cmd_wr32(phost, ptr);
    EVE_Cmd_wr32(phost, num);
    resAddr = EVE_Cmd_moveWp(phost, 4);
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (result)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        *result = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
    }
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_regRead(EVE_HalContext *phost, uint32_t ptr, uint32_t *result)
{
    uint16_t resAddr;
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_REGREAD, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_REGREAD);
    EVE_Cmd_wr32(phost, ptr);
    resAddr = EVE_Cmd_moveWp(phost, 4);
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (result)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        *result = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
    }
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_inflate_progMem(EVE_HalContext *phost, uint32_t dst, eve_progmem_const uint8_t *src, uint32_t size)
{
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_INFLATE);
    EVE_Cmd_wr32(phost, dst);
    EVE_Cmd_wrProgMem(phost, src, (size + 3) & ~0x3UL);
    EVE_Cmd_endFunc(phost);
    return EVE_Cmd_waitFlush(phost); // Resource failed to load
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_getPtr(EVE_HalContext *phost, uint32_t *result)
{
    uint16_t resAddr;
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_GETPTR, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_GETPTR);
    resAddr = EVE_Cmd_moveWp(phost, 4); // move write pointer to result location
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (result)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        *result = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
    }
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_loadImage_progMem(EVE_HalContext *phost, uint32_t dst, eve_progmem_const uint8_t *src, uint32_t size, uint32_t *format)
{
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_LOADIMAGE, dst))
        return false;
#endif
 
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_LOADIMAGE);
    EVE_Cmd_wr32(phost, dst);
    EVE_Cmd_wr32(phost, OPT_NODL);
    EVE_Cmd_wrProgMem(phost, src, (size + 3) & ~0x3UL);
    EVE_Cmd_endFunc(phost);
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Image failed to load
    if (format)
        *format = EVE_Hal_rd32(phost, 0x3097e8);
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_getProps(EVE_HalContext *phost, uint32_t *ptr, uint32_t *w, uint32_t *h)
{
    uint16_t resAddr;
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_GETPROPS, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_GETPROPS);
    resAddr = EVE_Cmd_moveWp(phost, 12);
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (ptr || w || h)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        if (ptr)
            *ptr = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
        if (w)
            *w = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 4);
        if (h)
            *h = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 8);
    }
    return true;
}
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815) && defined(EVE_FLASH_AVAILABLE)
 
EVE_HAL_EXPORT bool EVE_CoCmd_flashErase_flush(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_FLASHERASE, EVE_CHIPID >= EVE_BT815, false);
 
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
 
    EVE_CoCmd_d(phost, CMD_FLASHERASE);
 
    return EVE_Cmd_waitFlush(phost);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_flashRead_flush(EVE_HalContext *phost, uint32_t dest, uint32_t src, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_FLASHREAD, EVE_CHIPID >= EVE_BT815, false);
 
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
 
    EVE_CoCmd_dddd(phost, CMD_FLASHREAD, dest, src, num);
 
    return EVE_Cmd_waitFlush(phost);
}
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_flashAttach(EVE_HalContext *phost)
{
    uint32_t flashStatus;
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_FLASHATTACH, EVE_CHIPID >= EVE_BT815, 0);
    if (!EVE_Cmd_waitFlush(phost))
        return EVE_Hal_rd32(phost, REG_FLASH_STATUS); // Coprocessor must be ready
    flashStatus = EVE_Hal_rd32(phost, REG_FLASH_STATUS);
    if (flashStatus != FLASH_STATUS_DETACHED)
        return flashStatus; // Only attach when detached
    EVE_CoCmd_d(phost, CMD_FLASHATTACH);
    EVE_Cmd_waitFlush(phost); // Wait for command completion
    return EVE_Hal_rd32(phost, REG_FLASH_STATUS); // Return current status
}
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_flashFast(EVE_HalContext *phost, uint32_t *result)
{
    uint16_t resAddr;
    uint32_t flashStatus;
 
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_FLASHFAST, EVE_CHIPID >= EVE_BT815, 0);
 
    if (!EVE_Cmd_waitFlush(phost))
    {
        if (result)
            *result = 0xE000;
        return EVE_Hal_rd32(phost, REG_FLASH_STATUS);
    } // Coprocessor must be ready
    flashStatus = EVE_Hal_rd32(phost, REG_FLASH_STATUS);
    if (flashStatus < FLASH_STATUS_BASIC)
    {
        if (result)
            *result = 0xE001;
        return flashStatus;
    }
    if (flashStatus > FLASH_STATUS_BASIC)
    {
        if (result)
            *result = 0;
        return flashStatus;
    } // Only enter fast mode when attached
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_FLASHFAST, 0))
        return flashStatus;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_FLASHFAST);
    resAddr = EVE_Cmd_moveWp(phost, 4); // Get the address where the coprocessor will write the result
    EVE_Cmd_endFunc(phost);
    EVE_Cmd_waitFlush(phost); // Wait for command completion
    if (result)
        *result = EVE_Hal_rd32(phost, RAM_CMD + resAddr); // Fetch result
    return EVE_Hal_rd32(phost, REG_FLASH_STATUS); // Return current status
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_loadImage_flash(EVE_HalContext *phost, uint32_t dst, uint32_t src, uint32_t *format)
{
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_FLASHSOURCE, src))
        return false;
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_LOADIMAGE, dst))
        return false;
#endif
 
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_FLASHSOURCE);
    EVE_Cmd_wr32(phost, src);
    EVE_Cmd_wr32(phost, CMD_LOADIMAGE);
    EVE_Cmd_wr32(phost, dst);
    EVE_Cmd_wr32(phost, OPT_FLASH | OPT_NODL);
    EVE_Cmd_endFunc(phost);
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Image failed to load
    if (format)
        *format = EVE_Hal_rd32(phost, 0x3097e8);
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_inflate_flash(EVE_HalContext *phost, uint32_t dst, uint32_t src)
{
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_FLASHSOURCE, src))
        return false;
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_INFLATE2, dst))
        return false;
#endif
 
    if (!EVE_Cmd_waitFlush(phost))
        return false; // Coprocessor must be ready
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_FLASHSOURCE);
    EVE_Cmd_wr32(phost, src);
    EVE_Cmd_wr32(phost, CMD_INFLATE2);
    EVE_Cmd_wr32(phost, dst);
    EVE_Cmd_wr32(phost, OPT_FLASH);
    EVE_Cmd_endFunc(phost);
    return EVE_Cmd_waitFlush(phost); // Image failed to load
}
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
 
EVE_HAL_EXPORT bool EVE_CoCmd_getImage(EVE_HalContext *phost, uint32_t *source, uint32_t *fmt, uint32_t *w, uint32_t *h, uint32_t *palette)
{
    uint16_t resAddr;
 
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_GETIMAGE, EVE_CHIPID >= EVE_BT817, false);
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_GETIMAGE, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_GETIMAGE);
    resAddr = EVE_Cmd_moveWp(phost, 4 * 5);
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (source || fmt || w || h || palette)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        if (source)
            *source = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
        if (fmt)
            *fmt = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 4);
        if (w)
            *w = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 8);
        if (h)
            *h = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 12);
        if (palette)
            *palette = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 16);
    }
    return true;
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_fontCacheQuery(EVE_HalContext *phost, uint32_t *total, int32_t *used)
{
    uint16_t resAddr;
 
    EVE_MULTI_TARGET_CHECK_RETURN(CMD_FONTCACHEQUERY, EVE_CHIPID >= EVE_BT817, false);
 
#if EVE_CMD_HOOKS
    if (phost->CoCmdHook && phost->CoCmdHook(phost, CMD_FONTCACHEQUERY, 0))
        return false;
#endif
 
    EVE_Cmd_startFunc(phost);
    EVE_Cmd_wr32(phost, CMD_FONTCACHEQUERY);
    resAddr = EVE_Cmd_moveWp(phost, 8);
    EVE_Cmd_endFunc(phost);
 
    /* Read result */
    if (total || used)
    {
        if (!EVE_Cmd_waitFlush(phost))
            return false;
        if (total)
            *total = EVE_Hal_rd32(phost, RAM_CMD + resAddr);
        if (used)
            *used = EVE_Hal_rd32(phost, RAM_CMD + resAddr + 4);
    }
    return true;
}
 
#endif
 
/* end of file */