EVE_HalImpl_FT9XX.c File Reference

Eve_Hal framework APIs for FT9XX host platform. More...

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

Go to the source code of this file.

Macros
#define	GPIO_SS_NB   (sizeof(s_SpimGpioSS) / sizeof(s_SpimGpioSS[0]))

Functions
MISC
void	ticker ()
	Clear the interrupt and increment the counter.
static void	initSdHost ()
	Sdcard initialization.
void	EVE_Mcu_initialize ()
	Init FT9x host MCU.
void	EVE_Mcu_release ()
	Release FT9x host MCU.
void	EVE_Millis_initialize ()
	Init FT9x timer.
void	EVE_Millis_release ()
	Release FT9x timer.
uint32_t	EVE_millis ()
	Get clock in miliseond.
uint64_t	EVE_millis64 ()
	Get clock in miliseond.
void	EVE_sleep (uint32_t ms)
	Sleep in milisecond.
bool	EVE_UtilImpl_bootupDisplayGpio (EVE_HalContext *phost)
	Display GPIO pins.
INIT
void	EVE_HalImpl_initialize ()
	Initialize HAL platform.
void	EVE_HalImpl_release ()
	Release HAL platform.
EVE_HAL_EXPORT size_t	EVE_Hal_list ()
	List the available devices.
EVE_HAL_EXPORT void	EVE_Hal_info (EVE_DeviceInfo *deviceInfo, size_t deviceIdx)
	Get info of the specified device. Devices of type EVE_HOST_UNKNOWN should be ignored.
EVE_HAL_EXPORT bool	EVE_Hal_isDevice (EVE_HalContext *phost, size_t deviceIdx)
	Check whether the context is the specified device.
bool	EVE_HalImpl_defaults (EVE_HalParameters *parameters, size_t deviceIdx)
	Get the default configuration parameters.
void	setSPI (EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy)
	Set number of SPI channel.
bool	EVE_HalImpl_open (EVE_HalContext *phost, const EVE_HalParameters *parameters)
	Opens a new HAL context using the specified parameters.
void	EVE_HalImpl_close (EVE_HalContext *phost)
	Close a HAL context.
void	EVE_HalImpl_idle (EVE_HalContext *phost)
	Idle. Call regularly to update frequently changing internal state.
TRANSFER
void	EVE_Hal_startTransfer (EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr)
	Start data transfer to Coprocessor.
void	EVE_Hal_endTransfer (EVE_HalContext *phost)
	End data transfer.
void	EVE_Hal_flush (EVE_HalContext *phost)
	Flush data to Coprocessor.
static void	rdBuffer (EVE_HalContext *phost, uint8_t *buffer, uint32_t size)
	Read a block data from Coprocessor.
static void	wrBuffer (EVE_HalContext *phost, const uint8_t *buffer, uint32_t size)
	Write a block data to Coprocessor.
static uint8_t	transfer8 (EVE_HalContext *phost, uint8_t value)
	Write 8 bit to Coprocessor.
uint8_t	EVE_Hal_transfer8 (EVE_HalContext *phost, uint8_t value)
	Write 8 bits to Coprocessor.
uint16_t	EVE_Hal_transfer16 (EVE_HalContext *phost, uint16_t value)
	Write 2 bytes to Coprocessor.
uint32_t	EVE_Hal_transfer32 (EVE_HalContext *phost, uint32_t value)
	Write 4 bytes to Coprocessor.
void	EVE_Hal_transferMem (EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size)
	Transfer (read/write) a block data to Coprocessor.
void	EVE_Hal_transferProgMem (EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size)
	Transfer a block data from program memory.
uint32_t	EVE_Hal_transferString (EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask)
	Transfer a string to EVE platform.
UTILITY
void	EVE_Hal_hostCommand (EVE_HalContext *phost, uint8_t cmd)
	Send a host command to Coprocessor.
void	EVE_Hal_hostCommandExt3 (EVE_HalContext *phost, uint32_t cmd)
	This API sends a 3byte command to the phost.
bool	EVE_Hal_powerCycle (EVE_HalContext *phost, bool up)
	Toggle PD_N pin of FT800 board for a power cycle.
void	EVE_Hal_setSPI (EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy)
	Set number of SPI channel.
void	EVE_Hal_restoreSPI (EVE_HalContext *phost)
uint32_t	EVE_Hal_currentFrequency (EVE_HalContext *phost)
	Get current system clock of Coprocessor.

Variables
static const uint8_t	s_SpimGpioSS [4] = { GPIO_SPIM_SS0, GPIO_SPIM_SS1, GPIO_SPIM_SS2, 35 }
static const pad_dir_t	s_SpimFuncSS [4] = { pad_spim_ss0, pad_spim_ss1, pad_spim_ss2, pad_spim_ss3 }
static uint32_t	s_TotalMilliseconds = 0
static uint64_t	s_TotalMilliseconds64 = 0

Detailed Description

Eve_Hal framework APIs for FT9XX host platform.

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_HalImpl_FT9XX.c.

Macro Definition Documentation

GPIO_SS_NB

#define GPIO_SS_NB   (sizeof(s_SpimGpioSS) / sizeof(s_SpimGpioSS[0]))

Definition at line 44 of file EVE_HalImpl_FT9XX.c.

Function Documentation

EVE_Hal_currentFrequency()

uint32_t EVE_Hal_currentFrequency

(

EVE_HalContext *

phost

)

Get current system clock of Coprocessor.

Parameters

phost

Pointer to Hal context

Returns

uint32_t Frequency of Coprocessor

Definition at line 650 of file EVE_HalImpl_FT9XX.c.

{
    uint32_t t0;
    uint32_t t1;
    int32_t r = 15625;
 
    t0 = EVE_Hal_rd32(phost, REG_CLOCK); /* t0 read */
 
    __asm__(
        "   move.l  $r0,%0               \n\t"
        "   mul.l   $r0,$r0,100          \n\t"
        "1:                              \n\t"
        "   sub.l   $r0,$r0,3            \n\t" /* Subtract the loop time = 4 cycles */
        "   cmp.l   $r0,0                \n\t" /* Check that the counter is equal to 0 */
        "   jmpc    gt, 1b               \n\t"
        : /* Outputs */
        : "r"(r) /* Inputs */
        : "$r0"); /* Using */
 
    t1 = EVE_Hal_rd32(phost, REG_CLOCK); /* t1 read */
    return ((t1 - t0) << 6); /* bitshift 6 places is the same as multiplying 64 */
}

EVE_Hal_endTransfer()

void EVE_Hal_endTransfer

(

EVE_HalContext *

phost

)

End data transfer.

Parameters

phost

Pointer to Hal context

Definition at line 291 of file EVE_HalImpl_FT9XX.c.

{
    eve_assert(phost->Status == EVE_STATUS_READING || phost->Status == EVE_STATUS_WRITING);
 
    spi_close(SPIM, phost->SpiCsPin);
    phost->Status = EVE_STATUS_OPENED;
}

EVE_Hal_flush()

void EVE_Hal_flush

(

EVE_HalContext *

phost

)

Flush data to Coprocessor.

Parameters

phost

Pointer to Hal context

Definition at line 304 of file EVE_HalImpl_FT9XX.c.

{
    eve_assert(phost->Status == EVE_STATUS_OPENED);
    /* no-op */
}

EVE_Hal_hostCommand()

void EVE_Hal_hostCommand	(	EVE_HalContext *	phost,
		uint8_t	cmd
	)

Send a host command to Coprocessor.

Parameters

phost	Pointer to Hal context
cmd	Command to send

Definition at line 544 of file EVE_HalImpl_FT9XX.c.

{
    eve_assert(phost->Status == EVE_STATUS_OPENED);
 
    uint8_t hcmd[4] = { 0 };
    hcmd[0] = cmd;
    hcmd[1] = 0;
    hcmd[2] = 0;
    hcmd[3] = 0;
 
    spi_open(SPIM, phost->SpiCsPin);
    spi_writen(SPIM, hcmd, 3);
    spi_close(SPIM, phost->SpiCsPin);
}

EVE_Hal_hostCommandExt3()

void EVE_Hal_hostCommandExt3	(	EVE_HalContext *	phost,
		uint32_t	cmd
	)

This API sends a 3byte command to the phost.

Parameters

phost	Pointer to Hal context
cmd	Command to send

Definition at line 565 of file EVE_HalImpl_FT9XX.c.

{
    eve_assert(phost->Status == EVE_STATUS_OPENED);
 
    uint8_t hcmd[4] = { 0 };
    hcmd[0] = cmd & 0xff;
    hcmd[1] = (cmd >> 8) & 0xff;
    hcmd[2] = (cmd >> 16) & 0xff;
    hcmd[3] = 0;
 
    spi_open(SPIM, phost->SpiCsPin);
    spi_writen(SPIM, hcmd, 3);
    spi_close(SPIM, phost->SpiCsPin);
}

EVE_Hal_info()

EVE_HAL_EXPORT void EVE_Hal_info	(	EVE_DeviceInfo *	deviceInfo,
		size_t	deviceIdx
	)

Get info of the specified device. Devices of type EVE_HOST_UNKNOWN should be ignored.

Parameters

deviceInfo
deviceIdx

Definition at line 87 of file EVE_HalImpl_FT9XX.c.

{
    memset(deviceInfo, 0, sizeof(EVE_DeviceInfo));
    strcpy_s(deviceInfo->DisplayName, sizeof(deviceInfo->DisplayName), "FT9XX");
    strcpy_s(deviceInfo->SerialNumber, sizeof(deviceInfo->SerialNumber), "FT9XX");
    deviceInfo->Host = EVE_HOST_EMBEDDED;
}

EVE_Hal_isDevice()

EVE_HAL_EXPORT bool EVE_Hal_isDevice	(	EVE_HalContext *	phost,
		size_t	deviceIdx
	)

Check whether the context is the specified device.

Parameters

phost	Pointer to Hal context
deviceIdx

Returns

true True if ok

false False if error

Definition at line 103 of file EVE_HalImpl_FT9XX.c.

{
    return true;
}

EVE_Hal_list()

EVE_HAL_EXPORT size_t EVE_Hal_list

(

)

List the available devices.

List the available devices

Definition at line 76 of file EVE_HalImpl_FT9XX.c.

{
    return 1;
}

EVE_Hal_powerCycle()

bool EVE_Hal_powerCycle	(	EVE_HalContext *	phost,
		bool	up
	)

Toggle PD_N pin of FT800 board for a power cycle.

Parameters

phost	Pointer to Hal context
up	Up or Down

Returns

true True if ok

false False if error

Definition at line 588 of file EVE_HalImpl_FT9XX.c.

{
    if (up)
    {
        gpio_write(phost->PowerDownPin, 0);
        EVE_sleep(20);
        setSPI(phost, EVE_SPI_SINGLE_CHANNEL, 1);
        gpio_write(phost->PowerDownPin, 1);
        EVE_sleep(20);
    }
    else
    {
        gpio_write(phost->PowerDownPin, 1);
        EVE_sleep(20);
        gpio_write(phost->PowerDownPin, 0);
        EVE_sleep(20);
    }
    return true;
}

EVE_Hal_restoreSPI()

void EVE_Hal_restoreSPI

(

EVE_HalContext *

phost

)

Restore platform to previously configured EVE SPI channel mode

Definition at line 636 of file EVE_HalImpl_FT9XX.c.

{
    if (EVE_CHIPID < EVE_FT810)
        return;
 
    setSPI(phost, phost->SpiChannels, phost->SpiDummyBytes);
}

EVE_Hal_setSPI()

void EVE_Hal_setSPI	(	EVE_HalContext *	phost,
		EVE_SPI_CHANNELS_T	numchnls,
		uint8_t	numdummy
	)

Set number of SPI channel.

Parameters

phost	Pointer to Hal context
numchnls	Number of channel
numdummy	Number of dummy bytes

Definition at line 615 of file EVE_HalImpl_FT9XX.c.

{
    if (EVE_CHIPID < EVE_FT810)
        return;
 
    uint8_t writebyte = 0;
 
    if ((numchnls > EVE_SPI_QUAD_CHANNEL) || (numdummy > 2) || (numdummy < 1))
        return; // error
 
    // Switch EVE to multi channel SPI mode
    writebyte = numchnls;
    if (numdummy == 2)
        writebyte |= EVE_SPI_TWO_DUMMY_BYTES;
    EVE_Hal_wr8(phost, REG_SPI_WIDTH, writebyte);
    EVE_Hal_flush(phost);
 
    // Switch FT9XX to multi channel SPI mode
    setSPI(phost, numchnls, numdummy);
}

EVE_Hal_startTransfer()

void EVE_Hal_startTransfer	(	EVE_HalContext *	phost,
		EVE_TRANSFER_T	rw,
		uint32_t	addr
	)

Start data transfer to Coprocessor.

Parameters

phost	Pointer to Hal context
rw	Read or Write
addr	Address to read/write

Definition at line 257 of file EVE_HalImpl_FT9XX.c.

{
    eve_assert(phost->Status == EVE_STATUS_OPENED);
 
    if (rw == EVE_TRANSFER_READ)
    {
        eve_assert(3 + phost->SpiDummyBytes <= 5);
        uint8_t spidata[5]; // FIXME: phost->SpiDummyBytes // ?
        spidata[0] = (addr >> 16);
        spidata[1] = (addr >> 8);
        spidata[2] = addr & 0xff;
        spi_open(SPIM, phost->SpiCsPin);
        spi_writen(SPIM, spidata, 3 + phost->SpiDummyBytes);
        phost->Status = EVE_STATUS_READING;
    }
    else
    {
        uint8_t spidata[4];
        spidata[0] = (0x80 | (addr >> 16));
        spidata[1] = (addr >> 8);
        spidata[2] = addr;
 
        spi_open(SPIM, phost->SpiCsPin);
        spi_writen(SPIM, spidata, 3);
 
        phost->Status = EVE_STATUS_WRITING;
    }
}

EVE_Hal_transfer16()

uint16_t EVE_Hal_transfer16	(	EVE_HalContext *	phost,
		uint16_t	value
	)

Write 2 bytes to Coprocessor.

Parameters

phost	Pointer to Hal context
value	Value to write

Returns

uint16_t Number of bytes transfered

Definition at line 374 of file EVE_HalImpl_FT9XX.c.

{
    uint8_t buffer[2];
    if (phost->Status == EVE_STATUS_READING)
    {
        rdBuffer(phost, buffer, 2);
        return (uint16_t)buffer[0]
            | (uint16_t)buffer[1] << 8;
    }
    else
    {
        buffer[0] = value & 0xFF;
        buffer[1] = value >> 8;
        wrBuffer(phost, buffer, 2);
        return 0;
    }
}

EVE_Hal_transfer32()

uint32_t EVE_Hal_transfer32	(	EVE_HalContext *	phost,
		uint32_t	value
	)

Write 4 bytes to Coprocessor.

Parameters

phost	Pointer to Hal context
value	Value to write

Returns

uint32_t Number of bytes transfered

Definition at line 399 of file EVE_HalImpl_FT9XX.c.

{
    uint8_t buffer[4];
    if (phost->Status == EVE_STATUS_READING)
    {
        rdBuffer(phost, buffer, 4);
        return (uint32_t)buffer[0]
            | (uint32_t)buffer[1] << 8
            | (uint32_t)buffer[2] << 16
            | (uint32_t)buffer[3] << 24;
    }
    else
    {
        buffer[0] = value & 0xFF;
        buffer[1] = (value >> 8) & 0xFF;
        buffer[2] = (value >> 16) & 0xFF;
        buffer[3] = value >> 24;
        wrBuffer(phost, buffer, 4);
        return 0;
    }
}

EVE_Hal_transfer8()

uint8_t EVE_Hal_transfer8	(	EVE_HalContext *	phost,
		uint8_t	value
	)

Write 8 bits to Coprocessor.

Parameters

phost	Pointer to Hal context
value	Value to write

Returns

uint8_t Number of bytes transfered

Definition at line 362 of file EVE_HalImpl_FT9XX.c.

{
    return transfer8(phost, value);
}

EVE_Hal_transferMem()

void EVE_Hal_transferMem	(	EVE_HalContext *	phost,
		uint8_t *	result,
		const uint8_t *	buffer,
		uint32_t	size
	)

Transfer (read/write) a block data to Coprocessor.

Parameters

phost	Pointer to Hal context
result	Buffer to get data transfered, NULL when write
buffer	Buffer where data is transfered, NULL when read
size	Size of buffer

Definition at line 429 of file EVE_HalImpl_FT9XX.c.

{
    if (!size)
        return;
 
    if (result && buffer)
    {
        /* not implemented */
        eve_debug_break();
    }
    else if (result)
    {
        rdBuffer(phost, result, size);
    }
    else if (buffer)
    {
        wrBuffer(phost, buffer, size);
    }
}

EVE_Hal_transferProgMem()

void EVE_Hal_transferProgMem	(	EVE_HalContext *	phost,
		uint8_t *	result,
		eve_progmem_const uint8_t *	buffer,
		uint32_t	size
	)

Transfer a block data from program memory.

Parameters

phost	Pointer to Hal context
result	Buffer to get data transfered, NULL when write
buffer	Buffer where data is transfered, NULL when read
size	Size of buffer

Definition at line 457 of file EVE_HalImpl_FT9XX.c.

{
    if (!size)
        return;
 
    if (result && buffer)
    {
        /* not implemented */
        eve_debug_break();
    }
    else if (result)
    {
        /* not implemented */
        eve_debug_break();
    }
    else if (buffer)
    {
        eve_assert(!((uintptr_t)buffer & 0x3)); // must be 32-bit aligned
        eve_assert(!(size & 0x3)); // must be 32-bit aligned
        eve_progmem_const uint32_t *buf32 = (eve_progmem_const uint32_t *)(void eve_progmem_const *)buffer;
        size >>= 2;
        while (size--)
        {
            uint32_t value = *(buf32++);
            wrBuffer(phost, (uint8_t *)(&value), 4);
        }
    }
}

EVE_Hal_transferString()

uint32_t EVE_Hal_transferString	(	EVE_HalContext *	phost,
		const char *	str,
		uint32_t	index,
		uint32_t	size,
		uint32_t	padMask
	)

Transfer a string to EVE platform.

Parameters

phost	Pointer to Hal context
str	String to transfer
index	Start position in the string
size	Size of string
padMask	Padding mask

Returns

uint32_t Numer of bytes transfered

Definition at line 496 of file EVE_HalImpl_FT9XX.c.

{
    if (!size)
    {
        /* TODO: Support different padding options */
        eve_assert(padMask == 0x3);
        EVE_Hal_transfer32(phost, 0);
        return 4;
    }
 
    eve_assert(size <= EVE_CMD_STRING_MAX);
    uint32_t transferred = 0;
    if (phost->Status == EVE_STATUS_WRITING)
    {
        transferred += (uint32_t)strnlen(str, size) + 1;
        eve_assert(str[transferred - 1] == '\0');
        wrBuffer(phost, (uint8_t *)str, transferred);
        if (transferred & padMask)
        {
            uint32_t pad = 4 - (transferred & padMask);
            uint8_t padding[4] = { 0 };
            wrBuffer(phost, padding, pad);
            transferred += pad;
            eve_assert(!(transferred & 0x3));
        }
    }
    else
    {
        /* not implemented */
        eve_debug_break();
    }
    return transferred;
}

EVE_HalImpl_close()

void EVE_HalImpl_close

(

EVE_HalContext *

phost

)

Close a HAL context.

Parameters

phost

Pointer to Hal context

Definition at line 223 of file EVE_HalImpl_FT9XX.c.

{
    phost->Status = EVE_STATUS_CLOSED;
    --g_HalPlatform.OpenedDevices;
#ifndef PANL_APPLET
    spi_close(SPIM, phost->SpiCsPin);
#endif
}

EVE_HalImpl_defaults()

bool EVE_HalImpl_defaults	(	EVE_HalParameters *	parameters,
		size_t	deviceIdx
	)

Get the default configuration parameters.

Parameters

parameters	EVE_Hal framework's parameters
deviceIdx

Returns

true True if ok

false False if error

Definition at line 116 of file EVE_HalImpl_FT9XX.c.

{
    parameters->PowerDownPin = GPIO_FT800_PWD;
    parameters->SpiCsPin = deviceIdx < GPIO_SS_NB ? deviceIdx : 0; // SS0-3
    return true;
}

EVE_HalImpl_idle()

void EVE_HalImpl_idle

(

EVE_HalContext *

phost

)

Idle. Call regularly to update frequently changing internal state.

Parameters

phost

Pointer to Hal context

Definition at line 237 of file EVE_HalImpl_FT9XX.c.

{
    /* no-op */
}

EVE_HalImpl_initialize()

void EVE_HalImpl_initialize

(

)

Initialize HAL platform.

Initialize HAL platform

Definition at line 57 of file EVE_HalImpl_FT9XX.c.

{
}

EVE_HalImpl_open()

bool EVE_HalImpl_open	(	EVE_HalContext *	phost,
		const EVE_HalParameters *	parameters
	)

Opens a new HAL context using the specified parameters.

Parameters

phost	Pointer to Hal context
parameters	EVE_Hal framework's parameters

Returns

true True if ok

false False if error

Definition at line 191 of file EVE_HalImpl_FT9XX.c.

{
    phost->SpiCsPin = parameters->SpiCsPin < GPIO_SS_NB ? parameters->SpiCsPin : 0;
    phost->PowerDownPin = parameters->PowerDownPin;
    eve_printf_debug("EVE open PWD: %d, SS: %d\n",
        (unsigned int)phost->PowerDownPin, (unsigned int)s_SpimGpioSS[phost->SpiCsPin]);
 
#ifdef EVE_MULTI_GRAPHICS_TARGET
    phost->GpuDefs = &EVE_GpuDefs_FT80X;
#endif
 
    gpio_function(phost->PowerDownPin, pad_func_0);
    gpio_dir(phost->PowerDownPin, pad_dir_output);
    gpio_write(phost->PowerDownPin, 0);
 
    /* Initialize single channel */
    setSPI(phost, EVE_SPI_SINGLE_CHANNEL, 1);
 
    gpio_write(phost->PowerDownPin, 1);
 
    /* Initialize the context variables */
    phost->Status = EVE_STATUS_OPENED;
    ++g_HalPlatform.OpenedDevices;
 
    return true;
}

EVE_HalImpl_release()

void EVE_HalImpl_release

(

)

Release HAL platform.

Release HAL platform

Definition at line 65 of file EVE_HalImpl_FT9XX.c.

{
#ifndef PANL_APPLET
    spi_uninit(SPIM);
#endif
}

EVE_Mcu_initialize()

void EVE_Mcu_initialize

(

)

Init FT9x host MCU.

Definition at line 720 of file EVE_HalImpl_FT9XX.c.

{
#ifndef PANL_APPLET
    sys_reset_all();
 
    interrupt_enable_globally();
 
    sys_enable(sys_device_uart0);
    gpio_function(GPIO_UART0_TX, pad_uart0_txd); /* UART0 TXD */
    gpio_function(GPIO_UART0_RX, pad_uart0_rxd); /* UART0 RXD */
    uart_open(UART0, /* Device */
        1, /* Prescaler = 1 */
        UART_DIVIDER_115200_BAUD, /* Divider = 1302 */
        uart_data_bits_8, /* No. Data Bits */
        uart_parity_none, /* Parity */
        uart_stop_bits_1); /* No. Stop Bits */
#endif
 
#if (defined(ENABLE_ILI9488_HVGA_PORTRAIT) || defined(ENABLE_KD2401_HVGA_PORTRAIT))
    /* assign all the respective pins to GPIO and set them to default values */
    gpio_function(GPIO_ILI9488_DCX, pad_ili9488_dcx);
    gpio_dir(GPIO_ILI9488_DCX, pad_dir_output);
    gpio_write(GPIO_ILI9488_DCX, 1);
 
    gpio_function(GPIO_SPIM_CLK, pad_spim_sck);
    gpio_dir(GPIO_SPIM_CLK, pad_dir_output);
    gpio_write(GPIO_SPIM_CLK, 1);
 
    gpio_function(GPIO_SPIM_MOSI, pad_spim_mosi);
    gpio_dir(GPIO_SPIM_MOSI, pad_dir_output);
    gpio_write(GPIO_SPIM_MOSI, 1);
 
    gpio_function(GPIO_ILI9488_CS1, pad_ili9488_cs1);
    gpio_dir(GPIO_ILI9488_CS1, pad_dir_output);
    gpio_write(GPIO_ILI9488_CS1, 1);
 
    gpio_function(GPIO_SPIM_MISO, pad_spim_miso);
    gpio_dir(GPIO_SPIM_MISO, pad_dir_output);
    gpio_write(GPIO_SPIM_MISO, 1);
 
    gpio_function(GPIO_SPIM_SS0, pad_spim_ss0);
    gpio_dir(GPIO_SPIM_SS0, pad_dir_output);
    gpio_write(GPIO_SPIM_SS0, 1);
 
    gpio_function(GPIO_FT800_PWD, pad_func_0); /* FIXME: This needs to be done at open, not init */
    gpio_dir(GPIO_FT800_PWD, pad_dir_output);
    gpio_write(GPIO_FT800_PWD, 1);
 
    gpio_write(GPIO_ILI9488_DCX, 1);
    gpio_write(GPIO_SPIM_SS0, 1);
    gpio_write(GPIO_FT800_PWD, 1);
    gpio_write(GPIO_ILI9488_CS1, 1);
#endif
 
    initSdHost();
}

EVE_Mcu_release()

void EVE_Mcu_release

(

)

Release FT9x host MCU.

Definition at line 781 of file EVE_HalImpl_FT9XX.c.

{
    /* no-op */
}

EVE_millis()

uint32_t EVE_millis

(

)

Get clock in miliseond.

Need to ensure that below api is called at least once in 6.5 seconds duration for FT900 platform as this module doesnt use timer for context update global counter to loopback after ~49.71 days

Returns

uint32_t Clock number

Definition at line 842 of file EVE_HalImpl_FT9XX.c.

{
#if defined(PANL_APPLET)
    uint32_t ms = panl_timer_get_time();
    if ((uint64_t)ms < s_TotalMilliseconds)
        s_TotalMilliseconds64 += (1 << 32);
    s_TotalMilliseconds = ms;
    s_TotalMilliseconds64 = (s_TotalMilliseconds64 & ~0xFFFFFFFFULL) | (uint64_t)ms;
#endif
    return s_TotalMilliseconds;
}

EVE_millis64()

uint64_t EVE_millis64

(

)

Get clock in miliseond.

Need to ensure that below api is called at least once in 6.5 seconds duration for FT900 platform as this module doesnt use timer for context update global counter to loopback after ~49.71 days

Returns

uint32_t Clock number

Definition at line 862 of file EVE_HalImpl_FT9XX.c.

{
#if defined(PANL_APPLET)
    uint32_t ms = panl_timer_get_time();
    if ((uint64_t)ms < s_TotalMilliseconds)
        s_TotalMilliseconds64 += (1 << 32);
    s_TotalMilliseconds = ms;
    s_TotalMilliseconds64 = (s_TotalMilliseconds64 & ~0xFFFFFFFFULL) | (uint64_t)ms;
#endif
    return s_TotalMilliseconds64;
}

EVE_Millis_initialize()

void EVE_Millis_initialize

(

)

Init FT9x timer.

Definition at line 802 of file EVE_HalImpl_FT9XX.c.

{
    s_TotalMilliseconds = 0;
#if !defined(PANL_APPLET)
    sys_enable(sys_device_timer_wdt);
#if defined(FT900_PLATFORM)
    timer_prescaler(FT900_TIMER_PRESCALE_VALUE);
#else
    timer_prescaler(FT900_FT_MILLIS_TIMER, FT900_TIMER_PRESCALE_VALUE);
#endif
    timer_init(FT900_FT_MILLIS_TIMER, FT900_TIMER_OVERFLOW_VALUE, timer_direction_up, timer_prescaler_select_on, timer_mode_continuous);
 
    interrupt_attach(interrupt_timers, 17, ticker);
    /* enabling the interrupts for timer */
    timer_enable_interrupt(FT900_FT_MILLIS_TIMER);
 
    timer_start(FT900_FT_MILLIS_TIMER);
#endif
}

EVE_Millis_release()

void EVE_Millis_release

(

)

Release FT9x timer.

Definition at line 826 of file EVE_HalImpl_FT9XX.c.

{
#if !defined(PANL_APPLET)
    timer_stop(FT900_FT_MILLIS_TIMER);
    timer_disable_interrupt(FT900_FT_MILLIS_TIMER);
#endif
}

EVE_sleep()

void EVE_sleep

(

uint32_t

ms

)

Sleep in milisecond.

Parameters

ms	Milisecond

Definition at line 895 of file EVE_HalImpl_FT9XX.c.

{
    delayms(ms);
}

EVE_UtilImpl_bootupDisplayGpio()

bool EVE_UtilImpl_bootupDisplayGpio

(

EVE_HalContext *

phost

)

Display GPIO pins.

Parameters

phost

Pointer to Hal context

Returns

true True if Ok

false False if error

Definition at line 915 of file EVE_HalImpl_FT9XX.c.

{
    return true;
}

initSdHost()

static void initSdHost ( )

static

Sdcard initialization.

Definition at line 685 of file EVE_HalImpl_FT9XX.c.

{
#ifndef PANL_APPLET
#if 1
    /* All SD Host pins except CLK need a pull-up to work. The MM900EV*A module does not have external pull-up, so enable internal one */
    gpio_function(GPIO_SD_CLK, pad_sd_clk);
    gpio_pull(GPIO_SD_CLK, pad_pull_none);
    gpio_function(GPIO_SD_CMD, pad_sd_cmd);
    gpio_pull(GPIO_SD_CMD, pad_pull_pullup);
    gpio_function(GPIO_SD_DAT3, pad_sd_data3);
    gpio_pull(GPIO_SD_DAT3, pad_pull_pullup);
    gpio_function(GPIO_SD_DAT2, pad_sd_data2);
    gpio_pull(GPIO_SD_DAT2, pad_pull_pullup);
    gpio_function(GPIO_SD_DAT1, pad_sd_data1);
    gpio_pull(GPIO_SD_DAT1, pad_pull_pullup);
    gpio_function(GPIO_SD_DAT0, pad_sd_data0);
    gpio_pull(GPIO_SD_DAT0, pad_pull_pullup);
    gpio_function(GPIO_SD_CD, pad_sd_cd);
    gpio_pull(GPIO_SD_CD, pad_pull_pullup);
    gpio_function(GPIO_SD_WP, pad_sd_wp);
    gpio_pull(GPIO_SD_WP, pad_pull_pullup);
 
    /* Start up the SD Card */
    sys_enable(sys_device_sd_card);
#else
    sdhost_sys_init();
#endif
    sdhost_init();
#endif
}

rdBuffer()

static void rdBuffer ( EVE_HalContext *  phost, uint8_t *  buffer, uint32_t  size  )

inlinestatic

Read a block data from Coprocessor.

Parameters

phost	Pointer to Hal context
buffer	Buffer to get result
size	Number of bytes to read

Definition at line 317 of file EVE_HalImpl_FT9XX.c.

{
    spi_readn(SPIM, buffer, size);
}

setSPI()

void setSPI	(	EVE_HalContext *	phost,
		EVE_SPI_CHANNELS_T	numchnls,
		uint8_t	numdummy
	)

Set number of SPI channel.

Parameters

phost	Pointer to Hal context
numchnls	Number of channel
numdummy	Number of dummy bytes

Definition at line 130 of file EVE_HalImpl_FT9XX.c.

{
    uint8_t spimGpio = s_SpimGpioSS[phost->SpiCsPin];
    pad_dir_t spimFunc = s_SpimFuncSS[phost->SpiCsPin];
 
    /* Reconfigure the SPI */
    eve_assert_do(!sys_enable(sys_device_spi_master));
    gpio_function(GPIO_SPIM_CLK, pad_spim_sck); /* GPIO27 to SPIM_CLK */
    gpio_function(spimGpio, spimFunc); /* GPIO as SS0-SS4 */
    gpio_function(GPIO_SPIM_MOSI, pad_spim_mosi); /* GPIO29 to SPIM_MOSI */
    gpio_function(GPIO_SPIM_MISO, pad_spim_miso); /* GPIO30 to SPIM_MISO */
 
    gpio_dir(GPIO_SPIM_CLK, pad_dir_output);
    gpio_dir(spimGpio, pad_dir_output);
    gpio_dir(GPIO_SPIM_MOSI, pad_dir_output);
    gpio_dir(GPIO_SPIM_MISO, pad_dir_input);
 
    if (numchnls > EVE_SPI_SINGLE_CHANNEL)
    {
        /* Initialize IO2 and IO3 pad/pin for dual and quad settings */
        gpio_function(GPIO_SPIM_IO2, pad_spim_io2);
        gpio_function(GPIO_SPIM_IO3, pad_spim_io3);
        gpio_dir(GPIO_SPIM_IO2, pad_dir_output);
        gpio_dir(GPIO_SPIM_IO3, pad_dir_output);
    }
 
    gpio_write(spimGpio, 1);
 
    /* Change clock frequency to 25 MHz (100 MHz / 4) */
    eve_assert_do(!spi_init(SPIM, spi_dir_master, spi_mode_0, 4));
 
    /* Enable FIFO of QSPI */
    spi_option(SPIM, spi_option_fifo_size, 64);
    spi_option(SPIM, spi_option_fifo, 1);
    spi_option(SPIM, spi_option_fifo_receive_trigger, 1);
 
    switch (numchnls)
    {
    case EVE_SPI_QUAD_CHANNEL:
        spi_option(SPIM, spi_option_bus_width, 4);
        break;
    case EVE_SPI_DUAL_CHANNEL:
        spi_option(SPIM, spi_option_bus_width, 2);
        break;
    case EVE_SPI_SINGLE_CHANNEL:
        spi_option(SPIM, spi_option_bus_width, 1);
        break;
    }
 
    phost->SpiChannels = numchnls;
    phost->SpiDummyBytes = numdummy;
}

ticker()

void ticker

(

)

Clear the interrupt and increment the counter.

Definition at line 878 of file EVE_HalImpl_FT9XX.c.

{
#if !defined(PANL_APPLET)
    s_TotalMilliseconds += 1;
 
    timer_disable_interrupt(FT900_FT_MILLIS_TIMER);
    /* Clear the interrupt and increment the counter */
    timer_is_interrupted(FT900_FT_MILLIS_TIMER);
    timer_enable_interrupt(FT900_FT_MILLIS_TIMER);
#endif
}

transfer8()

static uint8_t transfer8 ( EVE_HalContext *  phost, uint8_t  value  )

inlinestatic

Write 8 bit to Coprocessor.

Parameters

phost	Pointer to Hal context
value	Value to write

Returns

uint8_t Number of bytes transfered

Definition at line 341 of file EVE_HalImpl_FT9XX.c.

{
    if (phost->Status == EVE_STATUS_READING)
    {
        spi_read(SPIM, value);
        return value;
    }
    else
    {
        spi_write(SPIM, value);
        return 0;
    }
}

wrBuffer()

static void wrBuffer ( EVE_HalContext *  phost, const uint8_t *  buffer, uint32_t  size  )

inlinestatic

Write a block data to Coprocessor.

Parameters

phost	Pointer to Hal context
buffer	Data buffer to write
size	Size of buffer

Definition at line 329 of file EVE_HalImpl_FT9XX.c.

{
    spi_writen(SPIM, buffer, size);
}

Variable Documentation

s_SpimFuncSS

const pad_dir_t s_SpimFuncSS[4] = { pad_spim_ss0, pad_spim_ss1, pad_spim_ss2, pad_spim_ss3 }

static

Definition at line 42 of file EVE_HalImpl_FT9XX.c.

{ pad_spim_ss0, pad_spim_ss1, pad_spim_ss2, pad_spim_ss3 };

s_SpimGpioSS

const uint8_t s_SpimGpioSS[4] = { GPIO_SPIM_SS0, GPIO_SPIM_SS1, GPIO_SPIM_SS2, 35 }

static

Definition at line 41 of file EVE_HalImpl_FT9XX.c.

{ GPIO_SPIM_SS0, GPIO_SPIM_SS1, GPIO_SPIM_SS2, 35 };

s_TotalMilliseconds

uint32_t s_TotalMilliseconds = 0

static

Definition at line 792 of file EVE_HalImpl_FT9XX.c.

s_TotalMilliseconds64

uint64_t s_TotalMilliseconds64 = 0

static

Definition at line 793 of file EVE_HalImpl_FT9XX.c.