EVE_CoCmd.h

Go to the documentation of this file.

 
#ifndef EVE_CO_CMD__H
#define EVE_CO_CMD__H
 
#include "EVE_HalDefs.h"
#include "EVE_GpuDefs.h"
 
/*
Commands are organized as follows:
 - System commands
 - I/O commands
 - Render state commands
 - Widget rendering commands
 - Complex widget commands
 */
 
#ifndef ESD_FUNCTION
#define ESD_FUNCTION(name, ...)
#endif
#ifndef ESD_RENDER
#define ESD_RENDER(name, ...)
#endif
#ifndef ESD_PARAMETER
#define ESD_PARAMETER(name, ...)
#endif
 
#define EVE_COCMD_UNSUPPORTED(cmd, res) eve_pragma_warning("Coprocessor command " #cmd " is not supported on this platform")(res)
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
EVE_HAL_EXPORT void EVE_CoCmd_d(EVE_HalContext *phost, uint32_t cmd);
EVE_HAL_EXPORT void EVE_CoCmd_dd(EVE_HalContext *phost, uint32_t cmd, uint32_t d0);
EVE_HAL_EXPORT void EVE_CoCmd_ddd(EVE_HalContext *phost, uint32_t cmd, uint32_t d0, uint32_t d1);
EVE_HAL_EXPORT void EVE_CoCmd_dddd(EVE_HalContext *phost, uint32_t cmd, uint32_t d0, uint32_t d1, uint32_t d2);
EVE_HAL_EXPORT void EVE_CoCmd_ddddd(EVE_HalContext *phost, uint32_t cmd, uint32_t d0, uint32_t d1, uint32_t d2, uint32_t d3);
EVE_HAL_EXPORT void EVE_CoCmd_ddww(EVE_HalContext *phost, uint32_t cmd,
    uint32_t d0, uint16_t w1, uint16_t w2);
EVE_HAL_EXPORT void EVE_CoCmd_ddwww(EVE_HalContext *phost, uint32_t cmd,
    uint32_t d0, uint16_t w1, uint16_t w2, uint16_t w3);
EVE_HAL_EXPORT void EVE_CoCmd_dddwwww(EVE_HalContext *phost, uint32_t cmd,
    uint32_t d0, uint32_t d1,
    uint16_t w2, uint16_t w3, uint16_t w4, uint16_t w5);
EVE_HAL_EXPORT void EVE_CoCmd_dwwdd(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint32_t d2, uint32_t d3);
EVE_HAL_EXPORT void EVE_CoCmd_dwwdwwd(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint32_t d2,
    uint16_t w3, uint16_t w4, uint32_t d5);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwdw(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint32_t d4, uint16_t w5);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwdww(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint32_t d4, uint16_t w5, uint16_t w6);
EVE_HAL_EXPORT void EVE_CoCmd_dwwww(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwww(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3, uint16_t w4);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwd(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3, uint32_t d4);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwwww(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint16_t w4, uint16_t w5, uint16_t w6);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwwwww(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint16_t w4, uint16_t w5, uint16_t w6, uint16_t w7);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwwwz(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint16_t w4, uint16_t w5, const char *s);
EVE_HAL_EXPORT void EVE_CoCmd_dwwwwwwz_s(EVE_HalContext *phost, uint32_t cmd,
    uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3,
    uint16_t w4, uint16_t w5, const char *s, uint32_t len);
 
static inline void EVE_CoCmd_dl(EVE_HalContext *phost, uint32_t dl)
{
    EVE_CoCmd_d(phost, dl);
}
 
#if defined(_DEBUG) && defined(EVE_MULTI_GRAPHICS_TARGET)
EVE_HAL_EXPORT void EVE_CoCmd_debugUnsupported(const char *cmd, uint32_t chipId);
#define EVE_MULTI_TARGET_CHECK(cmd, condition)        \
    if (!(condition))                                 \
    {                                                 \
        EVE_CoCmd_debugUnsupported(#cmd, EVE_CHIPID); \
        return;                                       \
    }
#define EVE_MULTI_TARGET_CHECK_RETURN(cmd, condition, res) \
    if (!(condition))                                      \
    {                                                      \
        EVE_CoCmd_debugUnsupported(#cmd, EVE_CHIPID);      \
        return res;                                        \
    }
#else
#define EVE_MULTI_TARGET_CHECK(cmd, condition)
#define EVE_MULTI_TARGET_CHECK_RETURN(cmd, condition, res)
#endif
 
EVE_HAL_EXPORT void EVE_CoDlImpl_resetDlState(EVE_HalContext *phost);
EVE_HAL_EXPORT void EVE_CoDlImpl_resetCoState(EVE_HalContext *phost);
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
#define EVE_CO_SCRATCH_HANDLE (EVE_CHIPID >= EVE_FT810 ? phost->CoScratchHandle : 15)
#else
#define EVE_CO_SCRATCH_HANDLE (15)
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
static inline void EVE_CoCmd_dlStart(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_DLSTART);
    EVE_CoDlImpl_resetDlState(phost);
}
 
static inline void EVE_CoCmd_swap(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_SWAP);
}
 
ESD_FUNCTION(EVE_CoCmd_interrupt, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(ms, Type = int32_t, Default = 0)
static inline void EVE_CoCmd_interrupt(EVE_HalContext *phost, uint32_t ms)
{
    EVE_CoCmd_dd(phost, CMD_INTERRUPT, ms);
}
 
static inline void EVE_CoCmd_coldStart(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_COLDSTART);
    EVE_CoDlImpl_resetCoState(phost);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_getMatrix(EVE_HalContext *phost, int32_t *m);
 
EVE_HAL_EXPORT void EVE_CoCmd_setRotate(EVE_HalContext *phost, uint32_t r);
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
 
ESD_FUNCTION(EVE_CoCmd_sync, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
static inline void EVE_CoCmd_sync(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_SYNC, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_d(phost, CMD_SYNC);
}
 
#else
 
#define EVE_CoCmd_sync(phost) EVE_COCMD_UNSUPPORTED(CMD_SYNC, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
 
static inline void EVE_CoCmd_clearCache(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_CLEARCACHE, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_CLEARCACHE);
}
 
static inline void EVE_CoCmd_nop(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_NOP, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_NOP);
}
 
#else
 
#define EVE_CoCmd_clearCache(phost) EVE_COCMD_UNSUPPORTED(CMD_CLEARCACHE, false)
#define EVE_CoCmd_nop(phost) EVE_COCMD_UNSUPPORTED(CMD_NOP, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
static inline void EVE_CoCmd_hsf(EVE_HalContext *phost, uint32_t hsf)
{
    EVE_MULTI_TARGET_CHECK(CMD_HSF, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dd(phost, CMD_HSF, hsf);
}
 
static inline void EVE_CoCmd_apiLevel(EVE_HalContext *phost, uint32_t level)
{
    EVE_MULTI_TARGET_CHECK(CMD_APILEVEL, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dd(phost, CMD_APILEVEL, level);
}
 
static inline void EVE_CoCmd_wait(EVE_HalContext *phost, uint32_t us)
{
    EVE_MULTI_TARGET_CHECK(CMD_WAIT, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dd(phost, CMD_WAIT, us);
}
 
static inline void EVE_CoCmd_return(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_RETURN, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_d(phost, CMD_RETURN);
}
 
static inline void EVE_CoCmd_callList(EVE_HalContext *phost, uint32_t a)
{
    EVE_MULTI_TARGET_CHECK(CMD_CALLLIST, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dd(phost, CMD_CALLLIST, a);
}
 
static inline void EVE_CoCmd_newList(EVE_HalContext *phost, uint32_t a)
{
    EVE_MULTI_TARGET_CHECK(CMD_NEWLIST, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dd(phost, CMD_NEWLIST, a);
}
 
static inline void EVE_CoCmd_endList(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_ENDLIST, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_d(phost, CMD_ENDLIST);
}
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_pclkFreq(EVE_HalContext *phost, uint32_t ftarget, int32_t rounding);
 
#else
 
#define EVE_CoCmd_hsf(phost, hsf) EVE_COCMD_UNSUPPORTED(CMD_HSF, false)
#define EVE_CoCmd_apiLevel(phost, level) EVE_COCMD_UNSUPPORTED(CMD_APILEVEL, false)
#define EVE_CoCmd_wait(phost, us) EVE_COCMD_UNSUPPORTED(CMD_WAIT, false)
#define EVE_CoCmd_return(phost) EVE_COCMD_UNSUPPORTED(CMD_RETURN, false)
#define EVE_CoCmd_callList(phost, a) EVE_COCMD_UNSUPPORTED(CMD_CALLLIST, false)
#define EVE_CoCmd_newList(phost, a) EVE_COCMD_UNSUPPORTED(CMD_NEWLIST, false)
#define EVE_CoCmd_endList(phost) EVE_COCMD_UNSUPPORTED(CMD_ENDLIST, false)
#define EVE_CoCmd_pclkFreq(phost, ftarget, rounding) EVE_COCMD_UNSUPPORTED(CMD_PCLKFREQ, 0)
 
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
EVE_HAL_EXPORT bool EVE_CoCmd_memCrc(EVE_HalContext *phost, uint32_t ptr, uint32_t num, uint32_t *result);
 
EVE_HAL_EXPORT bool EVE_CoCmd_regRead(EVE_HalContext *phost, uint32_t ptr, uint32_t *result);
 
static inline void EVE_CoCmd_memWrite(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_CoCmd_ddd(phost, CMD_MEMWRITE, ptr, num);
}
 
static inline void EVE_CoCmd_memWrite32(EVE_HalContext *phost, uint32_t ptr, uint32_t value)
{
    EVE_CoCmd_dddd(phost, CMD_MEMWRITE, ptr, 4, value);
}
 
ESD_FUNCTION(EVE_CoCmd_memSet, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(ptr, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
ESD_PARAMETER(value, Type = uint32_t, Default = 0)
ESD_PARAMETER(num, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
static inline void EVE_CoCmd_memSet(EVE_HalContext *phost, uint32_t ptr, uint32_t value, uint32_t num)
{
    EVE_CoCmd_dddd(phost, CMD_MEMSET, ptr, value, num);
}
 
ESD_FUNCTION(EVE_CoCmd_memZero, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(ptr, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
ESD_PARAMETER(num, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
static inline void EVE_CoCmd_memZero(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_CoCmd_ddd(phost, CMD_MEMZERO, ptr, num);
}
 
ESD_FUNCTION(EVE_CoCmd_memCpy, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(dest, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
ESD_PARAMETER(src, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
ESD_PARAMETER(num, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
static inline void EVE_CoCmd_memCpy(EVE_HalContext *phost, uint32_t dest, uint32_t src, uint32_t num)
{
    EVE_CoCmd_dddd(phost, CMD_MEMCPY, dest, src, num);
}
 
ESD_FUNCTION(EVE_CoCmd_append, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(ptr, Type = uint32_t, Default = 0) // MEMORY_ADDRESS
ESD_PARAMETER(num, Type = uint32_t, Default = 0, Min = 0, Max = 2048)
static inline void EVE_CoCmd_append(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_CoCmd_ddd(phost, CMD_APPEND, ptr, num);
}
 
static inline void EVE_CoCmd_snapshot(EVE_HalContext *phost, uint32_t ptr)
{
    EVE_CoCmd_dd(phost, CMD_SNAPSHOT, ptr);
}
 
static inline void EVE_CoCmd_inflate(EVE_HalContext *phost, uint32_t ptr)
{
    EVE_CoCmd_dd(phost, CMD_INFLATE, ptr);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_inflate_progMem(EVE_HalContext *phost, uint32_t dst, eve_progmem_const uint8_t *src, uint32_t size);
 
EVE_HAL_EXPORT bool EVE_CoCmd_getPtr(EVE_HalContext *phost, uint32_t *result);
 
static inline void EVE_CoCmd_loadImage(EVE_HalContext *phost, uint32_t ptr, uint32_t options)
{
    EVE_CoCmd_ddd(phost, CMD_LOADIMAGE, ptr, options);
}
 
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);
 
EVE_HAL_EXPORT bool EVE_CoCmd_getProps(EVE_HalContext *phost, uint32_t *ptr, uint32_t *w, uint32_t *h);
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
 
static inline void EVE_CoCmd_snapshot2(EVE_HalContext *phost, uint32_t fmt, uint32_t ptr, int16_t x, int16_t y, int16_t w, int16_t h)
{
    EVE_MULTI_TARGET_CHECK(CMD_SNAPSHOT2, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_dddwwww(phost, CMD_SNAPSHOT2, fmt, ptr, x, y, w, h);
}
 
static inline void EVE_CoCmd_mediaFifo(EVE_HalContext *phost, uint32_t ptr, uint32_t size)
{
    EVE_MULTI_TARGET_CHECK(CMD_MEDIAFIFO, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_ddd(phost, CMD_MEDIAFIFO, ptr, size);
}
 
static inline void EVE_CoCmd_videoStart(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_VIDEOSTART, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_d(phost, CMD_VIDEOSTART);
}
 
static inline void EVE_CoCmd_videoFrame(EVE_HalContext *phost, uint32_t dst, uint32_t ptr)
{
    EVE_MULTI_TARGET_CHECK(CMD_VIDEOFRAME, EVE_CHIPID >= EVE_FT810);
    if (EVE_CHIPID == EVE_BT815 || EVE_CHIPID == EVE_BT816)
        EVE_CoCmd_dddd(phost, CMD_MEMWRITE, 3182934, 1, OPT_NODL); // WORKAROUND CMD_VIDEOFRAME
    else if (EVE_CHIPID == EVE_BT817 || EVE_CHIPID == EVE_BT818)
        EVE_CoCmd_dddd(phost, CMD_MEMWRITE, 3182920, 1, OPT_NODL); // WORKAROUND CMD_VIDEOFRAME
    EVE_CoCmd_ddd(phost, CMD_VIDEOFRAME, dst, ptr);
}
 
#else
 
#define EVE_CoCmd_snapshot2(phost, fmt, ptr, x, y, w, h) EVE_COCMD_UNSUPPORTED(CMD_SNAPSHOT2, false)
#define EVE_CoCmd_mediaFifo(phost, ptr, size) EVE_COCMD_UNSUPPORTED(CMD_MEDIAFIFO, false)
#define EVE_CoCmd_videoStart(phost) EVE_COCMD_UNSUPPORTED(CMD_VIDEOSTART, false)
#define EVE_CoCmd_videoFrame(phost, dst, ptr) EVE_COCMD_UNSUPPORTED(CMD_VIDEOFRAME, false)
 
#endif
 
#define FLASH_ERROR_NOTATTACHED 0xE001
#define FLASH_ERROR_HEADERMISSING 0xE002
#define FLASH_ERROR_HEADERCRCFAILED 0xE003
#define FLASH_ERROR_FIRMWAREMISMATCH 0xE004
#define FLASH_ERROR_FULLSPEEDFAILED 0xE005
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815) && defined(EVE_FLASH_AVAILABLE)
 
static inline void EVE_CoCmd_flashErase(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHERASE, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_FLASHERASE);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_flashErase_flush(EVE_HalContext *phost);
 
static inline void EVE_CoCmd_flashWrite(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHWRITE, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddd(phost, CMD_FLASHWRITE, ptr, num);
}
 
static inline void EVE_CoCmd_flashRead(EVE_HalContext *phost, uint32_t dest, uint32_t src, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHREAD, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dddd(phost, CMD_FLASHREAD, dest, src, num);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_flashRead_flush(EVE_HalContext *phost, uint32_t dest, uint32_t src, uint32_t num);
 
static inline void EVE_CoCmd_flashUpdate(EVE_HalContext *phost, uint32_t dest, uint32_t src, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHUPDATE, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dddd(phost, CMD_FLASHUPDATE, dest, src, num);
}
 
static inline void EVE_CoCmd_flashDetach(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHDETACH, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_FLASHDETACH);
}
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_flashAttach(EVE_HalContext *phost);
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_flashFast(EVE_HalContext *phost, uint32_t *result);
 
static inline void EVE_CoCmd_flashSpiDesel(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHSPIDESEL, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_FLASHSPIDESEL);
}
 
static inline void EVE_CoCmd_flashSpiTx(EVE_HalContext *phost, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHSPITX, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dd(phost, CMD_FLASHSPITX, num);
}
 
static inline void EVE_CoCmd_flashSpiRx(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHSPIRX, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddd(phost, CMD_FLASHSPIRX, ptr, num);
}
 
static inline void EVE_CoCmd_flashSource(EVE_HalContext *phost, uint32_t ptr)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHSOURCE, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dd(phost, CMD_FLASHSOURCE, ptr);
}
 
static inline void EVE_CoCmd_appendF(EVE_HalContext *phost, uint32_t ptr, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_APPENDF, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddd(phost, CMD_APPENDF, ptr, num);
}
 
static inline void EVE_CoCmd_videoStartF(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_VIDEOSTARTF, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_VIDEOSTARTF);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_loadImage_flash(EVE_HalContext *phost, uint32_t dst, uint32_t src, uint32_t *format);
 
EVE_HAL_EXPORT bool EVE_CoCmd_inflate_flash(EVE_HalContext *phost, uint32_t dst, uint32_t src);
 
#else
 
#define EVE_CoCmd_flashErase(phost) EVE_COCMD_UNSUPPORTED(CMD_FLASHERASE, false)
#define EVE_CoCmd_flashErase_flush(phost) EVE_COCMD_UNSUPPORTED(CMD_FLASHERASE, false)
#define EVE_CoCmd_flashWrite(phost, ptr, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHWRITE, false)
#define EVE_CoCmd_flashRead(phost, dest, src, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHREAD, false)
#define EVE_CoCmd_flashRead_flush(phost, dest, src, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHREAD, false)
#define EVE_CoCmd_flashUpdate(phost, dest, src, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHUPDATE, false)
#define EVE_CoCmd_flashDetach(phost) EVE_COCMD_UNSUPPORTED(CMD_FLASHDETACH, false)
#define EVE_CoCmd_flashAttach(phost) EVE_COCMD_UNSUPPORTED(CMD_FLASHATTACH, 0)
#define EVE_CoCmd_flashFast(phost, result) EVE_COCMD_UNSUPPORTED(CMD_FLASHFAST, 0)
#define EVE_CoCmd_flashSpiDesel(phost) EVE_COCMD_UNSUPPORTED(CMD_FLASHSPIDESEL, false)
#define EVE_CoCmd_flashSpiTx(phost, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHSPITX, false)
#define EVE_CoCmd_flashSpiRx(phost, ptr, num) EVE_COCMD_UNSUPPORTED(CMD_FLASHSPIRX, false)
#define EVE_CoCmd_flashSource(phost, ptr) EVE_COCMD_UNSUPPORTED(CMD_FLASHSOURCE, false)
#define EVE_CoCmd_appendF(phost, ptr, num) EVE_COCMD_UNSUPPORTED(CMD_APPENDF, false)
#define EVE_CoCmd_videoStartF(phost) EVE_COCMD_UNSUPPORTED(CMD_VIDEOSTARTF, false)
#define EVE_CoCmd_loadImage_flash(phost, dst, src, format) EVE_COCMD_UNSUPPORTED(CMD_FLASHSOURCE, false)
#define EVE_CoCmd_inflate_flash(phost, dst, src, format) EVE_COCMD_UNSUPPORTED(CMD_FLASHSOURCE, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
 
static inline void EVE_CoCmd_inflate2(EVE_HalContext *phost, uint32_t ptr, uint32_t options)
{
    EVE_MULTI_TARGET_CHECK(CMD_INFLATE2, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddd(phost, CMD_INFLATE2, ptr, options);
}
 
#else
 
#define EVE_CoCmd_inflate2(phost, ptr, options) EVE_COCMD_UNSUPPORTED(CMD_INFLATE2, false)
 
#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);
 
static inline void EVE_CoCmd_fontCache(EVE_HalContext *phost, uint32_t font, int32_t ptr, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FONTCACHE, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dddd(phost, CMD_FONTCACHE, font, ptr, num);
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_fontCacheQuery(EVE_HalContext *phost, uint32_t *total, int32_t *used);
 
#else
 
#define EVE_CoCmd_getImage(phost, source, fmt, w, h, palette) EVE_COCMD_UNSUPPORTED(CMD_GETIMAGE, false)
#define EVE_CoCmd_fontCache(phost, font, ptr, num) EVE_COCMD_UNSUPPORTED(CMD_FONTCACHE, false)
#define EVE_CoCmd_fontCacheQuery(phost, total, used) EVE_COCMD_UNSUPPORTED(CMD_FONTCACHEQUERY, false)
 
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
ESD_FUNCTION(EVE_CoCmd_bgColor, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(c, Type = esd_rgb32_t, Default = 0) // COLOR
static inline void EVE_CoCmd_bgColor(EVE_HalContext *phost, uint32_t c)
{
#if EVE_DL_OPTIMIZE
    if (phost->CoBgColor != c)
    {
#endif
        EVE_CoCmd_dd(phost, CMD_BGCOLOR, c);
#if EVE_DL_OPTIMIZE
        phost->CoBgColor = c;
    }
#endif
}
 
ESD_FUNCTION(EVE_CoCmd_fgColor, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(c, Type = esd_rgb32_t, Default = 0) // COLOR
static inline void EVE_CoCmd_fgColor(EVE_HalContext *phost, uint32_t c)
{
#if EVE_DL_OPTIMIZE
    if (phost->CoFgColor != c)
    {
#endif
        EVE_CoCmd_dd(phost, CMD_FGCOLOR, c);
#if EVE_DL_OPTIMIZE
        phost->CoFgColor = c;
    }
#endif
}
 
EVE_HAL_EXPORT bool EVE_CoCmd_bitmapTransform(EVE_HalContext *phost, int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t tx0, int32_t ty0, int32_t tx1, int32_t ty1, int32_t tx2, int32_t ty2, uint16_t *result);
 
ESD_FUNCTION(EVE_CoCmd_loadIdentity, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
static inline void EVE_CoCmd_loadIdentity(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_LOADIDENTITY);
 
#if EVE_DL_OPTIMIZE
    phost->CoBitmapTransform = false; /* Identity */
#endif
}
 
ESD_FUNCTION(EVE_CoCmd_translate, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(tx, Type = int32_t, Default = 0)
ESD_PARAMETER(ty, Type = int32_t, Default = 0)
static inline void EVE_CoCmd_translate(EVE_HalContext *phost, int32_t tx, int32_t ty)
{
    EVE_CoCmd_ddd(phost, CMD_TRANSLATE, tx, ty);
 
#if EVE_DL_OPTIMIZE
    phost->CoBitmapTransform = true;
#endif
}
 
ESD_FUNCTION(EVE_CoCmd_scale, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(sx, Type = int32_t, Default = 0)
ESD_PARAMETER(sy, Type = int32_t, Default = 0)
static inline void EVE_CoCmd_scale(EVE_HalContext *phost, int32_t sx, int32_t sy)
{
    EVE_CoCmd_ddd(phost, CMD_SCALE, sx, sy);
 
#if EVE_DL_OPTIMIZE
    phost->CoBitmapTransform = true;
#endif
}
 
ESD_FUNCTION(EVE_CoCmd_rotate, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(a, Type = int32_t, Default = 0)
static inline void EVE_CoCmd_rotate(EVE_HalContext *phost, int32_t a)
{
    EVE_CoCmd_dd(phost, CMD_ROTATE, a);
 
#if EVE_DL_OPTIMIZE
    phost->CoBitmapTransform = true;
#endif
}
 
ESD_FUNCTION(EVE_CoCmd_setMatrix, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
static inline void EVE_CoCmd_setMatrix(EVE_HalContext *phost)
{
#if EVE_DL_OPTIMIZE
    if (phost->CoBitmapTransform || EVE_DL_STATE.BitmapTransform)
    {
        /* Setting matrix can be skipped if both are identity, since it's a no-op */
#endif
        EVE_CoCmd_d(phost, CMD_SETMATRIX);
#if EVE_DL_OPTIMIZE
        EVE_DL_STATE.BitmapTransform = phost->CoBitmapTransform; /* Coprocessor matrix is now written to the display list */
    }
#endif
}
 
static inline void EVE_CoCmd_setFont(EVE_HalContext *phost, uint32_t font, uint32_t ptr)
{
    EVE_CoCmd_ddd(phost, CMD_SETFONT, font, ptr);
}
 
ESD_FUNCTION(EVE_CoCmd_gradColor, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(c, Type = esd_rgb32_t, Default = 0) // COLOR
static inline void EVE_CoCmd_gradColor(EVE_HalContext *phost, uint32_t c)
{
    EVE_CoCmd_dd(phost, CMD_GRADCOLOR, c);
}
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
 
ESD_FUNCTION(EVE_CoCmd_setBase, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(base, Type = int32_t, Default = 0)
static inline void EVE_CoCmd_setBase(EVE_HalContext *phost, uint32_t base)
{
    EVE_MULTI_TARGET_CHECK(CMD_SETBASE, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_dd(phost, CMD_SETBASE, base);
}
 
static inline void EVE_CoCmd_setFont2(EVE_HalContext *phost, uint32_t font, uint32_t ptr, uint32_t firstchar)
{
    EVE_MULTI_TARGET_CHECK(CMD_SETFONT2, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_dddd(phost, CMD_SETFONT2, font, ptr, firstchar);
#if EVE_DL_OPTIMIZE
    EVE_DL_STATE.Handle = (uint8_t)font;
#endif
}
 
static inline void EVE_CoCmd_setScratch(EVE_HalContext *phost, uint32_t handle)
{
    EVE_MULTI_TARGET_CHECK(CMD_SETSCRATCH, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_dd(phost, CMD_SETSCRATCH, handle);
    phost->CoScratchHandle = (uint8_t)handle;
}
 
static inline void EVE_CoCmd_romFont(EVE_HalContext *phost, uint32_t font, uint32_t romslot)
{
    EVE_MULTI_TARGET_CHECK(CMD_ROMFONT, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_ddd(phost, CMD_ROMFONT, font, romslot);
#if EVE_DL_OPTIMIZE
    EVE_DL_STATE.Handle = (uint8_t)font;
#endif
}
 
static inline void EVE_CoCmd_setBitmap(EVE_HalContext *phost, uint32_t source, uint16_t fmt, uint16_t w, uint16_t h)
{
    EVE_MULTI_TARGET_CHECK(CMD_SETBITMAP, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_ddwww(phost, CMD_SETBITMAP, source, fmt, w, h);
}
 
#else
 
#define EVE_CoCmd_setBase(phost, base) EVE_COCMD_UNSUPPORTED(CMD_SETBASE, false)
#define EVE_CoCmd_setFont2(phost, font, ptr, firstchar) EVE_COCMD_UNSUPPORTED(CMD_SETFONT2, false)
#define EVE_CoCmd_setScratch(phost, handle) EVE_COCMD_UNSUPPORTED(CMD_SETSCRATCH, false)
#define EVE_CoCmd_romFont(phost, font, romslot) EVE_COCMD_UNSUPPORTED(CMD_ROMFONT, false)
#define EVE_CoCmd_setBitmap(phost, source, fmt, w, h) EVE_COCMD_UNSUPPORTED(CMD_SETBITMAP, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
 
static inline void EVE_CoCmd_rotateAround(EVE_HalContext *phost, int32_t x, int32_t y, int32_t a, int32_t s)
{
    EVE_MULTI_TARGET_CHECK(CMD_ROTATEAROUND, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddddd(phost, CMD_ROTATEAROUND, x, y, a, s);
 
#if EVE_DL_OPTIMIZE
    phost->CoBitmapTransform = true;
#endif
}
 
static inline void EVE_CoCmd_resetFonts(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_RESETFONTS, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_d(phost, CMD_RESETFONTS);
}
 
static inline void EVE_CoCmd_fillWidth(EVE_HalContext *phost, uint32_t s)
{
    EVE_MULTI_TARGET_CHECK(CMD_FILLWIDTH, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dd(phost, CMD_FILLWIDTH, s);
}
 
#else
 
#define EVE_CoCmd_rotateAround(phost, x, y, a, s) EVE_COCMD_UNSUPPORTED(CMD_ROTATEAROUND, false)
#define EVE_CoCmd_resetFonts(phost) EVE_COCMD_UNSUPPORTED(CMD_RESETFONTS, false)
#define EVE_CoCmd_fillWidth(phost, s) EVE_COCMD_UNSUPPORTED(CMD_FILLWIDTH, false)
 
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
ESD_FUNCTION(EVE_CoCmd_gradient, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x0, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y0, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(rgb0, Type = esd_rgb32_t, Default = 0) // COLOR
ESD_PARAMETER(x1, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y1, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(rgb1, Type = esd_rgb32_t, Default = 0) // COLOR
static inline void EVE_CoCmd_gradient(EVE_HalContext *phost, int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1)
{
    EVE_CoCmd_dwwdwwd(phost, CMD_GRADIENT, x0, y0, rgb0, x1, y1, rgb1);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
EVE_HAL_EXPORT void EVE_CoCmd_text(EVE_HalContext *phost, int16_t x, int16_t y, int16_t font, uint16_t options, const char *s, ...);
 
EVE_HAL_EXPORT void EVE_CoCmd_text_s(EVE_HalContext *phost, int16_t x, int16_t y, int16_t font, uint16_t options, const char *s, uint32_t length);
 
ESD_RENDER(EVE_CoCmd_text_ex, Type = void, Category = _GroupHidden, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(font, Type = int16_t, Default = 21, Min = 0, Max = 31) // BITMAP_HANDLE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(bottom, Type = bool, Default = 0)
ESD_PARAMETER(baseLine, Type = int16_t, Default = 0)
ESD_PARAMETER(capsHeight, Type = int16_t, Default = 0)
ESD_PARAMETER(xOffset, Type = int16_t, Default = 0)
ESD_PARAMETER(s, Type = const char *, Default = "Text")
EVE_HAL_EXPORT void EVE_CoCmd_text_ex(EVE_HalContext *phost, int16_t x, int16_t y, int16_t font, uint16_t options, bool bottom, int16_t baseLine, int16_t capsHeight, int16_t xOffset, const char *s);
 
EVE_HAL_EXPORT void EVE_CoCmd_button(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, int16_t font, uint16_t options, const char *s, ...);
 
ESD_RENDER(EVE_CoCmd_keys, Type = void, Category = _GroupHidden, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(width, Type = int16_t, Default = 60) // SCREEN_SIZE
ESD_PARAMETER(height, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(font, Type = int16_t, Default = 21, Min = 0, Max = 31) // BITMAP_HANDLE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(s, Type = const char *, Default = "Button")
EVE_HAL_EXPORT void EVE_CoCmd_keys(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, int16_t font, uint16_t options, const char *s);
 
ESD_RENDER(EVE_CoCmd_progress, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(width, Type = int16_t, Default = 60) // SCREEN_SIZE
ESD_PARAMETER(height, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(val, Type = uint16_t, Default = 0)
ESD_PARAMETER(range, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_progress(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t range)
{
    EVE_CoCmd_dwwwwwww(phost, CMD_PROGRESS, x, y, w, h, options, val, range);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
ESD_RENDER(EVE_CoCmd_slider, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(width, Type = int16_t, Default = 60) // SCREEN_SIZE
ESD_PARAMETER(height, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(val, Type = uint16_t, Default = 0)
ESD_PARAMETER(range, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_slider(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t range)
{
    EVE_CoCmd_dwwwwwww(phost, CMD_SLIDER, x, y, w, h, options, val, range);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
ESD_RENDER(EVE_CoCmd_scrollbar, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(width, Type = int16_t, Default = 60) // SCREEN_SIZE
ESD_PARAMETER(height, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(val, Type = uint16_t, Default = 0)
ESD_PARAMETER(size, Type = uint16_t, Default = 0)
ESD_PARAMETER(range, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_scrollbar(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t size, uint16_t range)
{
    EVE_CoCmd_dwwwwwwww(phost, CMD_SCROLLBAR, x, y, w, h, options, val, size, range);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
EVE_HAL_EXPORT void EVE_CoCmd_toggle(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t font, uint16_t options, uint16_t state, const char *s, ...);
 
ESD_RENDER(EVE_CoCmd_gauge, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(r, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(major, Type = uint16_t, Default = 0)
ESD_PARAMETER(minor, Type = uint16_t, Default = 0)
ESD_PARAMETER(val, Type = uint16_t, Default = 0)
ESD_PARAMETER(range, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_gauge(EVE_HalContext *phost, int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range)
{
    EVE_CoCmd_dwwwwwwww(phost, CMD_GAUGE, x, y, r, options, major, minor, val, range);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
ESD_RENDER(EVE_CoCmd_clock, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(r, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(height, Type = uint16_t, Default = 0)
ESD_PARAMETER(m, Type = uint16_t, Default = 0)
ESD_PARAMETER(s, Type = uint16_t, Default = 0)
ESD_PARAMETER(ms, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_clock(EVE_HalContext *phost, int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t h, uint16_t m, uint16_t s, uint16_t ms)
{
    EVE_CoCmd_dwwwwwwww(phost, CMD_CLOCK, x, y, r, options, h, m, s, ms);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
ESD_RENDER(EVE_CoCmd_dial, Type = void, Category = _GroupHidden, Inline, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(r, Type = int16_t, Default = 40) // SCREEN_SIZE
ESD_PARAMETER(options, Type = Ft_CoPro_Opt, Default = 0)
ESD_PARAMETER(val, Type = uint16_t, Default = 0)
static inline void EVE_CoCmd_dial(EVE_HalContext *phost, int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t val)
{
    EVE_CoCmd_dwwwww(phost, CMD_DIAL, x, y, r, options, val);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
ESD_RENDER(EVE_CoCmd_number, Type = void, Category = _GroupHidden, Include = "Esd_Core.h")
ESD_PARAMETER(phost, Type = EVE_HalContext *, Default = Esd_GetHost, Hidden, Internal, Static) // PHOST
ESD_PARAMETER(x, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(y, Type = int16_t, Default = 0) // SCREEN_SIZE
ESD_PARAMETER(font, Type = int16_t, Default = 21, Min = 16, Max = 34) // BITMAP_HANDLE
ESD_PARAMETER(options, Type = uint16_t, Default = 256)
ESD_PARAMETER(n, Type = int32_t, Default = 0)
EVE_HAL_EXPORT void EVE_CoCmd_number(EVE_HalContext *phost, int16_t x, int16_t y, int16_t font, uint16_t options, int32_t n);
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
 
static inline void EVE_CoCmd_gradientA(EVE_HalContext *phost, int16_t x0, int16_t y0, uint32_t argb0, int16_t x1, int16_t y1, uint32_t argb1)
{
    EVE_MULTI_TARGET_CHECK(CMD_GRADIENTA, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dwwdwwd(phost, CMD_GRADIENTA, x0, y0, argb0, x1, y1, argb1);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
#else
 
#define EVE_CoCmd_gradientA(phost, x0, y0, argb0, x1, y1, argb1) EVE_COCMD_UNSUPPORTED(CMD_GRADIENTA, false)
 
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_calibrate(EVE_HalContext *phost);
 
static inline void EVE_CoCmd_spinner(EVE_HalContext *phost, int16_t x, int16_t y, uint16_t style, uint16_t scale)
{
    EVE_CoCmd_dwwww(phost, CMD_SPINNER, x, y, style, scale);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_stop(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_STOP);
}
 
static inline void EVE_CoCmd_track(EVE_HalContext *phost, int16_t x, int16_t y, int16_t w, int16_t h, int16_t tag)
{
    EVE_CoCmd_dwwwww(phost, CMD_TRACK, x, y, w, h, tag);
}
 
static inline void EVE_CoCmd_screenSaver(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_SCREENSAVER);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_sketch(EVE_HalContext *phost, int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t ptr, uint16_t format)
{
    EVE_CoCmd_dwwwwdw(phost, CMD_SKETCH, x, y, w, h, ptr, format);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_logo(EVE_HalContext *phost)
{
    EVE_CoCmd_d(phost, CMD_LOGO);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_cSketch(EVE_HalContext *phost, int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t ptr, uint16_t format, uint16_t freq)
{
#if defined(EVE_MULTI_GRAPHICS_TARGET) || (EVE_SUPPORT_CHIPID == EVE_FT801)
    if (EVE_CHIPID == EVE_FT801)
    {
        EVE_CoCmd_dwwwwdww(phost, CMD_CSKETCH, x, y, w, h, ptr, format, freq);
 
#if (EVE_DL_OPTIMIZE)
        phost->DlPrimitive = 0;
#endif
    }
    else
#endif
    {
        /* Simply fall back to regular sketch on non-FT801 platform */
        EVE_CoCmd_sketch(phost, x, y, w, h, ptr, format);
    }
}
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
 
static inline void EVE_CoCmd_playVideo(EVE_HalContext *phost, uint32_t options)
{
    EVE_MULTI_TARGET_CHECK(CMD_PLAYVIDEO, EVE_CHIPID >= EVE_FT810);
    EVE_CoCmd_dd(phost, CMD_PLAYVIDEO, options);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
 
    if (options & (OPT_FLASH | OPT_MEDIAFIFO))
    {
        /* WORKAROUND: CMD_PLAYVIDEO completes immediately, 
        but the command following it does not.
        Write a CMD_NOP command to behave as documented */
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
        if (EVE_CHIPID >= EVE_BT815)
            EVE_CoCmd_nop(phost);
        else
#endif
            EVE_CoCmd_memCpy(phost, 0, 0, 1);
    }
}
 
#else
 
#define EVE_CoCmd_playVideo(phost, options) EVE_COCMD_UNSUPPORTED(CMD_PLAYVIDEO, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
 
EVE_HAL_EXPORT bool EVE_CoCmd_animStart(EVE_HalContext *phost, int32_t ch, uint32_t aoptr, uint32_t loop);
 
static inline void EVE_CoCmd_animStop(EVE_HalContext *phost, int32_t ch)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMSTOP, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dd(phost, CMD_ANIMSTOP, ch);
}
 
static inline void EVE_CoCmd_animXY(EVE_HalContext *phost, int32_t ch, int16_t x, int16_t y)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMXY, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_ddww(phost, CMD_ANIMXY, ch, x, y);
}
 
static inline void EVE_CoCmd_animDraw(EVE_HalContext *phost, int32_t ch)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMDRAW, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dd(phost, CMD_ANIMDRAW, ch);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_animFrame(EVE_HalContext *phost, int16_t x, int16_t y, uint32_t aoptr, uint32_t frame)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMFRAME, EVE_CHIPID >= EVE_BT815);
    EVE_CoCmd_dwwdd(phost, CMD_ANIMFRAME, x, y, aoptr, frame);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
#else
 
#define EVE_CoCmd_animStart(phost, ch, aoptr, loop) EVE_COCMD_UNSUPPORTED(CMD_ANIMSTART, false)
#define EVE_CoCmd_animStop(phost, ch) EVE_COCMD_UNSUPPORTED(CMD_ANIMSTOP, false)
#define EVE_CoCmd_animXY(phost, ch, x, y) EVE_COCMD_UNSUPPORTED(CMD_ANIMXY, false)
#define EVE_CoCmd_animDraw(phost, ch) EVE_COCMD_UNSUPPORTED(CMD_ANIMDRAW, false)
#define EVE_CoCmd_animFrame(phost, x, y, aoptr, frame) EVE_COCMD_UNSUPPORTED(CMD_ANIMFRAME, false)
 
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
 
static inline void EVE_CoCmd_flashProgram(EVE_HalContext *phost, uint32_t dst, uint32_t src, uint32_t num)
{
    EVE_MULTI_TARGET_CHECK(CMD_FLASHPROGRAM, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dddd(phost, CMD_FLASHPROGRAM, dst, src, num);
}
 
EVE_HAL_EXPORT uint32_t EVE_CoCmd_calibrateSub(EVE_HalContext *phost, uint16_t x, uint16_t y, uint16_t w, uint16_t h);
 
static inline void EVE_CoCmd_testCard(EVE_HalContext *phost)
{
    EVE_MULTI_TARGET_CHECK(CMD_TESTCARD, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_d(phost, CMD_TESTCARD);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_animFrameRam(EVE_HalContext *phost, int16_t x, int16_t y, uint32_t aoptr, uint32_t frame)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMFRAMERAM, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dwwdd(phost, CMD_ANIMFRAMERAM, x, y, aoptr, frame);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
static inline void EVE_CoCmd_animStartRam(EVE_HalContext *phost, int32_t ch, uint32_t aoptr, uint32_t loop)
{
    EVE_MULTI_TARGET_CHECK(CMD_ANIMSTARTRAM, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_dddd(phost, CMD_ANIMSTARTRAM, ch, aoptr, loop);
}
 
static inline void EVE_CoCmd_runAnim(EVE_HalContext *phost, uint32_t waitmask, uint32_t play)
{
    EVE_MULTI_TARGET_CHECK(CMD_RUNANIM, EVE_CHIPID >= EVE_BT817);
    EVE_CoCmd_ddd(phost, CMD_RUNANIM, waitmask, play);
 
#if (EVE_DL_OPTIMIZE)
    phost->DlPrimitive = 0;
#endif
}
 
#else
 
#define EVE_CoCmd_calibrateSub(phost, x, y, w, h) EVE_COCMD_UNSUPPORTED(CMD_CALIBRATESUB, 0)
#define EVE_CoCmd_testCard(phost) EVE_COCMD_UNSUPPORTED(CMD_TESTCARD, false)
#define EVE_CoCmd_animFrameRam(phost, x, y, aoptr, frame) EVE_COCMD_UNSUPPORTED(CMD_ANIMFRAMERAM, false)
#define EVE_CoCmd_animStartRam(phost, ch, aoptr, loop) EVE_COCMD_UNSUPPORTED(CMD_ANIMSTARTRAM, false)
#define EVE_CoCmd_runAnim(phost, waitmask, play) EVE_COCMD_UNSUPPORTED(CMD_RUNANIM, false)
 
#endif
 
/**********************************************************************
***********************************************************************
**********************************************************************/
 
#endif /* EVE_CO_CMD__H */
 
/* end of file */