EVE_Util.c File Reference

EVE HAL framework utilities. More...

#include "EVE_Util.h"
#include "EVE_Platform.h"
#include "EVE_HalImpl.h"

Go to the source code of this file.

Macros
#define	EVE_HARDCODED_DISPLAY_TIMINGS   1
#define	EXTRACT_CHIPID(romChipId)   EVE_extendedChipId((((romChipId) >> 8) & 0xFF) | (((romChipId) & (0xFF)) << 8))
#define	EVE_SUBPATCH_PTR   0x7ffeU /* NOTE: This address is only valid for FT81X */
#define	EVE_VIDEOPATCH_ADDR   0x309162UL /* NOTE: This address is only valid for BT815 and BT816 */

Functions
EVE_HAL_EXPORT void	EVE_CoDlImpl_resetCoState (EVE_HalContext *phost)
static void	uploadTouchFirmware (EVE_HalContext *phost)
EVE_HAL_EXPORT void	EVE_Util_clearScreen (EVE_HalContext *phost)
	Clear the screen.
EVE_HAL_EXPORT void	EVE_Util_bootupDefaults (EVE_HalContext *phost, EVE_BootupParameters *bootup)
static bool	configDefaultsEx (EVE_HalContext *phost, EVE_ConfigParameters *config, uint32_t width, uint32_t height, uint32_t refreshRate, uint32_t hsfWidth, uint32_t freq)
EVE_HAL_EXPORT bool	EVE_Util_configDefaultsEx (EVE_HalContext *phost, EVE_ConfigParameters *config, uint32_t width, uint32_t height, uint32_t refreshRate, uint32_t hsfWidth)
EVE_HAL_EXPORT void	EVE_Util_configDefaults (EVE_HalContext *phost, EVE_ConfigParameters *config, EVE_DISPLAY_T display)
EVE_HAL_EXPORT bool	EVE_Util_bootup (EVE_HalContext *phost, EVE_BootupParameters *bootup)
EVE_HAL_EXPORT bool	EVE_Util_config (EVE_HalContext *phost, EVE_ConfigParameters *config)
EVE_HAL_EXPORT void	EVE_Util_shutdown (EVE_HalContext *phost)
static bool	EVE_Util_needsSubPatch (EVE_HalContext *phost)
static bool	EVE_Util_needsVideoPatch (EVE_HalContext *phost)
void	debugBackupRamG (EVE_HalContext *phost)
	Backup the last 128 bytes of RAM_G, which may be used for an error message.
static void	debugRestoreRamG (EVE_HalContext *phost)
EVE_HAL_EXPORT bool	EVE_Util_resetCoprocessor (EVE_HalContext *phost)
	Reset Coprocessor.
EVE_HAL_EXPORT bool	EVE_Util_bootupConfig (EVE_HalContext *phost)
	Bootup Coprocessor.
INTERACTIVE SETUP
bool	EVE_Util_openDeviceInteractive (EVE_HalContext *phost, const wchar_t *flashFile)
EVE_HAL_EXPORT bool	EVE_Util_bootupConfigInteractive (EVE_HalContext *phost, EVE_DISPLAY_T display)
	Calls EVE_Util_bootup and EVE_Util_config using the default parameters. Falls back to no interactivity on FT9XX platform.
void	EVE_Util_forceFault (EVE_HalContext *phost, const char *err)

Variables
static eve_progmem_const uint8_t	c_DlCodeBootup [12]
static const uint16_t	s_DisplayResolutions [EVE_DISPLAY_NB][4]

Detailed Description

EVE HAL framework utilities.

Author

Bridgetek

Date

2018

MIT License

Copyright (c) [2019] [Bridgetek Pte Ltd (BRTChip)]

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Definition in file EVE_Util.c.

Macro Definition Documentation

EVE_HARDCODED_DISPLAY_TIMINGS

#define EVE_HARDCODED_DISPLAY_TIMINGS   1

Definition at line 351 of file EVE_Util.c.

EVE_SUBPATCH_PTR

#define EVE_SUBPATCH_PTR   0x7ffeU /* NOTE: This address is only valid for FT81X */

Patch: OTP needs to be reactivated when the coprocessor is reset during CMD_LOGO Applicable to: FT81X-series

Definition at line 1688 of file EVE_Util.c.

EVE_VIDEOPATCH_ADDR

#define EVE_VIDEOPATCH_ADDR   0x309162UL /* NOTE: This address is only valid for BT815 and BT816 */

Patch: Video patch from OTP needs to be reapplied after coprocessor reset Applicable to: BT81X-series

Definition at line 1704 of file EVE_Util.c.

EXTRACT_CHIPID

#define EXTRACT_CHIPID

(

romChipId

)

EVE_extendedChipId((((romChipId) >> 8) & 0xFF) | (((romChipId) & (0xFF)) << 8))

Definition at line 1111 of file EVE_Util.c.

Function Documentation

configDefaultsEx()

static bool configDefaultsEx ( EVE_HalContext *  phost, EVE_ConfigParameters *  config, uint32_t  width, uint32_t  height, uint32_t  refreshRate, uint32_t  hsfWidth, uint32_t  freq  )

static

Parameters

phost	Pointer to Hal context
config
width
height
refreshRate
hsfWidth
freq

Returns

true True if successful

false False if error

Definition at line 445 of file EVE_Util.c.

{
    /* Only false if the output resolution will be wrong.
    Not affected by unsupported HSF or refreshRate */
    bool supportedResolution = true;
 
    uint32_t screenWidth;
    uint32_t pixels;
    uint32_t minCycles;
    uint32_t maxRate;
    uint32_t pclk;
 
    uint32_t cycles;
    uint32_t vcycle;
    uint32_t hcycle;
    uint32_t hoffset;
    uint32_t voffset;
    uint32_t hsync1;
    uint32_t vsync1;
 
#ifdef EVE_SUPPORT_HSF
    uint32_t maxFreq;
    uint32_t maxRatePass;
    uint32_t pclkFreq = 0;
#endif
 
    memset(config, 0, sizeof(EVE_ConfigParameters));
 
    /*
    Refresh rate is as follows:
    REG_VCYCLE * REG_HCYCLE * REG_PCLK is the number of clocks each frame takes,
    Divide REG_FREQUENCY by this number to get the frame refresh rate in Hz.
    REG_HCYCLE must be higher than REG_HSIZE, REG_VCYCLE must be higher than REG_VSIZE.
 
    By default, FT800 is at 48MHz, FT810 is at 60MHz, and BT815 is increased to 72MHz.
    User may configure this differently in `EVE_Util_bootup`.
 
    Clocks per frame by clock frequency at 60Hz:
    - 84MHz: 1400k
    - 72MHz: 1200k
    - 60MHz: 1000k
    - 48MHz: 800k
    - 36MHz: 600k
    - 24MHz: 400k
 
    Clocks required per frame by display resolution at 60Hz:
    Max PCLK at frequency: 24  36  48  60  72  84MHz
    - 320x240: 76.8k        5   7  10  13  15  18
    - 480x272: 130.56k      3   4   6   7   9  10
    */
 
    /* Trim oversize displays */
    if (EVE_CHIPID >= EVE_FT810)
    {
#ifdef EVE_SUPPORT_HSF
        if (hsfWidth >= width)
        {
            eve_printf_debug("Screen HSF width %i is too large, disabled\n", (int)config->HsfWidth);
            hsfWidth = 0;
            width = hsfWidth;
            supportedResolution = false;
        }
#endif
        if (width > 2047)
        {
            eve_printf_debug("Line buffer width %i is too large for this configuration\n", (int)config->Width);
            width = 2047;
            supportedResolution = false;
        }
        if (height > 2047)
        {
            eve_printf_debug("Screen height %i is too large for this configuration\n", (int)config->Height);
            height = 2047;
            supportedResolution = false;
        }
    }
    else
    {
        if (width > 493)
        {
            /* 494 and up are not reliable */
            eve_printf_debug("Screen width %i is too large for this configuration\n", (int)config->Width);
            width = 493;
            supportedResolution = false;
        }
        if (height > 511)
        {
            eve_printf_debug("Screen height %i is too large for this configuration\n", (int)config->Height);
            height = 511;
            supportedResolution = false;
        }
    }
 
#ifdef EVE_SUPPORT_HSF
    if (EVE_Hal_supportHsf(phost))
    {
        /* Render width */
        config->Width = (int16_t)width;
 
        /* Screen width */
        config->HsfWidth = (int16_t)hsfWidth;
 
        if (hsfWidth)
        {
        }
    }
    else
#endif
        if (hsfWidth)
    {
        /* Use the screen width if HSF is not supported */
        config->Width = (int16_t)hsfWidth;
        eve_printf_debug("Display config specifies HSF but not supported on this platform\n");
    }
    else
    {
        config->Width = (int16_t)width;
    }
    config->Height = (int16_t)height;
 
    screenWidth = hsfWidth ? hsfWidth : width; /* Use screen width for calculation */
    pixels = screenWidth * height;
 
    /* Calculate maximum refresh rate */
    minCycles = pixels + (pixels >> 2); /* pixels * 1.25 */
#ifdef EVE_SUPPORT_HSF
    maxRatePass = (freq - 1) / minCycles;
    maxFreq = (freq << 1) < 96000000 ? (freq << 1) : 96000000;
    if (hsfWidth)
        maxRate = maxRatePass; // No 2X
    else
        maxRate = maxFreq / minCycles; // Support 2X
#else
    maxRate = freq / minCycles;
#endif
 
    /* If the refresh rate is too low, try with tighter settings */
    if (refreshRate > maxRate)
    {
        minCycles = pixels + (pixels >> 3); /* pixels * 1.125 */
#ifdef EVE_SUPPORT_HSF
        maxRatePass = (freq - 1) / minCycles;
        if (hsfWidth)
            maxRate = maxRatePass; // No 2X
        else
            maxRate = maxFreq / minCycles; // Support 2X
#else
        maxRate = freq / minCycles;
#endif
    }
 
#ifdef EVE_SUPPORT_HSF
    if (EVE_Hal_supportHsf(phost) && (hsfWidth || refreshRate > maxRatePass))
    {
        /* Setup EXTSYNC with freq lower (not equal) than system frequency for HSF, up to 2X otherwise */
        /* LL2 frequency = 12MHz * REG_PCLK_FREQ[8:4] */
        /* PCLK frequency = PLL2 frequency / REG_PCLK_FREQ[3:0] / 2 */
        /* PCLK frequency = 6MHz * REG_PCLK_FREQ[8:4] / REG_PCLK_FREQ[3:0] */
        /* PCLK frequency = 6MHz * mul / div */
        int32_t wantFreq = minCycles * (refreshRate > maxRate ? maxRate : refreshRate); // 25.92m for 800x480
        config->PClkFreq = getPClkFreq(wantFreq);
        pclkFreq = getFreqFromPClkFreq(config->PClkFreq);
        if (pclkFreq)
            maxRate = pclkFreq / minCycles;
    }
#endif
 
#ifdef EVE_SUPPORT_HSF
    if (pclkFreq)
    {
        pclk = 1;
    }
    else
#endif
        if (maxRate < refreshRate)
    {
        /* Trim unsupported framerate */
        eve_printf_debug("Frame rate limited to %d\n", (unsigned int)maxRate);
        refreshRate = maxRate;
        pclk = 1;
    }
    else
    {
#ifdef EVE_SUPPORT_HSF
        pclk = maxRatePass / refreshRate;
#else
        pclk = maxRate / refreshRate;
#endif
    }
    config->PCLK = (uint8_t)pclk;
 
    /* Change PCLKPol if the right edge of the display is noisy,
    or if the display is showing jagged colors. Values 0 or 1.
    This toggles the polarity of the PCLK. */
    config->PCLKPol = 1; /* non-default */
 
    /* Approximate an average good setting */
#ifdef EVE_SUPPORT_HSF
    cycles = (pclkFreq ? pclkFreq : freq) / (refreshRate * pclk);
#else
    cycles = freq / (refreshRate * pclk);
#endif
    vcycle = height * cycles / pixels; /* max vcycle without blanking, on average 1.125x height, or 1.25x */
    vcycle = (vcycle + ((vcycle + height) >> 1) + height + height) >> 2; /* vcycle is 1.5 max vcycle + 2.5 height / 4, so on average 1.046875x height, or 1.09375x */
    hcycle = cycles / vcycle; /* cycles div by vcycle, on average 1.07375x, or 1.1425x */
    hoffset = (hcycle - screenWidth) >> 1;
    voffset = (vcycle - height) >> 1;
    hsync1 = hoffset >> 1;
    vsync1 = voffset >> 1;
    hoffset += hsync1;
    voffset += vsync1;
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    if (pclkFreq && pclkFreq >= freq)
    {
        hcycle &= ~1UL;
        hoffset &= ~1UL;
        hsync1 &= ~1UL;
    }
#endif
    config->HCycle = (int16_t)hcycle;
    config->HSync0 = 0;
    config->HSync1 = (int16_t)hsync1;
    config->HOffset = (int16_t)hoffset;
    config->VCycle = (int16_t)vcycle;
    config->VSync0 = 0;
    config->VSync1 = (int16_t)vsync1;
    config->VOffset = (int16_t)voffset;
 
    /* Verify */
    eve_assert(config->HSync1);
    eve_assert(config->HOffset > config->HSync1);
#ifdef EVE_SUPPORT_HSF
    eve_assert(config->HCycle > (config->HsfWidth ? config->HsfWidth : config->Width));
    eve_assert((config->HCycle - (config->HsfWidth ? config->HsfWidth : config->Width)) > config->HOffset);
#else
    eve_assert(config->HCycle > config->Width);
    eve_assert((config->HCycle - config->Width) > config->HOffset);
#endif
    eve_assert(config->VSync1);
    eve_assert(config->VOffset > config->VSync1);
    eve_assert(config->VCycle > config->Height);
    eve_assert((config->VCycle - config->Height) > config->VOffset);
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
#ifdef EVE_ADAPTIVE_FRAMERATE
    config->AdaptiveFramerate = 1;
#else
    config->AdaptiveFramerate = 0;
#endif
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    config->AhHCycleMax = 0;
#endif
 
    /* Other options */
    /* Toggle CSpread if you see red and blue fringing on black and white edges */
    config->CSpread = 0; /* non-default */
    /* Change this if RGB colors are swapped */
    config->Swizzle = 0;
 
    if (EVE_CHIPID == EVE_FT812
        || EVE_CHIPID == EVE_FT813
        || EVE_CHIPID == EVE_BT882
        || EVE_CHIPID == EVE_BT883
        || EVE_CHIPID >= EVE_BT815)
    {
        config->Dither = 0;
        config->OutBitsR = 8;
        config->OutBitsG = 8;
        config->OutBitsB = 8;
    }
    else
    {
        config->Dither = 1;
        config->OutBitsR = 6;
        config->OutBitsG = 6;
        config->OutBitsB = 6;
    }
 
    return supportedResolution;
}

debugBackupRamG()

void debugBackupRamG

(

EVE_HalContext *

phost

)

Backup the last 128 bytes of RAM_G, which may be used for an error message.

Parameters

phost

Pointer to Hal context

Definition at line 1722 of file EVE_Util.c.

{
    if (!phost->DebugMessageVisible)
    {
        EVE_Hal_rdMem(phost, phost->DebugBackup, RAM_G + RAM_G_SIZE - sizeof(phost->DebugBackup), sizeof(phost->DebugBackup));
        phost->DebugMessageVisible = true;
    }
}

debugRestoreRamG()

static void debugRestoreRamG ( EVE_HalContext *  phost )

static

Parameters

phost

Pointer to Hal context

Definition at line 1735 of file EVE_Util.c.

{
    if (phost->DebugMessageVisible)
    {
        EVE_Hal_wrMem(phost, RAM_G + RAM_G_SIZE - sizeof(phost->DebugBackup), phost->DebugBackup, sizeof(phost->DebugBackup));
        phost->DebugMessageVisible = false;
    }
}

EVE_CoDlImpl_resetCoState()

EVE_HAL_EXPORT void EVE_CoDlImpl_resetCoState

(

EVE_HalContext *

phost

)

Parameters

phost

Pointer to Hal context

Definition at line 83 of file EVE_CoDl.c.

{
#if (EVE_DL_OPTIMIZE)
    phost->CoFgColor = 0x003870;
    phost->CoBgColor = 0x002040;
    phost->CoBitmapTransform = false;
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
    if (EVE_CHIPID >= EVE_FT810)
    {
        phost->CoScratchHandle = 15;
    }
#endif
}

EVE_Util_bootup()

EVE_HAL_EXPORT bool EVE_Util_bootup	(	EVE_HalContext *	phost,
		EVE_BootupParameters *	bootup
	)

Parameters

phost	Pointer to Hal context
bootup

Returns

true True if successful

false False if error

Definition at line 1121 of file EVE_Util.c.

{
    /* IMPORTANT: Do not use EVE_CoCmd functions here, as they can be overridden by hooks */
 
    const uint32_t expectedChipId = EVE_CHIPID;
    uint8_t engineStatus;
    uint32_t chipId;
    uint8_t id;
 
    do
    {
        int tries = 0;
 
        /* EVE will be in SPI Single channel after POR */
        if (!EVE_Hal_powerCycle(phost, true))
            return false;
 
        if (bootup->ExternalOsc)
        {
            /* Set the clk to external clock. Must disable it when no external clock source on the board */
            EVE_Hal_hostCommand(phost, EVE_EXTERNAL_OSC);
            EVE_sleep(10);
        }
        else
        {
            /* Send CLKINT explicitly to play safe for all EVE series chip*/
            EVE_Hal_hostCommand(phost, EVE_INTERNAL_OSC);
            EVE_sleep(10);
        }
 
        /* Update system clock as per user selected */
        if (bootup->SystemClock)
        {
            EVE_Host_selectSysClk(phost, bootup->SystemClock);
        }
 
        /* Access address 0 to wake up the FT800 */
        EVE_Hal_hostCommand(phost, EVE_ACTIVE_M);
        EVE_sleep(300);
 
        EVE_Host_coreReset(phost);
        /* Wait for valid chip ID */
        chipId = EVE_Hal_rd32(phost, ROM_CHIPID);
        while (EXTRACT_CHIPID(chipId) < EVE_FT800
            || EXTRACT_CHIPID(chipId) > EVE_BT818)
        {
            eve_printf_debug("EVE ROM_CHIPID after wake up %lx\n", (unsigned long)chipId);
 
            ++tries;
            EVE_sleep(20);
            if (phost->CbCmdWait && !phost->CbCmdWait(phost))
                return false;
 
            chipId = EVE_Hal_rd32(phost, ROM_CHIPID);
 
#ifdef EVE_MULTI_TARGET
            /* Turn off external clock if chipId reads incorrectly for 4 times */
            /* When not targeting multiple boards, set the EVE_USE_INTERNAL_OSC preprocessor variable, or configure the ExternalOsc parameter at runtime */
            if (tries >= 4)
            {
                bootup->ExternalOsc = !bootup->ExternalOsc;
                eve_printf_debug("Reattempting bootup with ExternalOsc changed from %s to %s\n", bootup->ExternalOsc ? "OFF" : "ON", bootup->ExternalOsc ? "ON" : "OFF");
 
                EVE_Host_powerModeSwitch(phost, EVE_SLEEP_M); /* Put EVE into Sleep mode, prepare for clock selection */
                chipId = 0; //In case chipId is not zero
                break;
            }
#endif
        }
    } while (!chipId);
 
    /* Validate chip ID to ensure the correct HAL is used */
    /* ROM_CHIPID is valid across all EVE devices */
    if (expectedChipId && EXTRACT_CHIPID(chipId) != expectedChipId)
        eve_printf_debug("Mismatching EVE chip id %lx, expect model %lx\n", (unsigned long)((chipId >> 8) & 0xFF) | ((chipId & 0xFF) << 8), (unsigned long)expectedChipId);
    eve_printf_debug("EVE chip id %lx %lx.%lx (EVE gen %i)\n", (unsigned long)EVE_shortChipId(EXTRACT_CHIPID(chipId)), (unsigned long)((chipId >> 16) & 0xFF), (unsigned long)((chipId >> 24) & 0xFF), EVE_gen(EXTRACT_CHIPID(chipId)));
 
    /* Switch to the proper chip ID if applicable */
#ifdef EVE_MULTI_GRAPHICS_TARGET
    phost->ChipId = EXTRACT_CHIPID(chipId);
    if (phost->ChipId >= EVE_BT815)
        phost->GpuDefs = &EVE_GpuDefs_BT81X;
    else if (phost->ChipId >= EVE_BT880)
        phost->GpuDefs = &EVE_GpuDefs_BT88X;
    else if (phost->ChipId >= EVE_FT810)
        phost->GpuDefs = &EVE_GpuDefs_FT81X;
    else if (phost->ChipId >= EVE_FT800)
        phost->GpuDefs = &EVE_GpuDefs_FT80X;
#endif
 
    /* Turn off previous audio playback (in case powerdown is not connected) */
    EVE_Hal_wr32(phost, REG_PLAYBACK_LENGTH, 0);
 
#ifdef EVE_MULTI_GRAPHICS_TARGET
    /* The default clock configuration is only set when the graphics target is known at compile time */
    if (!bootup->SystemClock)
    {
        if (phost->ChipId >= EVE_BT815)
        {
            /* No clock was set, but we want 72MHz default for BT81X and up */
            eve_printf_debug("Set system clock PLL to 72MHz\n");
            bootup->SystemClock = EVE_SYSCLK_72M;
 
            /* Sleep */
            EVE_Hal_hostCommand(phost, EVE_SLEEP_M);
            EVE_sleep(300);
 
            /* Update system clock */
            EVE_Host_selectSysClk(phost, bootup->SystemClock);
 
            /* Access address 0 to wake up the FT800 */
            EVE_Hal_hostCommand(phost, EVE_ACTIVE_M);
            EVE_sleep(300);
        }
        else if (phost->ChipId >= EVE_FT810)
        {
            /* Assume the default */
            bootup->SystemClock = EVE_SYSCLK_60M;
        }
    }
#endif
 
    /* Read Register ID to check if EVE is ready. */
    while ((id = EVE_Hal_rd8(phost, REG_ID)) != 0x7C)
    {
        eve_printf_debug("EVE register ID after wake up %x\n", (unsigned int)id);
 
        EVE_sleep(20);
        if (phost->CbCmdWait && !phost->CbCmdWait(phost))
            return false;
    }
    eve_printf_debug("EVE register ID after wake up %x\n", (unsigned int)id);
    eve_assert(chipId == EVE_Hal_rd32(phost, ROM_CHIPID));
 
    /* Read REG_CPURESET to check if engines are ready.
        Bit 0 for coprocessor engine,
        Bit 1 for touch engine,
        Bit 2 for audio engine.
    */
    while ((engineStatus = EVE_Hal_rd8(phost, REG_CPURESET)) != 0x00)
    {
        if (engineStatus & 0x01)
        {
            eve_printf_debug("Coprocessor engine is not ready\n");
        }
        if (engineStatus & 0x02)
        {
            eve_printf_debug("Touch engine is not ready\n");
            if (EVE_HOST == EVE_HOST_BT8XXEMU) // FIXME: Emulator REG_CPURESET bits behaviour on FT800 and FT801 doesn't match
            {
                EVE_Hal_wr8(phost, REG_CPURESET, 0);
            }
        }
        if (engineStatus & 0x04)
        {
            eve_printf_debug("Audio engine is not ready\n");
        }
 
        EVE_sleep(20);
        if (phost->CbCmdWait && !phost->CbCmdWait(phost))
            return false;
    }
    eve_printf_debug("All engines are ready\n");
 
    /* Update REG_FREQUENCY as per user selected */
    if (bootup->SystemClock != EVE_SYSCLK_DEFAULT)
    {
        uint32_t clockMHz = bootup->SystemClock * 12;
        EVE_Hal_wr32(phost, REG_FREQUENCY, clockMHz * 1000 * 1000);
        EVE_Hal_flush(phost);
        eve_printf_debug("EVE clock frequency set to %d MHz\n", (unsigned int)clockMHz);
    }
    else
    {
        eve_printf_debug("EVE default clock is %d MHz\n", (unsigned int)(EVE_Hal_rd32(phost, REG_FREQUENCY) / 1000000));
    }
 
    /* Switch to configured default SPI channel mode */
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
    if (EVE_CHIPID >= EVE_FT810)
    {
        EVE_Hal_setSPI(phost, bootup->SpiChannels, bootup->SpiDummyBytes);
#ifdef _DEBUG
        const char *spiChannels = (phost->SpiChannels == EVE_SPI_QUAD_CHANNEL)
            ? "Quad"
            : ((phost->SpiChannels == EVE_SPI_DUAL_CHANNEL) ? "Dual" : "Single");
        const char *requested = (bootup->SpiChannels == EVE_SPI_QUAD_CHANNEL)
            ? "Quad"
            : ((bootup->SpiChannels == EVE_SPI_DUAL_CHANNEL) ? "Dual" : "Single");
        if (bootup->SpiChannels == phost->SpiChannels)
            eve_printf_debug("%s channel SPI\n", spiChannels);
        else
            eve_printf_debug("%s channel SPI (%s unsupported)\n", spiChannels, requested);
#endif
    }
#endif
 
    /* In some cases, for example, QSPI on MM817EV board with MM930LITE, 
       the drive strength is required to adjust for better signal integrity. 
       Setting to max current 20mA here is to play safe.  Users may adjust the 
       corresponding bits of REG_GPIOX according to their own situation. */
    if (EVE_CHIPID >= EVE_FT810)
    {
        EVE_Hal_wr16(phost, REG_GPIOX_DIR, 0xffff);
        EVE_Hal_wr16(phost, REG_GPIOX, 0xffff);
    }
    else
    {
        EVE_Hal_wr8(phost, REG_GPIO_DIR, 0xff);
        EVE_Hal_wr8(phost, REG_GPIO, 0xff);
    }
 
    /* Update touch firmware */
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 6285)
#endif
    if ((EVE_CHIPID == EVE_FT811 || EVE_CHIPID == EVE_FT813) && (EVE_HOST != EVE_HOST_BT8XXEMU))
#ifdef _MSC_VER
#pragma warning(pop)
#endif
    {
#if defined(PANL70) || defined(PANL70PLUS)
        EVE_Hal_wr8(phost, REG_CPURESET, 2);
        EVE_Hal_wr16(phost, REG_TOUCH_CONFIG, 0x05d0);
#endif
        /* Download new firmware to fix pen up issue */
        /* It may cause resistive touch not working any more*/
        uploadTouchFirmware(phost);
#if defined(PANL70) || defined(PANL70PLUS)
        EVE_UtilImpl_bootupDisplayGpio(phost);
#endif
        EVE_Hal_flush(phost);
        EVE_sleep(100);
    }
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 6285)
#endif
    if ((EVE_CHIPID == EVE_BT815 || EVE_CHIPID == EVE_BT817) && (EVE_HOST != EVE_HOST_BT8XXEMU))
#ifdef _MSC_VER
#pragma warning(pop)
#endif
    {
#if defined(DISPLAY_RESOLUTION_WXGA)
        //Assume WXGA is using Goodix touch IC
        //To be fixed: use macro for touch configuration
        eve_printf_debug("Setup touch for Goodix\n");
        EVE_Hal_wr8(phost, REG_CPURESET, 2);
        EVE_Hal_wr16(phost, REG_TOUCH_CONFIG, 0x05d0);
        EVE_Hal_wr8(phost, REG_CPURESET, 0);
#endif
    }
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
#ifdef EVE_TOUCH_GOODIX
    eve_printf_debug("Goodix configuration\n");
    EVE_Hal_wr8(phost, REG_CPURESET, 2);
    EVE_Hal_wr16(phost, REG_TOUCH_CONFIG, 0x05d0);
    EVE_Hal_wr8(phost, REG_CPURESET, 0);
#endif
#endif
 
    return true;
}

EVE_Util_bootupConfig()

EVE_HAL_EXPORT bool EVE_Util_bootupConfig

(

EVE_HalContext *

phost

)

Bootup Coprocessor.

Parameters

phost

Pointer to Hal context

Returns

true True if successful

false False if error

Definition at line 1898 of file EVE_Util.c.

{
    EVE_BootupParameters bootup;
    EVE_ConfigParameters config;
 
    EVE_Util_bootupDefaults(phost, &bootup);
    if (!EVE_Util_bootup(phost, &bootup))
    {
        return false;
    }
 
    EVE_Util_configDefaults(phost, &config, EVE_DISPLAY_DEFAULT);
    if (!EVE_Util_config(phost, &config))
    {
        EVE_Util_shutdown(phost);
        return false;
    }
 
    return true;
}

EVE_Util_bootupConfigInteractive()

EVE_HAL_EXPORT bool EVE_Util_bootupConfigInteractive	(	EVE_HalContext *	phost,
		EVE_DISPLAY_T	display
	)

Calls EVE_Util_bootup and EVE_Util_config using the default parameters. Falls back to no interactivity on FT9XX platform.

Parameters

phost	Pointer to Hal context
display

Returns

true True if successful

false False if error

Definition at line 2582 of file EVE_Util.c.

{
    EVE_DISPLAY_T selectedDisplay;
    EVE_BootupParameters bootup;
    EVE_ConfigParameters config;
 
    EVE_Util_bootupDefaults(phost, &bootup);
    if (!EVE_Util_bootup(phost, &bootup))
    {
        return false;
    }
 
    EVE_Util_selectDisplayInteractive(&selectedDisplay);
    if (!selectedDisplay)
        selectedDisplay = display;
 
    EVE_Util_configDefaults(phost, &config, selectedDisplay);
    if (!EVE_Util_config(phost, &config))
    {
        EVE_Util_shutdown(phost);
        return false;
    }
 
    return true;
}

EVE_Util_bootupDefaults()

EVE_HAL_EXPORT void EVE_Util_bootupDefaults	(	EVE_HalContext *	phost,
		EVE_BootupParameters *	bootup
	)

Parameters

phost	Pointer to Hal context
bootup

Definition at line 282 of file EVE_Util.c.

{
    int32_t chipId = EVE_CHIPID;
    (void)chipId;
 
    memset(bootup, 0, sizeof(EVE_BootupParameters));
 
#if !defined(EVE_USE_INTERNAL_OSC)
    /* Board without external oscillator will not work when ExternalOsc is enabled */
    bootup->ExternalOsc = true;
#endif
 
#ifdef EVE_SYSTEM_CLOCK
    bootup->SystemClock = EVE_SYSTEM_CLOCK;
#else
    if (chipId >= EVE_FT800 && chipId <= EVE_BT818)
    {
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
        if (chipId >= EVE_BT815)
        {
            bootup->SystemClock = EVE_SYSCLK_72M; /* 72Mhz is default for BT8xx */
        }
        else
#endif
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
            if (chipId >= EVE_FT810)
        {
            bootup->SystemClock = EVE_SYSCLK_60M; /* 60Mhz is default for FT81x */
        }
        else
#endif
        {
            bootup->SystemClock = EVE_SYSCLK_48M; /* 48Mhz is default for FT80x */
        }
    }
    else
    {
        /* If the chipid is not known yet, this will reconfigure the system clock during `EVE_Util_bootup`.
        Additional default clock overrides need to be implemented there as well. */
        bootup->SystemClock = EVE_SYSCLK_DEFAULT;
    }
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
#if defined(EVE_MULTI_PLATFORM_TARGET)
    if (EVE_HOST == EVE_HOST_FT4222)
    {
        bootup->SpiChannels = EVE_SPI_QUAD_CHANNEL;
        bootup->SpiDummyBytes = 2;
    }
    else
    {
        bootup->SpiChannels = EVE_SPI_SINGLE_CHANNEL;
        bootup->SpiDummyBytes = 1;
    }
#elif defined(ENABLE_SPI_QUAD)
    bootup->SpiChannels = EVE_SPI_QUAD_CHANNEL;
    bootup->SpiDummyBytes = 2;
#elif defined(ENABLE_SPI_DUAL)
    bootup->SpiChannels = EVE_SPI_DUAL_CHANNEL;
    bootup->SpiDummyBytes = 2;
#else
    bootup->SpiChannels = EVE_SPI_SINGLE_CHANNEL;
    bootup->SpiDummyBytes = 1;
#endif
#endif
}

EVE_Util_clearScreen()

EVE_HAL_EXPORT void EVE_Util_clearScreen

(

EVE_HalContext *

phost

)

Clear the screen.

Parameters

phost

Pointer to Hal context

Definition at line 270 of file EVE_Util.c.

{
    EVE_Hal_wrProgMem(phost, RAM_DL, c_DlCodeBootup, sizeof(c_DlCodeBootup));
    EVE_Hal_wr8(phost, REG_DLSWAP, DLSWAP_FRAME);
}

EVE_Util_config()

EVE_HAL_EXPORT bool EVE_Util_config	(	EVE_HalContext *	phost,
		EVE_ConfigParameters *	config
	)

Parameters

phost	Pointer to Hal context
config

Returns

true True if successful

false False if error

Definition at line 1396 of file EVE_Util.c.

{
    /* IMPORTANT: Do not use EVE_CoCmd functions here, as they can be overridden by hooks */
 
    bool reconfigure = phost->PCLK;
    if (reconfigure)
    {
        /* If PCLK is already set, we're reconfiguring. Quiet flush first */
        eve_printf_debug("Reconfiguring\n");
        EVE_Cmd_waitFlush(phost);
    }
 
    const bool swapXY = EVE_CHIPID >= EVE_FT810 ? EVE_Hal_rd8(phost, REG_ROTATE) & 0x2 : false;
    uint16_t wp;
    uint16_t rp;
 
    if (EVE_CHIPID < EVE_FT810)
    {
        eve_assert(config->Width < 512);
        eve_assert(config->Height < 512);
    }
    else
    {
        eve_assert(config->Width < 2048);
        eve_assert(config->Height < 2048);
    }
 
    /* Turn off display output clock */
    EVE_Hal_wr8(phost, REG_PCLK, 0);
    phost->PCLK = 0;
 
    EVE_Hal_wr16(phost, REG_HCYCLE, config->HCycle);
    EVE_Hal_wr16(phost, REG_HOFFSET, config->HOffset);
    EVE_Hal_wr16(phost, REG_HSYNC0, config->HSync0);
    EVE_Hal_wr16(phost, REG_HSYNC1, config->HSync1);
    EVE_Hal_wr16(phost, REG_VCYCLE, config->VCycle);
    EVE_Hal_wr16(phost, REG_VOFFSET, config->VOffset);
    EVE_Hal_wr16(phost, REG_VSYNC0, config->VSync0);
    EVE_Hal_wr16(phost, REG_VSYNC1, config->VSync1);
    EVE_Hal_wr8(phost, REG_SWIZZLE, config->Swizzle);
    EVE_Hal_wr8(phost, REG_PCLK_POL, config->PCLKPol);
    EVE_Hal_wr16(phost, REG_HSIZE, config->Width);
    EVE_Hal_wr16(phost, REG_VSIZE, config->Height);
    EVE_Hal_wr16(phost, REG_CSPREAD, config->CSpread);
    EVE_Hal_wr16(phost, REG_DITHER, config->Dither);
    EVE_Hal_wr16(phost, REG_OUTBITS,
        (uint16_t)(((config->OutBitsR & 0x7) << 6)
            | ((config->OutBitsG & 0x7) << 3)
            | (config->OutBitsB & 0x7)));
    if (swapXY)
    {
        phost->Width = config->Height;
        phost->Height = config->Width;
    }
    else
    {
        phost->Width = config->Width;
        phost->Height = config->Height;
    }
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    bool pclk2X = false;
    if (EVE_CHIPID >= EVE_BT817)
    {
        uint32_t freq = EVE_Hal_rd32(phost, REG_FREQUENCY);
        uint16_t pclkFreq = config->PClkFreq;
        if (!pclkFreq)
        {
            /* If not configured, match system frequency, in case a legacy configuration with PClk 1 is specified */
            /* PClk Freq is 60MHz by default, but we raise the system frequency to 72MHz during bootup */
            uint32_t refMul = freq / 6000000;
            uint32_t pllFreq = 12 * refMul;
            uint32_t range = pllFreq >= 160 ? 3 : (pllFreq >= 80 ? 2 : (pllFreq >= 40 ? 1 : 0));
            pclkFreq = 1 | ((refMul & 0x3F) << 4) | (range << 10);
        }
        EVE_Hal_wr32(phost, REG_PCLK_FREQ, pclkFreq);
        if (config->PClk2X)
        {
            /* User forces 2X */
            EVE_Hal_wr8(phost, REG_PCLK_2X, 1);
        }
        else if (config->PCLK == 1)
        {
            /* Send two pixels per system clock to the EXTSYNC block if PCLK_frequency > SystemClock */
            uint32_t pclkFrequency = getFreqFromPClkFreq(pclkFreq);
            pclk2X = pclkFrequency > freq;
            EVE_Hal_wr8(phost, REG_PCLK_2X, pclk2X);
        }
        else
        {
            EVE_Hal_wr8(phost, REG_PCLK_2X, 0);
        }
    }
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
    if (EVE_CHIPID >= EVE_BT815)
    {
        EVE_Hal_wr8(phost, REG_ADAPTIVE_FRAMERATE, config->AdaptiveFramerate);
    }
#endif
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    if (EVE_CHIPID >= EVE_BT817)
    {
        EVE_Hal_wr16(phost, REG_AH_HCYCLE_MAX, config->AhHCycleMax);
    }
#endif
 
#ifdef RESISTANCE_THRESHOLD /* TODO: From config */
    if (EVE_Hal_isScreenResistive(phost))
    {
        /* Touch configuration - configure the resistance value to 1200 - this value is specific to customer requirement and derived by experiment */
        /* TODO: From config */
        EVE_Hal_wr16(phost, REG_TOUCH_RZTHRESH, RESISTANCE_THRESHOLD);
    }
#endif
 
    EVE_Util_clearScreen(phost);
 
    /* Refresh fifo */
    wp = EVE_Cmd_wp(phost);
    rp = EVE_Cmd_rp(phost);
    EVE_Cmd_space(phost);
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
    if (EVE_CHIPID >= EVE_FT810)
    {
        phost->MediaFifoAddress = 0;
        phost->MediaFifoSize = 0;
    }
#endif
 
    /* Coprocessor needs a reset */
    if (reconfigure ? EVE_CMD_FAULT(rp) : (wp || rp))
    {
        /* If this occurs after powerdown and bootup, powerdown is not working */
        eve_printf_debug("Coprocessor fifo not empty\n");
        if (!EVE_Util_resetCoprocessor(phost))
            return false;
    }
    else
    {
        /* Setup coprocessor defaults */
        eve_printf_debug("Configure coprocessor defaults\n");
        EVE_Cmd_wr32(phost, CMD_DLSTART);
        EVE_Cmd_wr32(phost, CMD_COLDSTART);
 
        /* Set the latest API level.
        CMD_APILEVEL applicable since BT817. */
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
        if (EVE_CHIPID >= EVE_BT817)
        {
            EVE_Cmd_wr32(phost, CMD_APILEVEL);
            EVE_Cmd_wr32(phost, 2);
        }
#endif
 
#ifdef EVE_FLASH_AVAILABLE
        if (EVE_CHIPID >= EVE_BT815)
        {
            /* Reattach flash to avoid inconsistent state */
            EVE_Cmd_wr32(phost, CMD_FLASHDETACH);
            EVE_Cmd_wr32(phost, CMD_FLASHATTACH);
        }
#endif
 
        EVE_CoDlImpl_resetCoState(phost);
    }
 
#ifdef EVE_SUPPORT_HSF
    if (config->HsfWidth)
    {
        if (EVE_Hal_supportHsf(phost) && !pclk2X)
        {
            EVE_Cmd_startFunc(phost);
            EVE_Cmd_wr32(phost, CMD_HSF);
            EVE_Cmd_wr32(phost, config->HsfWidth);
            EVE_Cmd_endFunc(phost);
        }
        else
        {
            /* Set width to screen width if HSF is not supported here */
            eve_printf_debug("HSF specified but not supported on this device\n");
            EVE_Hal_wr16(phost, REG_HSIZE, config->HsfWidth);
            if (swapXY)
                phost->Height = config->HsfWidth;
            else
                phost->Width = config->HsfWidth;
        }
    }
#endif
 
    EVE_Hal_flush(phost);
    if (!EVE_Cmd_waitFlush(phost))
        return false;
 
    EVE_Hal_wr8(phost, REG_PCLK, config->PCLK); /* After this display is visible on the LCD */
    phost->PCLK = config->PCLK;
 
#ifdef EVE_SUPPORT_HSF
    if (config->HsfWidth)
    {
        if (EVE_Hal_supportHsf(phost))
        {
            eve_printf_debug("HSize: %i, HSF HSize: %i\n", EVE_Hal_rd32(phost, REG_HSIZE), EVE_Hal_rd32(phost, REG_HSF_HSIZE));
        }
    }
#endif
 
#if (defined(ENABLE_ILI9488_HVGA_PORTRAIT) || defined(ENABLE_KD2401_HVGA_PORTRAIT))
    /* to cross check reset pin */
    EVE_Hal_wr8(phost, REG_GPIO, 0xff);
    EVE_Hal_flush(phost);
    EVE_sleep(120);
    EVE_Hal_wr8(phost, REG_GPIO, 0x7f);
    EVE_Hal_flush(phost);
    EVE_sleep(120);
    EVE_Hal_wr8(phost, REG_GPIO, 0xff);
    EVE_Hal_flush(phost);
    EVE_sleep(120);
#endif
 
#if defined(ENABLE_ILI9488_HVGA_PORTRAIT) || defined(ENABLE_KD2401_HVGA_PORTRAIT)
#if defined(RP2040_PLATFORM)
    EVE_ILI9488_RP2040_bootup(phost);
    eve_printf_debug("after ILI9488 RP2040 bootup\n");
    EVE_Hal_restoreSPI(phost);
#endif
#if defined(FT9XX_PLATFORM)
    EVE_ILI9488_bootup();
    eve_printf_debug("after ILI9488 bootup\n");
    EVE_Hal_restoreSPI(phost);
#endif
#endif
 
#if 0
    eve_printf_debug("REG_HSIZE: %i\n", (int)EVE_Hal_rd16(phost, REG_HSIZE));
    eve_printf_debug("REG_VSIZE: %i\n", (int)EVE_Hal_rd16(phost, REG_VSIZE));
    eve_printf_debug("REG_HCYCLE: %i\n", (int)EVE_Hal_rd16(phost, REG_HCYCLE));
    eve_printf_debug("REG_HOFFSET: %i\n", (int)EVE_Hal_rd16(phost, REG_HOFFSET));
    eve_printf_debug("REG_HSYNC0: %i\n", (int)EVE_Hal_rd16(phost, REG_HSYNC0));
    eve_printf_debug("REG_HSYNC1: %i\n", (int)EVE_Hal_rd16(phost, REG_HSYNC1));
    eve_printf_debug("REG_VCYCLE: %i\n", (int)EVE_Hal_rd16(phost, REG_VCYCLE));
    eve_printf_debug("REG_VOFFSET: %i\n", (int)EVE_Hal_rd16(phost, REG_VOFFSET));
    eve_printf_debug("REG_VSYNC0: %i\n", (int)EVE_Hal_rd16(phost, REG_VSYNC0));
    eve_printf_debug("REG_VSYNC1: %i\n", (int)EVE_Hal_rd16(phost, REG_VSYNC1));
    eve_printf_debug("REG_PCLK: %i\n", (int)EVE_Hal_rd16(phost, REG_PCLK));
    eve_printf_debug("REG_SWIZZLE: %i\n", (int)EVE_Hal_rd16(phost, REG_SWIZZLE));
    eve_printf_debug("REG_PCLK_POL: %i\n", (int)EVE_Hal_rd16(phost, REG_PCLK_POL));
    eve_printf_debug("REG_CSPREAD: %i\n", (int)EVE_Hal_rd16(phost, REG_CSPREAD));
    eve_printf_debug("REG_OUTBITS: %i\n", (int)EVE_Hal_rd16(phost, REG_OUTBITS));
    eve_printf_debug("REG_DITHER: %i\n", (int)EVE_Hal_rd16(phost, REG_DITHER));
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
    eve_printf_debug("REG_ADAPTIVE_FRAMERATE: %i\n", (int)EVE_Hal_rd16(phost, REG_ADAPTIVE_FRAMERATE));
#endif
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    eve_printf_debug("REG_PCLK_FREQ: %X\n", (int)EVE_Hal_rd16(phost, REG_PCLK_FREQ));
    eve_printf_debug("REG_AH_HCYCLE_MAX: %i\n", (int)EVE_Hal_rd16(phost, REG_AH_HCYCLE_MAX));
    eve_printf_debug("REG_HSF_HSIZE: %i\n", (int)EVE_Hal_rd16(phost, REG_HSF_HSIZE));
#endif
#endif
 
    eve_printf_debug("EVE configuration ready\n");
    return true;
}

EVE_Util_configDefaults()

EVE_HAL_EXPORT void EVE_Util_configDefaults	(	EVE_HalContext *	phost,
		EVE_ConfigParameters *	config,
		EVE_DISPLAY_T	display
	)

Parameters

phost	Pointer to Hal context
config
display

Definition at line 765 of file EVE_Util.c.

{
    bool supportedResolution;
    uint32_t freq = EVE_Hal_rd32(phost, REG_FREQUENCY);
    uint32_t width;
    uint32_t height;
    uint32_t refreshRate;
    uint32_t hsfWidth;
 
    /* NOTE: Update `EVE_DISPLAY_T` in `EVE_Util.h` when adding display presets. */
    if (!display)
    {
        /* Default displays if none was explicitly chosen */
#if defined(DISPLAY_RESOLUTION_QVGA)
        display = EVE_DISPLAY_QVGA_320x240_56Hz;
#elif defined(DISPLAY_RESOLUTION_WQVGA)
        display = EVE_DISPLAY_WQVGA_480x272_60Hz;
#elif defined(DISPLAY_RESOLUTION_WVGA)
#if defined(EVE_GRAPHICS_IDM2040)
        display = EVE_DISPLAY_WVGA_800x480_W860_60Hz;
#else
        display = EVE_DISPLAY_WVGA_800x480_74Hz;
#endif
#elif defined(DISPLAY_RESOLUTION_WSVGA)
        display = EVE_DISPLAY_WSVGA_1024x600_59Hz;
#elif defined(DISPLAY_RESOLUTION_HDTV)
        display = EVE_DISPLAY_HDTV_1280x720_58Hz;
#elif defined(DISPLAY_RESOLUTION_WXGA)
        display = EVE_DISPLAY_WXGA_1280x800_57Hz;
#elif defined(DISPLAY_RESOLUTION_HVGA_PORTRAIT)
        display = EVE_DISPLAY_HVGA_320x480_60Hz;
#else
        if (EVE_CHIPID >= EVE_BT817)
            display = EVE_DISPLAY_WXGA_1280x800_57Hz;
        else if (EVE_CHIPID >= EVE_BT815)
            display = EVE_DISPLAY_WVGA_800x480_74Hz;
        else if (EVE_CHIPID >= EVE_FT810)
            display = EVE_DISPLAY_WVGA_800x480_74Hz;
        else if (EVE_CHIPID >= EVE_FT800)
            display = EVE_DISPLAY_WQVGA_480x272_60Hz;
#endif
    }
 
    width = s_DisplayResolutions[display][0];
    height = s_DisplayResolutions[display][1];
#if EVE_DISPLAY_REFRESH
    refreshRate = EVE_DISPLAY_REFRESH;
#else
    refreshRate = s_DisplayResolutions[display][2];
#endif
    hsfWidth = s_DisplayResolutions[display][3];
    supportedResolution = configDefaultsEx(phost, config, width, height, refreshRate, hsfWidth, freq);
 
    /* Known values for specific display models */
#if EVE_DISPLAY_REFRESH
    if (EVE_DISPLAY_REFRESH != s_DisplayResolutions[display][2])
    {
        /* Don't use known preset values if the requested refresh rate differs from the default */
    }
    else
#endif
        if (display == EVE_DISPLAY_QVGA_320x240_56Hz && freq == 48000000)
    {
        /*
        FT800 known values:
        Resolution: 320x240
        Refresh rate: 55.916Hz
        */
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (supportedResolution)
        {
            config->Width = 320;
            config->Height = 240;
            config->HCycle = 408;
            config->HOffset = 70;
            config->HSync0 = 0;
            config->HSync1 = 10;
            config->VCycle = 263;
            config->VOffset = 13;
            config->VSync0 = 0;
            config->VSync1 = 2;
            config->PCLK = 8;
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
            config->PClkFreq = 0;
#endif
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
        config->Swizzle = 2;
        config->PCLKPol = 0;
        config->CSpread = 1;
        config->Dither = 1;
    }
    else if (display == EVE_DISPLAY_WQVGA_480x272_60Hz && freq == 48000000)
    {
        /*
        FT800 known values:
        Display: LBL-T050BPH-01
        REG_FREQUENCY: 48MHz
        REG_PCLK: 5
        REG_HCYCLE: 548
        REG_VCYCLE: 292
        Resolution: 480x272
        Refresh rate: 59.994Hz
        */
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (supportedResolution)
        {
            config->Width = 480;
            config->Height = 272;
            config->HCycle = 548;
            config->HOffset = 43;
            config->HSync0 = 0;
            config->HSync1 = 41;
            config->VCycle = 292;
            config->VOffset = 12;
            config->VSync0 = 0;
            config->VSync1 = 10;
            config->PCLK = 5;
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
            config->PClkFreq = 0;
#endif
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
    }
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    else if (display == EVE_DISPLAY_WQVGA_480x272_60Hz && EVE_CHIPID >= EVE_BT817)
    {
        /* Same as above, but using PClkFreq */
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (supportedResolution)
        {
            config->Width = 480;
            config->Height = 272;
            config->HCycle = 548;
            config->HOffset = 43;
            config->HSync0 = 0;
            config->HSync1 = 41;
            config->VCycle = 292;
            config->VOffset = 12;
            config->VSync0 = 0;
            config->VSync1 = 10;
            config->PCLK = 1;
            config->PClkFreq = 0x885; // 9.6MHz
            config->HsfWidth = 0;
        }
#endif
    }
#endif
    else if (display == EVE_DISPLAY_WVGA_800x480_74Hz && freq == 72000000)
    {
        /*
        BT81X known values:
        Display: MTF070TN83-V1
        REG_FREQUENCY: 72MHz
        Resolution: 800x480
        Refresh rate: 73.892Hz
        */
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (supportedResolution)
        {
            config->Width = 800;
            config->Height = 480;
            config->HCycle = 928;
            config->HOffset = 88;
            config->HSync0 = 0;
            config->HSync1 = 48;
            config->VCycle = 525;
            config->VOffset = 32;
            config->VSync0 = 0;
            config->VSync1 = 3;
            config->PCLK = 2;
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
            config->PClkFreq = 0;
#endif
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
    }
    else if (display == EVE_DISPLAY_HDTV_1280x720_58Hz && freq == 72000000)
    {
        /*
        BT815 known values:
        REG_FREQUENCY: 72MHz
        Resolution: 1280x720
        Refresh rate: 58.182Hz
        */
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (supportedResolution)
        {
            config->Width = 1280;
            config->Height = 720;
            config->HCycle = 1650;
            config->HOffset = 40 + 220;
            config->HSync0 = 0;
            config->HSync1 = 40;
            config->VCycle = 750;
            config->VOffset = 5 + 20;
            config->VSync0 = 0;
            config->VSync1 = 5;
            config->PCLK = 1;
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
            config->PClkFreq = 0;
#endif
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
        config->CSpread = 0;
        config->Dither = 0;
        config->PCLKPol = 0;
        config->OutBitsR = 0;
        config->OutBitsG = 0;
        config->OutBitsB = 0;
    }
    else if (display == EVE_DISPLAY_WXGA_1280x800_57Hz)
    {
        /*
        BT817 known values:
        Resolution: 1280x800
        Refresh rate: 57.393Hz
        */
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (EVE_CHIPID >= EVE_BT817 && supportedResolution)
        {
            config->Width = 1280;
            config->Height = 800;
            config->HCycle = 1411;
            config->HOffset = 120;
            config->HSync0 = 0;
            config->HSync1 = 100;
            config->VCycle = 815;
            config->VOffset = 14;
            config->VSync0 = 0;
            config->VSync1 = 10;
            config->PCLK = 1;
            config->PClkFreq = 0x8B1; // 66MHz
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
#endif
        config->CSpread = 0;
        config->Dither = 0;
        config->PCLKPol = 0;
        config->OutBitsR = 0;
        config->OutBitsG = 0;
        config->OutBitsB = 0;
    }
    else if (display == EVE_DISPLAY_WSVGA_1024x600_59Hz)
    {
        /*
        BT817 known values:
        Resolution: 1024x600
        Refresh rate: 59.758Hz
        */
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
#if EVE_HARDCODED_DISPLAY_TIMINGS
        if (EVE_CHIPID >= EVE_BT817 && supportedResolution)
        {
            config->Width = 1024;
            config->Height = 600;
            config->HCycle = 1344;
            config->HOffset = 160;
            config->HSync0 = 0;
            config->HSync1 = 100;
            config->VCycle = 635;
            config->VOffset = 23;
            config->VSync0 = 0;
            config->VSync1 = 10;
            config->PCLK = 1;
            config->PClkFreq = 0xD12; // 51Mhz
#ifdef EVE_SUPPORT_HSF
            config->HsfWidth = 0;
#endif
        }
#endif
#endif
        config->CSpread = 0;
        config->Dither = 1;
        config->PCLKPol = 1;
        config->OutBitsR = 0;
        config->OutBitsG = 0;
        config->OutBitsB = 0;
    }
 
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    /* Disable max cycle if incompatible hardcoded timings are used */
    if (config->AhHCycleMax && config->HCycle > config->AhHCycleMax)
        config->AhHCycleMax = 0;
#endif
 
#ifdef _DEBUG
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    if (config->PClkFreq)
    {
        uint32_t pclkFrequency = getFreqFromPClkFreq(config->PClkFreq);
        eve_printf_debug("Display refresh rate set to %f Hz using pclk %X freq %f MHz\n", (float)((double)pclkFrequency / ((double)config->HCycle * (double)config->VCycle)), (int)config->PClkFreq, (float)((double)pclkFrequency * 0.000001));
    }
    else
#endif
        eve_printf_debug("Display refresh rate set to %f Hz\n", (float)((double)freq / ((double)config->HCycle * (double)config->VCycle * (double)config->PCLK)));
#endif
 
#if 0
    eve_printf_debug("Width: %i\n", (int)config->Width);
    eve_printf_debug("Height: %i\n", (int)config->Height);
    eve_printf_debug("HCycle: %i\n", (int)config->HCycle);
    eve_printf_debug("HOffset: %i\n", (int)config->HOffset);
    eve_printf_debug("HSync0: %i\n", (int)config->HSync0);
    eve_printf_debug("HSync1: %i\n", (int)config->HSync1);
    eve_printf_debug("VCycle: %i\n", (int)config->VCycle);
    eve_printf_debug("VOffset: %i\n", (int)config->VOffset);
    eve_printf_debug("VSync0: %i\n", (int)config->VSync0);
    eve_printf_debug("VSync1: %i\n", (int)config->VSync1);
    eve_printf_debug("PCLK: %i\n", (int)config->PCLK);
    eve_printf_debug("Swizzle: %i\n", (int)config->Swizzle);
    eve_printf_debug("PCLKPol: %i\n", (int)config->PCLKPol);
    eve_printf_debug("CSpread: %i\n", (int)config->CSpread);
    eve_printf_debug("OutBitsR: %i\n", (int)config->OutBitsR);
    eve_printf_debug("OutBitsG: %i\n", (int)config->OutBitsG);
    eve_printf_debug("OutBitsB: %i\n", (int)config->OutBitsB);
    eve_printf_debug("Dither: %i\n", (int)config->Dither);
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
    eve_printf_debug("AdaptiveFramerate: %i\n", (int)config->AdaptiveFramerate);
#endif
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    eve_printf_debug("PClkFreq: %X\n", (int)config->PClkFreq);
    eve_printf_debug("AhHCycleMax: %i\n", (int)config->AhHCycleMax);
#endif
#ifdef EVE_SUPPORT_HSF
    eve_printf_debug("HsfWidth: %i\n", (int)config->HsfWidth);
#endif
#endif
}

EVE_Util_configDefaultsEx()

EVE_HAL_EXPORT bool EVE_Util_configDefaultsEx	(	EVE_HalContext *	phost,
		EVE_ConfigParameters *	config,
		uint32_t	width,
		uint32_t	height,
		uint32_t	refreshRate,
		uint32_t	hsfWidth
	)

Parameters

phost	Pointer to Hal context
config
width
height
refreshRate
hsfWidth

Returns

true True if successful

false False if error

Definition at line 740 of file EVE_Util.c.

{
    uint32_t freq = EVE_Hal_rd32(phost, REG_FREQUENCY);
    bool res = configDefaultsEx(phost, config, width, height, refreshRate, hsfWidth, freq);
#ifdef _DEBUG
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    if (config->PClkFreq)
    {
        uint32_t pclkFrequency = getFreqFromPClkFreq(config->PClkFreq);
        eve_printf_debug("Display refresh rate set to %f Hz using pclk %X freq %f MHz\n", (float)((double)pclkFrequency / ((double)config->HCycle * (double)config->VCycle)), (int)config->PClkFreq, (float)((double)pclkFrequency * 0.000001));
    }
    else
#endif
        eve_printf_debug("Display refresh rate set to %f Hz\n", (float)((double)freq / ((double)config->HCycle * (double)config->VCycle * (double)config->PCLK)));
#endif
    return res;
}

EVE_Util_forceFault()

void EVE_Util_forceFault	(	EVE_HalContext *	phost,
		const char *	err
	)

Parameters

phost	Pointer to Hal context
err

Definition at line 2614 of file EVE_Util.c.

{
    /* Check if we're already in fault state */
    if (!EVE_Cmd_waitSpace(phost, 0))
        return;
#if 1
    /* Go into reset state and mimic a fault */
    EVE_Hal_wr8(phost, REG_CPURESET, 1);
    EVE_Hal_flush(phost);
    EVE_sleep(100);
    EVE_Hal_wr16(phost, REG_CMD_READ, 0xFFF);
    EVE_Hal_wr16(phost, REG_CMD_WRITE, 0xFFF);
#else
    /* TODO: Clean this up a bit */
    if (!EVE_Util_resetCoprocessor(phost))
        return;
    EVE_CoCmd_dlStart(phost);
    for (int i = 0; i < EVE_DL_COUNT; ++i)
        EVE_Cmd_wr32(phost, DISPLAY());
    EVE_Cmd_waitFlush(phost);
    EVE_Cmd_wr32(phost, DISPLAY());
    EVE_Hal_flush(phost);
    EVE_sleep(100);
#endif
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
    if (EVE_CHIPID >= EVE_BT815 && (EVE_Cmd_rp(phost) & 0x3))
    {
        /* Write our own error to the error report area */
        uint32_t errLen = (uint32_t)strlen(err);
        EVE_Hal_wrMem(phost, RAM_ERR_REPORT, (const uint8_t *)err, errLen);
        if (errLen < RAM_ERR_REPORT_MAX)
        {
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, RAM_ERR_REPORT + errLen);
            for (int i = (int)errLen; i < RAM_ERR_REPORT_MAX; ++i)
                EVE_Hal_transfer8(phost, 0);
            EVE_Hal_endTransfer(phost);
        }
    }
#endif
    /* Fault state now */
    EVE_Cmd_waitFlush(phost);
#if 0
#if defined(_DEBUG)
#if (EVE_SUPPORT_CHIPID >= EVE_BT815)
    if (EVE_CHIPID >= EVE_BT815
        && phost->DebugMessageVisible)
    {
        uint32_t errLen = (uint32_t)strlen(err);
        EVE_Hal_wrMem(phost, RAM_G + RAM_G_SIZE - sizeof(phost->DebugBackup), (const uint8_t *)err, errLen);
        if (errLen < sizeof(phost->DebugBackup))
        {
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, RAM_G + RAM_G_SIZE - sizeof(phost->DebugBackup) + errLen);
            for (int i = (int)errLen; i < sizeof(phost->DebugBackup); ++i)
                EVE_Hal_transfer8(phost, 0);
            EVE_Hal_endTransfer(phost);
        }
    }
#endif
#endif
#endif
}

EVE_Util_needsSubPatch()

static bool EVE_Util_needsSubPatch ( EVE_HalContext *  phost )

inlinestatic

Parameters

phost

Pointer to Hal context

Returns

bool

Definition at line 1695 of file EVE_Util.c.

{
    return (EVE_CHIPID >= EVE_FT810) && (EVE_CHIPID <= EVE_FT813);
}

EVE_Util_needsVideoPatch()

static bool EVE_Util_needsVideoPatch ( EVE_HalContext *  phost )

inlinestatic

Parameters

phost

Pointer to Hal context

Returns

bool

Definition at line 1711 of file EVE_Util.c.

{
    return (EVE_CHIPID >= EVE_BT815) && (EVE_CHIPID <= EVE_BT816);
}

EVE_Util_openDeviceInteractive()

bool EVE_Util_openDeviceInteractive	(	EVE_HalContext *	phost,
		const wchar_t *	flashFile
	)

Parameters

phost	Pointer to Hal context
flashFile

Returns

true True if successful

false False if error

Definition at line 2521 of file EVE_Util.c.

{
    EVE_CHIPID_T chipId;
    size_t deviceIdx;
    bool opened;
 
#ifdef BT8XXEMU_PLATFORM
    BT8XXEMU_EmulatorParameters emulatorParams;
#if defined(EVE_FLASH_AVAILABLE)
    BT8XXEMU_FlashParameters flashParams;
#endif
#endif
    EVE_HalParameters params = { 0 };
#if defined(_WIN32) && defined(EVE_FLASH_AVAILABLE)
    bool updateFlash = false;
    bool updateFlashFirmware = false;
    wchar_t flashPath[MAX_PATH];
    flashPath[0] = '\0';
#endif
 
    /* Interactive device selection */
    EVE_Util_selectDeviceInteractive(&chipId, &deviceIdx);
 
    /* Fetch the default parameters for a device. Set the expected chip id.
    Pass the device index, or -1 to select the first device */
    EVE_Hal_defaultsEx(&params, deviceIdx);
 
#if defined(_WIN32) && defined(EVE_FLASH_AVAILABLE)
    if (chipId >= EVE_BT815 || (chipId <= 0 && flashFile && flashFile[0]))
        EVE_Util_selectFlashFileInteractive(flashPath, sizeof(flashPath) / sizeof(flashPath[0]), &updateFlash, &updateFlashFirmware, &params, flashFile);
#endif
 
#if defined(BT8XXEMU_PLATFORM)
    EVE_Util_emulatorDefaults(&params, &emulatorParams, chipId);
#if defined(EVE_FLASH_AVAILABLE)
    EVE_Util_emulatorFlashDefaults(&params, &emulatorParams, &flashParams, flashPath);
#endif
#endif
 
    opened = EVE_Hal_open(phost, &params);
 
    if (!opened)
        return false;
 
#if defined(_WIN32) && defined(EVE_FLASH_AVAILABLE)
    if (updateFlash && flashPath[0])
        EVE_Util_uploadFlashFileInteractive(phost, flashPath, updateFlashFirmware);
#endif
 
    return true;
}

EVE_Util_resetCoprocessor()

EVE_HAL_EXPORT bool EVE_Util_resetCoprocessor

(

EVE_HalContext *

phost

)

Reset Coprocessor.

Parameters

phost

Pointer to Hal context

Returns

true True if successful

false False if error

Definition at line 1752 of file EVE_Util.c.

{
    /* IMPORTANT: Do not use EVE_CoCmd functions here, as they can be overridden by hooks */
 
    const bool needsVideoPatch = EVE_Util_needsVideoPatch(phost);
    uint16_t videoPatchVector;
    bool ready;
    uint16_t rd;
    uint16_t wr;
    (void)rd;
    (void)wr;
 
    eve_printf_debug("Reset coprocessor\n");
 
    if (needsVideoPatch)
    {
        /* BT81X video patch */
        videoPatchVector = EVE_Hal_rd16(phost, EVE_VIDEOPATCH_ADDR);
    }
 
    /* Set REG_CPURESET to 1, to hold the coprocessor in the reset condition */
    EVE_Hal_wr8(phost, REG_CPURESET, 1);
    EVE_Hal_flush(phost);
    EVE_sleep(100);
 
    /* Set REG_CMD_READ and REG_CMD_WRITE to zero */
    EVE_Hal_wr16(phost, REG_CMD_READ, 0);
    EVE_Hal_wr16(phost, REG_CMD_WRITE, 0);
    EVE_Hal_wr16(phost, REG_CMD_DL, 0);
    EVE_Hal_wr8(phost, REG_PCLK, phost->PCLK); /* j1 will set the pclk to 0 for that error case */
 
    /* Stop playing audio in case video with audio was playing during reset */
    EVE_Hal_wr8(phost, REG_PLAYBACK_PLAY, 0);
 
    if (EVE_Util_needsSubPatch(phost))
    {
        /* Enable patched rom in case the reset is requested while CMD_LOGO is running.
        This is necessary as CMD_LOGO may swap to the other rom page */
        EVE_Hal_wr8(phost, REG_ROMSUB_SEL, 3);
    }
 
    /* Default */
    phost->CmdFault = false;
 
    /* Set REG_CPURESET to 0, to restart the coprocessor */
    EVE_Hal_wr8(phost, REG_CPURESET, 0);
    EVE_Hal_flush(phost);
    EVE_sleep(100);
    eve_assert((wr = EVE_Hal_rd16(phost, REG_CMD_WRITE)) == 0);
    eve_assert((rd = EVE_Hal_rd16(phost, REG_CMD_READ)) == 0);
 
    /* Refresh fifo */
    EVE_Cmd_waitFlush(phost);
#if (EVE_SUPPORT_CHIPID >= EVE_FT810)
    if (EVE_CHIPID >= EVE_FT810)
    {
        phost->MediaFifoAddress = 0;
        phost->MediaFifoSize = 0;
    }
#endif
 
    if (EVE_Util_needsSubPatch(phost))
    {
        /* Clear cmd with CMD_STOP, exiting CMD_EXECUTE may loop over, depending on OTP */
        EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, RAM_CMD);
        for (int i = 0; i < EVE_CMD_FIFO_SIZE; i += 4)
            EVE_Hal_transfer32(phost, CMD_STOP);
        EVE_Hal_endTransfer(phost);
 
        /* Go back into the patched coprocessor main loop */
        EVE_Hal_wr8(phost, REG_ROMSUB_SEL, 3);
        EVE_Cmd_startFunc(phost);
        EVE_Cmd_wr32(phost, (4294967047UL));
        EVE_Cmd_wr32(phost, EVE_SUBPATCH_PTR);
        EVE_Cmd_wr32(phost, 0);
        EVE_Cmd_endFunc(phost);
        EVE_Hal_flush(phost);
        eve_assert((wr = EVE_Hal_rd16(phost, REG_CMD_WRITE)) == 12);
        eve_assert((rd = EVE_Hal_rd16(phost, REG_CMD_READ)) == 0);
 
        /* Difficult to check when CMD_EXECUTE is processed when there's an OTP,
        since the read pointer keeps looping back to 0. */
        EVE_sleep(100);
        eve_assert((wr = EVE_Hal_rd16(phost, REG_CMD_WRITE)) == 12);
        eve_assert((rd = EVE_Hal_rd16(phost, REG_CMD_READ)) == 0);
 
        /* Need to manually stop previous command from repeating infinitely,
        however, this may cause the coprocessor to overshoot the command fifo,
        hence it's been filled with harmless CMD_STOP commands. */
        EVE_Hal_wr16(phost, REG_CMD_WRITE, 0);
        EVE_Hal_flush(phost);
        EVE_sleep(100);
 
        /* Refresh fifo */
        EVE_Cmd_waitFlush(phost);
        eve_assert((wr = EVE_Hal_rd16(phost, REG_CMD_WRITE)) == 0);
        eve_assert((rd = EVE_Hal_rd16(phost, REG_CMD_READ)) == 0);
    }
 
    if (needsVideoPatch)
    {
        /* BT81X video patch */
        EVE_Hal_wr16(phost, EVE_VIDEOPATCH_ADDR, videoPatchVector);
    }
 
    /* Cold start. Ensure that the coprocessor is ready. */
    EVE_Cmd_wr32(phost, CMD_DLSTART);
    EVE_Cmd_wr32(phost, CMD_COLDSTART);
 
    /* Set the latest API level.
    CMD_APILEVEL applicable since BT817. */
#if (EVE_SUPPORT_CHIPID >= EVE_BT817)
    if (EVE_CHIPID >= EVE_BT817)
    {
        EVE_Cmd_wr32(phost, CMD_APILEVEL);
        EVE_Cmd_wr32(phost, 2);
    }
#endif
 
#ifdef EVE_FLASH_AVAILABLE
    if (EVE_CHIPID >= EVE_BT815)
    {
        /* Reattach flash to avoid inconsistent state */
        EVE_Cmd_wr32(phost, CMD_FLASHATTACH);
    }
#endif
 
    /* Wait for coprocessor to be ready */
    ready = EVE_Cmd_waitFlush(phost);
    if (phost->CbCoprocessorReset) /* Notify */
        phost->CbCoprocessorReset(phost, !ready);
 
#if defined(_DEBUG)
    debugRestoreRamG(phost);
#endif
    EVE_CoDlImpl_resetCoState(phost);
    return ready;
}

EVE_Util_shutdown()

EVE_HAL_EXPORT void EVE_Util_shutdown

(

EVE_HalContext *

phost

)

Parameters

phost

Pointer to Hal context

Definition at line 1667 of file EVE_Util.c.

{
    if (EVE_CHIPID >= EVE_FT810)
    {
        EVE_Hal_wr16(phost, REG_GPIOX_DIR, 0xffff);
        EVE_Hal_wr16(phost, REG_GPIOX, 0);
    }
    else
    {
        EVE_Hal_wr8(phost, REG_GPIO_DIR, 0xff);
        EVE_Hal_wr8(phost, REG_GPIO, 0);
    }
    EVE_Hal_wr8(phost, REG_PCLK, 0);
    EVE_Hal_flush(phost);
    EVE_Hal_powerCycle(phost, false);
}

uploadTouchFirmware()

static void uploadTouchFirmware ( EVE_HalContext *  phost )

inlinestatic

VERIFY: Can the emulator handle this?

Definition at line 259 of file EVE_Util.c.

{
    /* no-op */
}

Variable Documentation

c_DlCodeBootup

eve_progmem_const uint8_t c_DlCodeBootup[12]

static

Initial value:

= {
    0, 0, 0, 2, 
    7, 0, 0, 38, 
    0, 0, 0, 0, 
}

Definition at line 38 of file EVE_Util.c.

                                                      {
    0, 0, 0, 2, // GPU instruction CLEAR_COLOR_RGB
    7, 0, 0, 38, // GPU instruction CLEAR
    0, 0, 0, 0, // GPU instruction DISPLAY
};

s_DisplayResolutions

const uint16_t s_DisplayResolutions[EVE_DISPLAY_NB][4]

static

Initial value:

= {
    
 
    { 480, 272, 60, 0 }, 
 
    
    { 320, 240, 56, 0 }, 
    { 480, 272, 60, 0 }, 
    { 800, 480, 74, 0 }, 
    { 1024, 600, 59, 0 }, 
    { 1280, 720, 58, 0 }, 
    { 1280, 800, 57, 0 }, 
 
    
    { 320, 480, 60, 0 }, 
 
    
    { 860, 480, 60, 800 }, 
 
    
    { 320, 240, 62, 0 }, 
    { 480, 272, 58, 0 }, 
    { 800, 480, 63, 0 }, 
    { 1024, 600, 59, 0 }, 
    { 1280, 800, 59, 0 }, 
 
}

Note

Update EVE_DISPLAY_T in EVE_Util.h when adding display presets.

Definition at line 45 of file EVE_Util.c.

                                                                {
    /* width, height, refreshRate, hsfWidth */
 
    { 480, 272, 60, 0 }, /* EVE_DISPLAY_DEFAULT (values ignored) */
 
    /* Landscape */
    { 320, 240, 56, 0 }, /* EVE_DISPLAY_QVGA_320x240_56Hz */
    { 480, 272, 60, 0 }, /* EVE_DISPLAY_WQVGA_480x272_60Hz */
    { 800, 480, 74, 0 }, /* EVE_DISPLAY_WVGA_800x480_74Hz */
    { 1024, 600, 59, 0 }, /* EVE_DISPLAY_WSVGA_1024x600_59Hz */
    { 1280, 720, 58, 0 }, /* EVE_DISPLAY_HDTV_1280x720_58Hz */
    { 1280, 800, 57, 0 }, /* EVE_DISPLAY_WXGA_1280x800_57Hz */
 
    /* Portrait */
    { 320, 480, 60, 0 }, /* EVE_DISPLAY_HVGA_320x480_60Hz */
 
    /* IDM2040-7A, AT-T070SWH-51CP, HX8264-E, 60 to 90Hz capable */
    { 860, 480, 60, 800 }, /* EVE_DISPLAY_WVGA_800x480_W860_60Hz */
 
    /* Riverdi */
    { 320, 240, 62, 0 }, /* EVE_DISPLAY_RIVERDI_IPS35_62Hz */
    { 480, 272, 58, 0 }, /* EVE_DISPLAY_RIVERDI_IPS43_58Hz */
    { 800, 480, 63, 0 }, /* EVE_DISPLAY_RIVERDI_IPS50_63Hz */
    { 1024, 600, 59, 0 }, /* EVE_DISPLAY_RIVERDI_IPS70_59Hz */
    { 1280, 800, 59, 0 }, /* EVE_DISPLAY_RIVERDI_IPS101_59Hz */
 
};