EVE_Cmd.c File Reference

EVE's command read/write. More...

#include "EVE_Cmd.h"
#include "EVE_Platform.h"

Go to the source code of this file.

Functions
static void	endFunc (EVE_HalContext *phost)
	End read/write to Coprocessor.
EVE_HAL_EXPORT uint16_t	EVE_Cmd_rp (EVE_HalContext *phost)
	Read from Coprocessor.
EVE_HAL_EXPORT uint16_t	EVE_Cmd_wp (EVE_HalContext *phost)
	Write to Coprocessor.
EVE_HAL_EXPORT uint16_t	EVE_Cmd_space (EVE_HalContext *phost)
	Get free space of Coprocessor's command buffer.
static void	startBufferTransfer (EVE_HalContext *phost)
	Start transfer data to EVE.
static uint32_t	wrString (EVE_HalContext *phost, const void *buffer, uint32_t *size, uint32_t transfered, uint32_t transfer)
	Write string to Coprocessor's comand fifo.
static uint32_t	wrBuffer (EVE_HalContext *phost, const void *buffer, uint32_t size, bool progmem, bool string)
	Write buffer to Coprocessor's comand fifo.
EVE_HAL_EXPORT void	EVE_Cmd_startFunc (EVE_HalContext *phost)
	Begin writing a function, keeps the transfer open.
EVE_HAL_EXPORT void	EVE_Cmd_endFunc (EVE_HalContext *phost)
	End writing a function, closes the transfer.
EVE_HAL_EXPORT bool	EVE_Cmd_wrMem (EVE_HalContext *phost, const uint8_t *buffer, uint32_t size)
	Write buffer to Coprocessor's comand fifo.
EVE_HAL_EXPORT bool	EVE_Cmd_wrProgMem (EVE_HalContext *phost, eve_progmem_const uint8_t *buffer, uint32_t size)
	Write buffer in ProgMem to Coprocessor's comand fifo.
EVE_HAL_EXPORT uint32_t	EVE_Cmd_wrString (EVE_HalContext *phost, const char *str, uint32_t maxLength)
	Write a string into Coprocessor's command fifo.
EVE_HAL_EXPORT bool	EVE_Cmd_wr8 (EVE_HalContext *phost, uint8_t value)
	Write a byte to Coprocessor's command fifo.
EVE_HAL_EXPORT bool	EVE_Cmd_wr16 (EVE_HalContext *phost, uint16_t value)
	Write 2 bytes to Coprocessor's command fifo.
EVE_HAL_EXPORT bool	EVE_Cmd_wr32 (EVE_HalContext *phost, uint32_t value)
	Write 4 bytes to Coprocessor's command fifo.
EVE_HAL_EXPORT uint16_t	EVE_Cmd_moveWp (EVE_HalContext *phost, uint16_t bytes)
	Move the write pointer forward by the specified number of bytes. Returns the previous write pointer.
void	debugBackupRamG (EVE_HalContext *phost)
	Backup the last 128 bytes of RAM_G, which may be used for an error message.
static bool	checkWait (EVE_HalContext *phost, uint16_t rpOrSpace)
	Check for coprocessor fault.
static bool	handleWait (EVE_HalContext *phost, uint16_t rpOrSpace)
	Wait handler.
EVE_HAL_EXPORT bool	EVE_Cmd_waitFlush (EVE_HalContext *phost)
	Wait till Command FIFO buffer empty.
EVE_HAL_EXPORT uint32_t	EVE_Cmd_waitSpace (EVE_HalContext *phost, uint32_t size)
EVE_HAL_EXPORT bool	EVE_Cmd_waitLogo (EVE_HalContext *phost)
	Wait until Coprocessor finished logo animation.
EVE_HAL_EXPORT bool	EVE_Cmd_waitRead32 (EVE_HalContext *phost, uint32_t ptr, uint32_t value)
EVE_HAL_EXPORT void	EVE_Cmd_restore (EVE_HalContext *phost)

Detailed Description

EVE's command read/write.

This file defines the generic APIs of phost access layer for the FT800 or EVE compatible silicon. Application shall access FT800 or EVE resources over these APIs,regardless of I2C or SPI protocol. In addition, there are some helper functions defined for FT800 coprocessor engine as well as phost commands.

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

Function Documentation

checkWait()

static bool checkWait ( EVE_HalContext *  phost, uint16_t  rpOrSpace  )

static

Check for coprocessor fault.

Parameters

phost	Pointer to Hal context
rpOrSpace	Read pointer or space

Returns

true True if ok

false False if coprocessor fault

Definition at line 481 of file EVE_Cmd.c.

{
    /* Check for coprocessor fault */
    if (EVE_CMD_FAULT(rpOrSpace))
    {
        char err[128];
        err[0] = '\0';
        /* Coprocessor fault */
        phost->CmdWaiting = false;
#if defined(_DEBUG)
        if (!phost->DebugMessageVisible)
        {
            eve_printf_debug("Coprocessor fault\n");
            debugBackupRamG(phost);
            if (EVE_CHIPID >= EVE_BT815)
            {
                EVE_Hal_rdMem(phost, (uint8_t *)err, RAM_ERR_REPORT, 128);
                eve_printf_debug("%s\n", err);
                EVE_Hal_displayMessage(phost, err, 128);
            }
            else
            {
                EVE_Hal_displayMessage(phost, "Coprocessor fault ", sizeof("Coprocessor fault "));
            }
        }
#endif
        return false;
    }
 
    if (phost->Status == EVE_STATUS_ERROR || phost->Status == EVE_STATUS_CLOSED)
    {
        phost->CmdWaiting = false;
        eve_printf_debug("Host error\n");
        return false;
    }
 
    return true;
}

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

endFunc()

static void endFunc ( EVE_HalContext *  phost )

inlinestatic

End read/write to Coprocessor.

Parameters

phost

Pointer to Hal context

Definition at line 44 of file EVE_Cmd.c.

{
    if (phost->Status == EVE_STATUS_WRITING)
    {
        EVE_Hal_endTransfer(phost);
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
        if (!EVE_Hal_supportCmdB(phost))
        {
            EVE_Hal_wr16(phost, REG_CMD_WRITE, phost->CmdWp);
        }
#endif
    }
}

EVE_Cmd_endFunc()

EVE_HAL_EXPORT void EVE_Cmd_endFunc

(

EVE_HalContext *

phost

)

End writing a function, closes the transfer.

Parameters

phost

Pointer to Hal context

Definition at line 274 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
    endFunc(phost);
    phost->CmdFunc = false;
}

EVE_Cmd_moveWp()

EVE_HAL_EXPORT uint16_t EVE_Cmd_moveWp	(	EVE_HalContext *	phost,
		uint16_t	bytes
	)

Move the write pointer forward by the specified number of bytes. Returns the previous write pointer.

Parameters

phost	Pointer to Hal context
bytes	Number of bytes to move

Returns

uint16_t Previous write pointer

Definition at line 446 of file EVE_Cmd.c.

{
    uint16_t wp;
    uint16_t prevWp;
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
 
    if (!EVE_Cmd_waitSpace(phost, bytes))
        return -1;
 
    prevWp = EVE_Cmd_wp(phost);
    wp = (prevWp + bytes) & EVE_CMD_FIFO_MASK;
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
    if (!EVE_Hal_supportCmdB(phost))
    {
        phost->CmdWp = wp;
    }
#endif
    EVE_Hal_wr16(phost, REG_CMD_WRITE, wp);
 
    return prevWp;
}

EVE_Cmd_restore()

EVE_HAL_EXPORT void EVE_Cmd_restore

(

EVE_HalContext *

phost

)

Restore the internal state of EVE_Cmd. Call this after manually writing to the coprocessor buffer

Definition at line 682 of file EVE_Cmd.c.

{
    EVE_Cmd_rp(phost);
    EVE_Cmd_wp(phost);
    EVE_Cmd_space(phost);
}

EVE_Cmd_rp()

EVE_HAL_EXPORT uint16_t EVE_Cmd_rp

(

EVE_HalContext *

phost

)

Read from Coprocessor.

Parameters

phost

Pointer to Hal context

Returns

uint16_t Read pointer

Definition at line 64 of file EVE_Cmd.c.

{
    uint16_t rp;
    endFunc(phost);
    rp = EVE_Hal_rd16(phost, REG_CMD_READ) & EVE_CMD_FIFO_MASK;
    if (EVE_CMD_FAULT(rp))
        phost->CmdFault = true;
    return rp;
}

EVE_Cmd_space()

EVE_HAL_EXPORT uint16_t EVE_Cmd_space

(

EVE_HalContext *

phost

)

Get free space of Coprocessor's command buffer.

Parameters

phost

Pointer to Hal context

Returns

uint16_t Free space in Bytes

Definition at line 105 of file EVE_Cmd.c.

{
    uint16_t space;
    uint16_t wp;
    uint16_t rp;
    endFunc(phost);
    if (EVE_Hal_supportCmdB(phost))
    {
        space = EVE_Hal_rd16(phost, REG_CMDB_SPACE) & EVE_CMD_FIFO_MASK;
        if (EVE_CMD_FAULT(space))
            phost->CmdFault = true;
        phost->CmdSpace = space;
        return space;
    }
    else
    {
        wp = EVE_Cmd_wp(phost);
        rp = EVE_Cmd_rp(phost);
        space = (rp - wp - 4) & EVE_CMD_FIFO_MASK;
        phost->CmdSpace = space;
        return space;
    }
}

EVE_Cmd_startFunc()

EVE_HAL_EXPORT void EVE_Cmd_startFunc

(

EVE_HalContext *

phost

)

Begin writing a function, keeps the transfer open.

Parameters

phost

Pointer to Hal context

Definition at line 262 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
    phost->CmdFunc = true;
}

EVE_Cmd_waitFlush()

EVE_HAL_EXPORT bool EVE_Cmd_waitFlush

(

EVE_HalContext *

phost

)

Wait till Command FIFO buffer empty.

Parameters

phost

Pointer to Hal context

Returns

true True if ok

false False if error

Definition at line 555 of file EVE_Cmd.c.

{
    uint16_t rp;
    uint16_t wp;
 
    eve_assert(!phost->CmdWaiting);
    phost->CmdWaiting = true;
    while ((rp = EVE_Cmd_rp(phost)) != (wp = EVE_Cmd_wp(phost)))
    {
        if (!handleWait(phost, rp))
        {
            phost->CmdSpace = (rp - wp - 4) & EVE_CMD_FIFO_MASK;
            return false;
        }
    }
 
    /* Command buffer empty */
    phost->CmdSpace = EVE_CMD_FIFO_SIZE - 4;
    phost->CmdWaiting = false;
    return true;
}

EVE_Cmd_waitLogo()

EVE_HAL_EXPORT bool EVE_Cmd_waitLogo

(

EVE_HalContext *

phost

)

Wait until Coprocessor finished logo animation.

Parameters

phost

Pointer to Hal context

Returns

true True if ok

false False if error

Definition at line 625 of file EVE_Cmd.c.

{
    uint16_t rp;
    uint16_t wp;
 
    eve_assert(!phost->CmdWaiting);
    phost->CmdWaiting = true;
 
    do
    {
        rp = EVE_Cmd_rp(phost);
        wp = EVE_Cmd_wp(phost);
        if (!handleWait(phost, rp))
            return false;
 
    } while ((wp != 0) || (rp != 0));
 
    phost->CmdWaiting = false;
    return true;
}

EVE_Cmd_waitRead32()

EVE_HAL_EXPORT bool EVE_Cmd_waitRead32	(	EVE_HalContext *	phost,
		uint32_t	ptr,
		uint32_t	value
	)

Wait for a 32-bit value that was set by EVE_CoCmd_memWrite32(phost, ptr, value).

Returns

true when the value is found.

false otherwise when the coprocessor has flushed, or a coprocessor fault occured.

Definition at line 651 of file EVE_Cmd.c.

{
    uint16_t rp;
    uint16_t wp;
 
    eve_assert(!phost->CmdWaiting);
    phost->CmdWaiting = true;
    while ((rp = EVE_Cmd_rp(phost)) != (wp = EVE_Cmd_wp(phost)))
    {
        if (EVE_Hal_rd32(phost, ptr) == value)
        {
            /* Expected value has been read */
            phost->CmdWaiting = false;
            return true;
        }
        if (!handleWait(phost, rp))
        {
            phost->CmdSpace = (rp - wp - 4) & EVE_CMD_FIFO_MASK;
            return false;
        }
    }
 
    /* Command buffer empty */
    phost->CmdSpace = EVE_CMD_FIFO_SIZE - 4;
    phost->CmdWaiting = false;
    return EVE_Hal_rd32(phost, ptr) == value;
}

EVE_Cmd_waitSpace()

EVE_HAL_EXPORT uint32_t EVE_Cmd_waitSpace	(	EVE_HalContext *	phost,
		uint32_t	size
	)

Wait for the command buffer to have at least the requested amount of free space.

Returns

0 in case a coprocessor fault occurred

Definition at line 580 of file EVE_Cmd.c.

{
    uint16_t space;
 
    if (size > (EVE_CMD_FIFO_SIZE - 4))
    {
        eve_printf_debug("Requested free space exceeds coprocessor FIFO\n");
        return 0;
    }
 
    eve_assert(!phost->CmdWaiting);
    phost->CmdWaiting = true;
 
    space = phost->CmdSpace;
 
#if 1
    /* Optimization. 
    Only update space if more space is needed than already known available, 
    or when not actually waiting for any space */
    if (space < size || !size)
        space = EVE_Cmd_space(phost);
    if (!checkWait(phost, space))
        return 0;
#endif
 
    /* Wait until there's sufficient space */
    while (space < size)
    {
        space = EVE_Cmd_space(phost);
        if (!handleWait(phost, space))
            return 0;
    }
 
    /* Sufficient space */
    phost->CmdWaiting = false;
    return space;
}

EVE_Cmd_wp()

EVE_HAL_EXPORT uint16_t EVE_Cmd_wp

(

EVE_HalContext *

phost

)

Write to Coprocessor.

Parameters

phost

Pointer to Hal context

Returns

uint16_t Write pointer

Definition at line 80 of file EVE_Cmd.c.

{
    endFunc(phost);
    if (EVE_Hal_supportCmdB(phost))
    {
        return EVE_Hal_rd16(phost, REG_CMD_WRITE) & EVE_CMD_FIFO_MASK;
    }
    else
    {
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
        phost->CmdWp = EVE_Hal_rd16(phost, REG_CMD_WRITE) & EVE_CMD_FIFO_MASK;
        return phost->CmdWp;
#else
        eve_assert(false);
        return 0xffff;
#endif
    }
}

EVE_Cmd_wr16()

EVE_HAL_EXPORT bool EVE_Cmd_wr16	(	EVE_HalContext *	phost,
		uint16_t	value
	)

Write 2 bytes to Coprocessor's command fifo.

Parameters

phost	Pointer to Hal context
value	Data to write

Returns

true True if ok

false False if error

Definition at line 366 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex < 3);
 
    if (phost->CmdBufferIndex < 3)
    {
        phost->CmdBuffer[phost->CmdBufferIndex++] = value & 0xFF;
        phost->CmdBuffer[phost->CmdBufferIndex++] = value >> 8;
    }
 
    if (phost->CmdBufferIndex == 4)
    {
        phost->CmdBufferIndex = 0;
        return EVE_Cmd_wrMem(phost, phost->CmdBuffer, 4);
    }
 
    return true;
}

EVE_Cmd_wr32()

EVE_HAL_EXPORT bool EVE_Cmd_wr32	(	EVE_HalContext *	phost,
		uint32_t	value
	)

Write 4 bytes to Coprocessor's command fifo.

Parameters

phost	Pointer to Hal context
value	Data to write

Returns

true True if ok

false False if error

Definition at line 394 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
 
    if (phost->CmdSpace < 4 && !EVE_Cmd_waitSpace(phost, 4))
        return false;
 
    if (phost->Status != EVE_STATUS_WRITING)
    {
        if (EVE_Hal_supportCmdB(phost))
        {
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, REG_CMDB_WRITE);
        }
        else
        {
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, RAM_CMD + phost->CmdWp);
#else
            eve_assert(false);
#endif
        }
    }
    EVE_Hal_transfer32(phost, value);
    if (!phost->CmdFunc) /* Keep alive while writing function */
    {
        EVE_Hal_endTransfer(phost);
    }
    eve_assert(phost->CmdSpace >= 4);
    phost->CmdSpace -= 4;
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
    if (!EVE_Hal_supportCmdB(phost))
    {
        phost->CmdWp += 4;
        phost->CmdWp &= EVE_CMD_FIFO_MASK;
        if (!phost->CmdFunc) /* Defer write pointer */
        {
            EVE_Hal_wr16(phost, REG_CMD_WRITE, phost->CmdWp);
        }
    }
#endif
 
    return true;
}

EVE_Cmd_wr8()

EVE_HAL_EXPORT bool EVE_Cmd_wr8	(	EVE_HalContext *	phost,
		uint8_t	value
	)

Write a byte to Coprocessor's command fifo.

Parameters

phost	Pointer to Hal context
value	Byte to write

Returns

true True if ok

false False if error

Definition at line 339 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex < 4);
 
    if (phost->CmdBufferIndex < 4)
    {
        phost->CmdBuffer[phost->CmdBufferIndex++] = value;
    }
 
    if (phost->CmdBufferIndex == 4)
    {
        phost->CmdBufferIndex = 0;
        return EVE_Cmd_wrMem(phost, phost->CmdBuffer, 4);
    }
 
    return true;
}

EVE_Cmd_wrMem()

EVE_HAL_EXPORT bool EVE_Cmd_wrMem	(	EVE_HalContext *	phost,
		const uint8_t *	buffer,
		uint32_t	size
	)

Write buffer to Coprocessor's comand fifo.

Parameters

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

Returns

true Write ok

false Write error

Definition at line 291 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
    return wrBuffer(phost, buffer, size, false, false) == size;
}

EVE_Cmd_wrProgMem()

EVE_HAL_EXPORT bool EVE_Cmd_wrProgMem	(	EVE_HalContext *	phost,
		eve_progmem_const uint8_t *	buffer,
		uint32_t	size
	)

Write buffer in ProgMem to Coprocessor's comand fifo.

Parameters

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

Returns

true True if ok

false False if error

Definition at line 307 of file EVE_Cmd.c.

{
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
    return wrBuffer(phost, (void *)(uintptr_t)buffer, size, true, false) == size;
}

EVE_Cmd_wrString()

EVE_HAL_EXPORT uint32_t EVE_Cmd_wrString	(	EVE_HalContext *	phost,
		const char *	str,
		uint32_t	maxLength
	)

Write a string into Coprocessor's command fifo.

Parameters

phost	Pointer to Hal context
str	String to write
maxLength	Length to write, up to EVE_CMD_STRING_MAX

Returns

uint32_t Number of bytes transfered

Definition at line 322 of file EVE_Cmd.c.

{
    uint32_t transfered;
    eve_assert(!phost->CmdWaiting);
    eve_assert(phost->CmdBufferIndex == 0);
    transfered = wrBuffer(phost, str, maxLength, false, true);
    return transfered;
}

handleWait()

static bool handleWait ( EVE_HalContext *  phost, uint16_t  rpOrSpace  )

static

Wait handler.

Parameters

phost	Pointer to Hal context
rpOrSpace	Read pointer or space

Returns

true True if ok

false False if error

Definition at line 528 of file EVE_Cmd.c.

{
    /* Check for coprocessor fault */
    if (!checkWait(phost, rpOrSpace))
        return false;
 
    /* Process any idling */
    EVE_Hal_idle(phost);
 
    /* Process user idling */
    if (phost->CbCmdWait && !phost->CbCmdWait(phost))
    {
        /* Wait aborted */
        phost->CmdWaiting = false;
        eve_printf_debug("Wait for coprocessor aborted\n");
        return false;
    }
    return true;
}

startBufferTransfer()

static void startBufferTransfer ( EVE_HalContext *  phost )

static

Start transfer data to EVE.

Parameters

phost

Pointer to Hal context

Definition at line 134 of file EVE_Cmd.c.

{
    if (phost->Status != EVE_STATUS_WRITING)
    {
        if (EVE_Hal_supportCmdB(phost))
        {
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, REG_CMDB_WRITE);
        }
        else
        {
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
            EVE_Hal_startTransfer(phost, EVE_TRANSFER_WRITE, RAM_CMD + phost->CmdWp);
#else
            eve_assert(false);
#endif
        }
    }
}

wrBuffer()

static uint32_t wrBuffer ( EVE_HalContext *  phost, const void *  buffer, uint32_t  size, bool  progmem, bool  string  )

static

Write buffer to Coprocessor's comand fifo.

Parameters

phost	Pointer to Hal context
buffer	Data pointer
size	Size to write
progmem	True if ProgMem
string	True is string

Returns

uint32_t Byte transfered

Definition at line 191 of file EVE_Cmd.c.

{
    uint32_t transfered = 0;
 
    do
    {
        uint32_t transfer = (size - transfered);
        uint32_t space = phost->CmdSpace;
        uint32_t req = min((string ? (transfer + 1) : transfer), (EVE_CMD_FIFO_SIZE >> 1));
        eve_assert(!string || (req == (transfer + 1)));
        if (space < req)
        {
            if (!EVE_Cmd_waitSpace(phost, req))
                return transfered; /* Coprocessor fault */
            space = phost->CmdSpace;
        }
        if (transfer > space)
            transfer = space;
        eve_assert(transfer <= EVE_CMD_FIFO_SIZE - 4);
        if (transfer)
        {
            startBufferTransfer(phost);
            if (string)
            {
                transfer = wrString(phost, buffer, &size, transfered, transfer);
            }
            else if (progmem)
            {
                EVE_Hal_transferProgMem(phost, NULL, (eve_progmem_const uint8_t *)(uintptr_t)(&((uint8_t *)buffer)[transfered]), transfer);
            }
            else
            {
                EVE_Hal_transferMem(phost, NULL, &((uint8_t *)buffer)[transfered], transfer);
            }
            if (!string && (transfer & 0x3))
            {
                uint32_t pad = 4 - (transfer & 0x3);
                uint8_t padding[4] = { 0 };
                eve_assert((transfered + transfer) == size);
                EVE_Hal_transferMem(phost, NULL, padding, pad);
                transfer += pad;
                eve_assert(!(transfer & 0x3));
            }
            transfered += transfer;
            if (!phost->CmdFunc) /* Keep alive while writing function */
            {
                EVE_Hal_endTransfer(phost);
            }
            eve_assert(phost->CmdSpace >= transfer);
            phost->CmdSpace -= (uint16_t)transfer;
#if !defined(EVE_SUPPORT_CMDB) || defined(EVE_MULTI_GRAPHICS_TARGET)
            if (!EVE_Hal_supportCmdB(phost))
            {
                phost->CmdWp += (uint16_t)transfer;
                phost->CmdWp &= EVE_CMD_FIFO_MASK;
                if (!phost->CmdFunc) /* Defer write pointer */
                {
                    EVE_Hal_wr16(phost, REG_CMD_WRITE, phost->CmdWp);
                }
            }
#endif
        }
    } while (transfered < size);
    return transfered;
}

wrString()

static uint32_t wrString ( EVE_HalContext *  phost, const void *  buffer, uint32_t *  size, uint32_t  transfered, uint32_t  transfer  )

static

Write string to Coprocessor's comand fifo.

Parameters

phost	Pointer to Hal context
buffer	Data pointer
size	Size to write
transfer	Byte to transfer
transfered	Byte transfered

Returns

transfer Byte to transfer

Definition at line 163 of file EVE_Cmd.c.

{
    uint32_t t;
    eve_assert(transfered == 0);
    eve_assert(transfer == *size); /* Cannot split string transfers */
    eve_assert(transfer <= phost->CmdSpace);
    t = EVE_Hal_transferString(phost, (const char *)buffer, transfered, transfer, 0x3);
    if (t != transfer) /* End of string */
    {
        eve_assert(t <= phost->CmdSpace);
        transfer = t;
        *size = (transfered + transfer);
    }
    eve_assert((transfered + transfer) == *size);
 
    return transfer;
}