EVE_Util.h File Reference

EVE HAL framework utilities. More...

#include "EVE_HalDefs.h"

Go to the source code of this file.

Data Structures
struct	EVE_BootupParameters
struct	EVE_ConfigParameters

Typedefs
typedef struct EVE_BootupParameters	EVE_BootupParameters
typedef struct EVE_ConfigParameters	EVE_ConfigParameters
typedef enum EVE_DISPLAY_T	EVE_DISPLAY_T

Enumerations
enum	EVE_DISPLAY_T {   EVE_DISPLAY_DEFAULT = 0 , EVE_DISPLAY_QVGA_320x240_56Hz , EVE_DISPLAY_WQVGA_480x272_60Hz , EVE_DISPLAY_WVGA_800x480_74Hz ,   EVE_DISPLAY_WSVGA_1024x600_59Hz , EVE_DISPLAY_HDTV_1280x720_58Hz , EVE_DISPLAY_WXGA_1280x800_57Hz , EVE_DISPLAY_HVGA_320x480_60Hz ,   EVE_DISPLAY_WVGA_800x480_W860_60Hz , EVE_DISPLAY_RIVERDI_IPS35_62Hz , EVE_DISPLAY_RIVERDI_IPS43_58Hz , EVE_DISPLAY_RIVERDI_IPS50_63Hz ,   EVE_DISPLAY_RIVERDI_IPS70_59Hz , EVE_DISPLAY_RIVERDI_IPS101_59Hz , EVE_DISPLAY_NB }

Functions
INIT AND SHUTDOWN
EVE_HAL_EXPORT void	EVE_Util_bootupDefaults (EVE_HalContext *phost, EVE_BootupParameters *bootup)
EVE_HAL_EXPORT bool	EVE_Util_bootup (EVE_HalContext *phost, EVE_BootupParameters *bootup)
EVE_HAL_EXPORT void	EVE_Util_configDefaults (EVE_HalContext *phost, EVE_ConfigParameters *config, EVE_DISPLAY_T display)
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 bool	EVE_Util_config (EVE_HalContext *phost, EVE_ConfigParameters *config)
EVE_HAL_EXPORT void	EVE_Util_shutdown (EVE_HalContext *phost)
EVE_HAL_EXPORT void	EVE_Util_clearScreen (EVE_HalContext *phost)
	Clear the screen.
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
static void	EVE_Util_selectDeviceInteractive (EVE_CHIPID_T *chipId, size_t *deviceIdx)
static void	EVE_Util_selectDisplayInteractive (EVE_DISPLAY_T *display)
static void	EVE_Util_selectFlashFileInteractive (eve_tchar_t *flashPath, size_t flashPathSize, bool *updateFlash, bool *updateFlashFirmware, const EVE_HalParameters *params, const eve_tchar_t *flashFile)
static void	EVE_Util_uploadFlashFileInteractive (EVE_HalContext *phost, const eve_tchar_t *flashPath, bool updateFlashFirmware)
EVE_HAL_EXPORT 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.
EVE_HAL_EXPORT void	EVE_Util_forceFault (EVE_HalContext *phost, const char *err)

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.h.

Typedef Documentation

EVE_BootupParameters

typedef struct EVE_BootupParameters EVE_BootupParameters

EVE_ConfigParameters

typedef struct EVE_ConfigParameters EVE_ConfigParameters

EVE_DISPLAY_T

typedef enum EVE_DISPLAY_T EVE_DISPLAY_T

Display resolution presets.

Note

Also update s_DisplayResolutions and s_DisplayNames in EVE_Util.c around ln 50, as well as EVE_Util_configDefaults around ln 500, when adding display presets.

Enumeration Type Documentation

EVE_DISPLAY_T

enum EVE_DISPLAY_T

Display resolution presets.

Note

Also update s_DisplayResolutions and s_DisplayNames in EVE_Util.c around ln 50, as well as EVE_Util_configDefaults around ln 500, when adding display presets.

Enumerator
EVE_DISPLAY_DEFAULT	0
EVE_DISPLAY_QVGA_320x240_56Hz	Landscape
EVE_DISPLAY_WQVGA_480x272_60Hz	Landscape
EVE_DISPLAY_WVGA_800x480_74Hz	Landscape
EVE_DISPLAY_WSVGA_1024x600_59Hz	Landscape
EVE_DISPLAY_HDTV_1280x720_58Hz	Landscape
EVE_DISPLAY_WXGA_1280x800_57Hz	Landscape
EVE_DISPLAY_HVGA_320x480_60Hz	Portrait
EVE_DISPLAY_WVGA_800x480_W860_60Hz	IDM2040
EVE_DISPLAY_RIVERDI_IPS35_62Hz	Riverdi
EVE_DISPLAY_RIVERDI_IPS43_58Hz	Riverdi
EVE_DISPLAY_RIVERDI_IPS50_63Hz	Riverdi
EVE_DISPLAY_RIVERDI_IPS70_59Hz	Riverdi
EVE_DISPLAY_RIVERDI_IPS101_59Hz	Riverdi
EVE_DISPLAY_NB

Definition at line 100 of file EVE_Util.h.

{
    EVE_DISPLAY_DEFAULT = 0, 
 
    EVE_DISPLAY_QVGA_320x240_56Hz,
    EVE_DISPLAY_WQVGA_480x272_60Hz, 
    EVE_DISPLAY_WVGA_800x480_74Hz, 
    EVE_DISPLAY_WSVGA_1024x600_59Hz, 
    EVE_DISPLAY_HDTV_1280x720_58Hz, 
    EVE_DISPLAY_WXGA_1280x800_57Hz, 
 
    EVE_DISPLAY_HVGA_320x480_60Hz,
 
    EVE_DISPLAY_WVGA_800x480_W860_60Hz,
 
    EVE_DISPLAY_RIVERDI_IPS35_62Hz,
    EVE_DISPLAY_RIVERDI_IPS43_58Hz, 
    EVE_DISPLAY_RIVERDI_IPS50_63Hz, 
    EVE_DISPLAY_RIVERDI_IPS70_59Hz, 
    EVE_DISPLAY_RIVERDI_IPS101_59Hz, 
 
    EVE_DISPLAY_NB,
 
} EVE_DISPLAY_T;

Function Documentation

EVE_Util_bootup()

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

Boot up the device. Obtains the chip Id. Sets up clock and SPI speed.

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.

Calls EVE_Util_bootup and EVE_Util_config using the default parameters

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.

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
	)

Get the default bootup parameters.

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.

Sets the display list to a blank cleared 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
	)

Boot up the device. Configures the display, resets or initializes coprocessor state.

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
	)

Get the default configuration parameters for the specified 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
	)

Get the default configuration parameters for the specified display parameters.

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()

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

Forces a coprocessor fault, useful for triggering a delayed reset (TODO: Remove this)

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_openDeviceInteractive()

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

Command line device selection utility. Provides selection of flash file, and option to write the flash file to the device. Parameter flashFile is only relevant for Windows build. Falls back to no interactivity on FT9XX platform

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.

Resets the coprocessor. To be used after a coprocessor fault, or to exit CMD_LOGO. After a reset, flash will be in attached state (not in full speed). Coprocessor will be set to the latest API level.

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_selectDeviceInteractive()

static void EVE_Util_selectDeviceInteractive ( EVE_CHIPID_T *  chipId, size_t *  deviceIdx  )

inlinestatic

Command line device selection utility

Definition at line 178 of file EVE_Util.h.

{
    *chipId = EVE_SUPPORT_CHIPID;
    *deviceIdx = -1;
}

EVE_Util_selectDisplayInteractive()

static void EVE_Util_selectDisplayInteractive ( EVE_DISPLAY_T *  display )

inlinestatic

Command line display selection utility

Definition at line 189 of file EVE_Util.h.

{
    *display = EVE_DISPLAY_DEFAULT;
}

EVE_Util_selectFlashFileInteractive()

static void EVE_Util_selectFlashFileInteractive ( eve_tchar_t *  flashPath, size_t  flashPathSize, bool *  updateFlash, bool *  updateFlashFirmware, const EVE_HalParameters *  params, const eve_tchar_t *  flashFile  )

inlinestatic

Definition at line 198 of file EVE_Util.h.

{
    flashPath[0] = '\0';
    *updateFlash = false;
    *updateFlashFirmware = false;
}

EVE_Util_shutdown()

EVE_HAL_EXPORT void EVE_Util_shutdown

(

EVE_HalContext *

phost

)

Complementary of bootup. Does not close the HAL context.

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);
}

EVE_Util_uploadFlashFileInteractive()

static void EVE_Util_uploadFlashFileInteractive ( EVE_HalContext *  phost, const eve_tchar_t *  flashPath, bool  updateFlashFirmware  )

inlinestatic

Definition at line 209 of file EVE_Util.h.

{
    /* no-op */
}