sysmocom
/
openblt
11
0
Fork 0
Code Issues Pull Requests Releases Activity

- Corrected whitespace formatting with Astyle tool. 

git-svn-id: https://svn.code.sf.net/p/openblt/code/trunk@132 5dc33758-31d5-4daf-9ae8-b24bf3d40d73
This commit is contained in:
Frank Voorburg 2016-03-01 14:24:23 +00:00
parent efbab9c73d
commit 90b766c778
173 changed files with 41206 additions and 38694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Doc/astyle.bat Normal file
View File

@ -0,0 +1,20 @@
@echo off
rem Configuration file for Astyle. Can be downloaded from: https://sourceforge.net/projects/astyle/?source=typ_redirect
rem Example usage: C:\Work\software\OpenBLT\Target\Source>..\..\Doc\astyle.bat *.c *.h
set ASTYLE_BIN="C:\AStyle\bin"
set ASTYLE_CODESTYLE_PARAMS=--mode=c --style=allman --indent=spaces=2 --indent-switches --pad-header --unpad-paren --lineend=windows --add-brackets --align-pointer=name
set ASTYLE_EXECUTION_PARAMS=--suffix=none --formatted --ignore-exclude-errors-x --recursive
echo.
echo ------------------ prepare astyle ---------------------------------------------
echo.
%ASTYLE_BIN%\AStyle.exe --version
echo style params: %ASTYLE_CODESTYLE_PARAMS%
echo exec params : %ASTYLE_EXECUTION_PARAMS%
echo user params : %*
echo target dir : %CD%
echo.
echo ------------------ astyle execution -------------------------------------------
echo.
%ASTYLE_BIN%\AStyle.exe %ASTYLE_CODESTYLE_PARAMS% %ASTYLE_EXECUTION_PARAMS% %*
echo.
echo ------------------ astyle done ------------------------------------------------

182
Target/Source/ARM7_LPC2000/Crossworks/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -67,13 +67,13 @@
/**************************************************************************************** /****************************************************************************************
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Function pointer type that is needed to call IAP functions of the /** \brief Function pointer type that is needed to call IAP functions of the
* NXP LPC2xxx. * NXP LPC2xxx.
*/ */
typedef void (*pIapHandler)(blt_int32u command[], blt_int32u result[]); typedef void (*pIapHandler)(blt_int32u command[], blt_int32u result[]);
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -82,17 +82,17 @@ typedef struct
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. Note that the .data member must be 32-bit aligned by the linker. * block. Note that the .data member must be 32-bit aligned by the linker.
* the .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * the .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
{ {
blt_addr base_addr; /**< Base address for the flash operation.*/ blt_addr base_addr; /**< Base address for the flash operation.*/
blt_int8u data[FLASH_WRITE_BLOCK_SIZE] __attribute__ ((aligned (4))); /**< Data array. */ blt_int8u data[FLASH_WRITE_BLOCK_SIZE] __attribute__((aligned(4))); /**< Data array. */
} tFlashBlockInfo; } tFlashBlockInfo;
@ -101,7 +101,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -112,11 +112,11 @@ static blt_int8u FlashGetSector(blt_addr address);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout supports the NXP LPC21xx and LPC22xx targets. * The current flash layout supports the NXP LPC21xx and LPC22xx targets.
* LPC23xx has a slightly different layout. To support the LPC23xx, simply * LPC23xx has a slightly different layout. To support the LPC23xx, simply
* update this flash layout. * update this flash layout.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -177,27 +177,27 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* LPC2000 is also the where the checksum is written to. Is it likely that the * LPC2000 is also the where the checksum is written to. Is it likely that the
* vector table is first flashed and then, at the end of the programming * vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed and * write the same values to those bytes that are not supposed to be changed and
* the locations where you do write to are still in the erased 0xFF state. * the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* the LPC2000. This is why we need to have an extra block, the bootblock, * the LPC2000. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
@ -208,7 +208,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -228,23 +228,23 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
{ {
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -260,24 +260,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -292,16 +292,16 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* The ARM7 core already has a spot reserved for a checksum that the bootloader can /* The ARM7 core already has a spot reserved for a checksum that the bootloader can
* store at the end of a programming session. * store at the end of a programming session.
* *
* Layout of the vector table (* = don't care) * Layout of the vector table (* = don't care)
* 0x******00 Reset Exception * 0x******00 Reset Exception
* 0x******04 Undefined Instruction Exception * 0x******04 Undefined Instruction Exception
@ -311,7 +311,7 @@ blt_bool FlashWriteChecksum(void)
* 0x******14 [reserved for signature checksum] * 0x******14 [reserved for signature checksum]
* 0x******18 IRQ Exception * 0x******18 IRQ Exception
* 0x******1C FIQ Exception * 0x******1C FIQ Exception
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
*/ */
@ -319,50 +319,50 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x1C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x1C]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+0x14, sizeof(blt_addr), return FlashWrite(flashLayout[0].sector_start+0x14, sizeof(blt_addr),
(blt_int8u*)&signature_checksum); (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x1C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x1C));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -377,7 +377,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -390,7 +390,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -399,7 +399,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -417,16 +417,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -437,8 +437,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -457,14 +457,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -483,7 +483,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -505,13 +505,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -535,7 +535,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -590,7 +590,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the prepare sector command for just this one sector */ /* send the prepare sector command for just this one sector */
iap_command[0] = IAP_CMD_PREPARE_SECTORS; iap_command[0] = IAP_CMD_PREPARE_SECTORS;
iap_command[1] = sector_num; iap_command[1] = sector_num;
iap_command[2] = sector_num; iap_command[2] = sector_num;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -602,7 +602,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the erase sector command */ /* send the erase sector command */
iap_command[0] = IAP_CMD_COPY_RAM_TO_FLASH; iap_command[0] = IAP_CMD_COPY_RAM_TO_FLASH;
iap_command[1] = (blt_int32u)block->base_addr; iap_command[1] = (blt_int32u)block->base_addr;
iap_command[2] = (blt_int32u)block->data; iap_command[2] = (blt_int32u)block->data;
iap_command[3] = FLASH_WRITE_BLOCK_SIZE; iap_command[3] = FLASH_WRITE_BLOCK_SIZE;
@ -616,7 +616,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* perform a comparison for verification purposes */ /* perform a comparison for verification purposes */
iap_command[0] = IAP_CMD_COMPARE; iap_command[0] = IAP_CMD_COMPARE;
iap_command[1] = (blt_int32u)block->base_addr; iap_command[1] = (blt_int32u)block->base_addr;
iap_command[2] = (blt_int32u)block->data; iap_command[2] = (blt_int32u)block->data;
iap_command[3] = FLASH_WRITE_BLOCK_SIZE; iap_command[3] = FLASH_WRITE_BLOCK_SIZE;
@ -630,7 +630,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashWriteBlock ***/ } /*** end of FlashWriteBlock ***/
@ -646,20 +646,20 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
blt_int32u iap_command[5]; blt_int32u iap_command[5];
blt_int32u iap_result[3]; blt_int32u iap_result[3];
pIapHandler iapHandler = (void *)IAP_ENTRY_ADDRESS; pIapHandler iapHandler = (void *)IAP_ENTRY_ADDRESS;
/* validate the sector numbers */ /* validate the sector numbers */
if (first_sector > last_sector) if (first_sector > last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* send the prepare sector command for just this one sector */ /* send the prepare sector command for just this one sector */
iap_command[0] = IAP_CMD_PREPARE_SECTORS; iap_command[0] = IAP_CMD_PREPARE_SECTORS;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -671,7 +671,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the erase sector command */ /* send the erase sector command */
iap_command[0] = IAP_CMD_ERASE_SECTORS; iap_command[0] = IAP_CMD_ERASE_SECTORS;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_command[3] = BOOT_CPU_SYSTEM_SPEED_KHZ; iap_command[3] = BOOT_CPU_SYSTEM_SPEED_KHZ;
@ -684,7 +684,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
return BLT_FALSE; return BLT_FALSE;
} }
/* perform a blank check for verification purposes */ /* perform a blank check for verification purposes */
iap_command[0] = IAP_CMD_BLANK_CHECK_SECTORS ; iap_command[0] = IAP_CMD_BLANK_CHECK_SECTORS ;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -709,16 +709,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;

6
Target/Source/ARM7_LPC2000/Crossworks/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

182
Target/Source/ARM7_LPC2000/GCC/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -67,13 +67,13 @@
/**************************************************************************************** /****************************************************************************************
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Function pointer type that is needed to call IAP functions of the /** \brief Function pointer type that is needed to call IAP functions of the
* NXP LPC2xxx. * NXP LPC2xxx.
*/ */
typedef void (*pIapHandler)(blt_int32u command[], blt_int32u result[]); typedef void (*pIapHandler)(blt_int32u command[], blt_int32u result[]);
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -82,17 +82,17 @@ typedef struct
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. Note that the .data member must be 32-bit aligned by the linker. * block. Note that the .data member must be 32-bit aligned by the linker.
* the .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * the .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
{ {
blt_addr base_addr; /**< Base address for the flash operation.*/ blt_addr base_addr; /**< Base address for the flash operation.*/
blt_int8u data[FLASH_WRITE_BLOCK_SIZE] __attribute__ ((aligned (4))); /**< Data array. */ blt_int8u data[FLASH_WRITE_BLOCK_SIZE] __attribute__((aligned(4))); /**< Data array. */
} tFlashBlockInfo; } tFlashBlockInfo;
@ -101,7 +101,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -112,11 +112,11 @@ static blt_int8u FlashGetSector(blt_addr address);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout supports the NXP LPC21xx and LPC22xx targets. * The current flash layout supports the NXP LPC21xx and LPC22xx targets.
* LPC23xx has a slightly different layout. To support the LPC23xx, simply * LPC23xx has a slightly different layout. To support the LPC23xx, simply
* update this flash layout. * update this flash layout.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -177,27 +177,27 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* LPC2000 is also the where the checksum is written to. Is it likely that the * LPC2000 is also the where the checksum is written to. Is it likely that the
* vector table is first flashed and then, at the end of the programming * vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed and * write the same values to those bytes that are not supposed to be changed and
* the locations where you do write to are still in the erased 0xFF state. * the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* the LPC2000. This is why we need to have an extra block, the bootblock, * the LPC2000. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
@ -208,7 +208,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -228,23 +228,23 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
{ {
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -260,24 +260,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -292,16 +292,16 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* The ARM7 core already has a spot reserved for a checksum that the bootloader can /* The ARM7 core already has a spot reserved for a checksum that the bootloader can
* store at the end of a programming session. * store at the end of a programming session.
* *
* Layout of the vector table (* = don't care) * Layout of the vector table (* = don't care)
* 0x******00 Reset Exception * 0x******00 Reset Exception
* 0x******04 Undefined Instruction Exception * 0x******04 Undefined Instruction Exception
@ -311,7 +311,7 @@ blt_bool FlashWriteChecksum(void)
* 0x******14 [reserved for signature checksum] * 0x******14 [reserved for signature checksum]
* 0x******18 IRQ Exception * 0x******18 IRQ Exception
* 0x******1C FIQ Exception * 0x******1C FIQ Exception
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
*/ */
@ -319,50 +319,50 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x1C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x1C]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+0x14, sizeof(blt_addr), return FlashWrite(flashLayout[0].sector_start+0x14, sizeof(blt_addr),
(blt_int8u*)&signature_checksum); (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x1C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x1C));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -377,7 +377,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -390,7 +390,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -399,7 +399,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -417,16 +417,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -437,8 +437,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -457,14 +457,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -483,7 +483,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -505,13 +505,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -535,7 +535,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -590,7 +590,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the prepare sector command for just this one sector */ /* send the prepare sector command for just this one sector */
iap_command[0] = IAP_CMD_PREPARE_SECTORS; iap_command[0] = IAP_CMD_PREPARE_SECTORS;
iap_command[1] = sector_num; iap_command[1] = sector_num;
iap_command[2] = sector_num; iap_command[2] = sector_num;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -602,7 +602,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the erase sector command */ /* send the erase sector command */
iap_command[0] = IAP_CMD_COPY_RAM_TO_FLASH; iap_command[0] = IAP_CMD_COPY_RAM_TO_FLASH;
iap_command[1] = (blt_int32u)block->base_addr; iap_command[1] = (blt_int32u)block->base_addr;
iap_command[2] = (blt_int32u)block->data; iap_command[2] = (blt_int32u)block->data;
iap_command[3] = FLASH_WRITE_BLOCK_SIZE; iap_command[3] = FLASH_WRITE_BLOCK_SIZE;
@ -616,7 +616,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
return BLT_FALSE; return BLT_FALSE;
} }
/* perform a comparison for verification purposes */ /* perform a comparison for verification purposes */
iap_command[0] = IAP_CMD_COMPARE; iap_command[0] = IAP_CMD_COMPARE;
iap_command[1] = (blt_int32u)block->base_addr; iap_command[1] = (blt_int32u)block->base_addr;
iap_command[2] = (blt_int32u)block->data; iap_command[2] = (blt_int32u)block->data;
iap_command[3] = FLASH_WRITE_BLOCK_SIZE; iap_command[3] = FLASH_WRITE_BLOCK_SIZE;
@ -630,7 +630,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashWriteBlock ***/ } /*** end of FlashWriteBlock ***/
@ -646,20 +646,20 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
blt_int32u iap_command[5]; blt_int32u iap_command[5];
blt_int32u iap_result[3]; blt_int32u iap_result[3];
pIapHandler iapHandler = (void *)IAP_ENTRY_ADDRESS; pIapHandler iapHandler = (void *)IAP_ENTRY_ADDRESS;
/* validate the sector numbers */ /* validate the sector numbers */
if (first_sector > last_sector) if (first_sector > last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* send the prepare sector command for just this one sector */ /* send the prepare sector command for just this one sector */
iap_command[0] = IAP_CMD_PREPARE_SECTORS; iap_command[0] = IAP_CMD_PREPARE_SECTORS;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -671,7 +671,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
return BLT_FALSE; return BLT_FALSE;
} }
/* send the erase sector command */ /* send the erase sector command */
iap_command[0] = IAP_CMD_ERASE_SECTORS; iap_command[0] = IAP_CMD_ERASE_SECTORS;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_command[3] = BOOT_CPU_SYSTEM_SPEED_KHZ; iap_command[3] = BOOT_CPU_SYSTEM_SPEED_KHZ;
@ -684,7 +684,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
return BLT_FALSE; return BLT_FALSE;
} }
/* perform a blank check for verification purposes */ /* perform a blank check for verification purposes */
iap_command[0] = IAP_CMD_BLANK_CHECK_SECTORS ; iap_command[0] = IAP_CMD_BLANK_CHECK_SECTORS ;
iap_command[1] = first_sector; iap_command[1] = first_sector;
iap_command[2] = last_sector; iap_command[2] = last_sector;
iap_result[0] = !IAP_CMD_SUCCESS; iap_result[0] = !IAP_CMD_SUCCESS;
@ -709,16 +709,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;

6
Target/Source/ARM7_LPC2000/GCC/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

12
Target/Source/ARM7_LPC2000/GCC/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -41,9 +41,9 @@
/**************************************************************************************** /****************************************************************************************
* Function prototypes * Function prototypes
****************************************************************************************/ ****************************************************************************************/
void __attribute__ ((interrupt("FIQ"))) FIQ_ISR(void); void __attribute__((interrupt("FIQ"))) FIQ_ISR(void);
void __attribute__ ((interrupt("IRQ"))) IRQ_ISR(void); void __attribute__((interrupt("IRQ"))) IRQ_ISR(void);
void __attribute__ ((interrupt("UNDEF"))) UNDEF_ISR(void); void __attribute__((interrupt("UNDEF"))) UNDEF_ISR(void);
/************************************************************************************//** /************************************************************************************//**

95
Target/Source/ARM7_LPC2000/can.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -43,7 +43,7 @@
* Macro definitions * Macro definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Transmit buffer 1 idle bit. */ /** \brief Transmit buffer 1 idle bit. */
#define CAN_TBS1 (0x00000004) #define CAN_TBS1 (0x00000004)
/** \brief Transmit buffer 1 complete bit. */ /** \brief Transmit buffer 1 complete bit. */
#define CAN_TCS1 (0x00000008) #define CAN_TCS1 (0x00000008)
/** \brief Receive buffer release bit. */ /** \brief Receive buffer release bit. */
@ -104,42 +104,43 @@ typedef struct t_can_bus_timing
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief CAN bittiming table for dynamically calculating the bittiming settings. /** \brief CAN bittiming table for dynamically calculating the bittiming settings.
* \details According to the CAN protocol 1 bit-time can be made up of between 8..25 * \details According to the CAN protocol 1 bit-time can be made up of between 8..25
* time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC * time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC
* always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) * * always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) *
* 100%. This array contains possible and valid time quanta configurations with * 100%. This array contains possible and valid time quanta configurations with
* a sample point between 68..78%. * a sample point between 68..78%.
*/ */
static const tCanBusTiming canTiming[] = static const tCanBusTiming canTiming[] =
{ /* TQ | TSEG1 | TSEG2 | SP */ {
/* ------------------------- */ /* TQ | TSEG1 | TSEG2 | SP */
{ 5, 2 }, /* 8 | 5 | 2 | 75% */ /* ------------------------- */
{ 6, 2 }, /* 9 | 6 | 2 | 78% */ { 5, 2 }, /* 8 | 5 | 2 | 75% */
{ 6, 3 }, /* 10 | 6 | 3 | 70% */ { 6, 2 }, /* 9 | 6 | 2 | 78% */
{ 7, 3 }, /* 11 | 7 | 3 | 73% */ { 6, 3 }, /* 10 | 6 | 3 | 70% */
{ 8, 3 }, /* 12 | 8 | 3 | 75% */ { 7, 3 }, /* 11 | 7 | 3 | 73% */
{ 9, 3 }, /* 13 | 9 | 3 | 77% */ { 8, 3 }, /* 12 | 8 | 3 | 75% */
{ 9, 4 }, /* 14 | 9 | 4 | 71% */ { 9, 3 }, /* 13 | 9 | 3 | 77% */
{ 10, 4 }, /* 15 | 10 | 4 | 73% */ { 9, 4 }, /* 14 | 9 | 4 | 71% */
{ 11, 4 }, /* 16 | 11 | 4 | 75% */ { 10, 4 }, /* 15 | 10 | 4 | 73% */
{ 12, 4 }, /* 17 | 12 | 4 | 76% */ { 11, 4 }, /* 16 | 11 | 4 | 75% */
{ 12, 5 }, /* 18 | 12 | 5 | 72% */ { 12, 4 }, /* 17 | 12 | 4 | 76% */
{ 13, 5 }, /* 19 | 13 | 5 | 74% */ { 12, 5 }, /* 18 | 12 | 5 | 72% */
{ 14, 5 }, /* 20 | 14 | 5 | 75% */ { 13, 5 }, /* 19 | 13 | 5 | 74% */
{ 15, 5 }, /* 21 | 15 | 5 | 76% */ { 14, 5 }, /* 20 | 14 | 5 | 75% */
{ 15, 6 }, /* 22 | 15 | 6 | 73% */ { 15, 5 }, /* 21 | 15 | 5 | 76% */
{ 16, 6 }, /* 23 | 16 | 6 | 74% */ { 15, 6 }, /* 22 | 15 | 6 | 73% */
{ 16, 7 }, /* 24 | 16 | 7 | 71% */ { 16, 6 }, /* 23 | 16 | 6 | 74% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */ { 16, 7 }, /* 24 | 16 | 7 | 71% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */
}; };
/************************************************************************************//** /************************************************************************************//**
** \brief Search algorithm to match the desired baudrate to a possible bus ** \brief Search algorithm to match the desired baudrate to a possible bus
** timing configuration. ** timing configuration.
** \param baud The desired baudrate in kbps. Valid values are 10..1000. ** \param baud The desired baudrate in kbps. Valid values are 10..1000.
** \param btr Pointer to where the value for register CANxBTR will be stored. ** \param btr Pointer to where the value for register CANxBTR will be stored.
** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE ** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE
** otherwise. ** otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
@ -157,7 +158,7 @@ static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int32u *btr)
prescaler = BOOT_CPU_SYSTEM_SPEED_KHZ/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)); prescaler = BOOT_CPU_SYSTEM_SPEED_KHZ/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1));
/* make sure the prescaler is valid */ /* make sure the prescaler is valid */
if ( (prescaler > 0) && (prescaler <= 1024) ) if ((prescaler > 0) && (prescaler <= 1024))
{ {
/* store the prescaler and bustiming register value */ /* store the prescaler and bustiming register value */
*btr = prescaler - 1; *btr = prescaler - 1;
@ -181,25 +182,25 @@ void CanInit(void)
{ {
blt_bool result; blt_bool result;
blt_int32u btr_reg_value=0; blt_int32u btr_reg_value=0;
/* the current implementation supports CAN1, which has channel index 0. throw an /* the current implementation supports CAN1, which has channel index 0. throw an
* assertion error in case a different CAN channel is configured. * assertion error in case a different CAN channel is configured.
*/ */
ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0);
/* configure acceptance filter for bypass mode so it receives all messages */ /* configure acceptance filter for bypass mode so it receives all messages */
CANAFMR = 0x00000002L; CANAFMR = 0x00000002L;
/* take CAN controller offline and go into reset mode */ /* take CAN controller offline and go into reset mode */
CAN1MOD = 1; CAN1MOD = 1;
/* disable all interrupts. driver only needs to work in polling mode */ /* disable all interrupts. driver only needs to work in polling mode */
CAN1IER = 0; CAN1IER = 0;
/* reset CAN controller status */ /* reset CAN controller status */
CAN1GSR = 0; CAN1GSR = 0;
/* configure the bittiming */ /* configure the bittiming */
result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &btr_reg_value); result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &btr_reg_value);
/* check that a valid baudrate configuration was found */ /* check that a valid baudrate configuration was found */
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* write the bittiming configuration to the register */ /* write the bittiming configuration to the register */
CAN1BTR = btr_reg_value; CAN1BTR = btr_reg_value;
/* enter normal operating mode and synchronize to the CAN bus */ /* enter normal operating mode and synchronize to the CAN bus */
CAN1MOD = 0; CAN1MOD = 0;
} /*** end of CanInit ***/ } /*** end of CanInit ***/
@ -217,7 +218,7 @@ void CanTransmitPacket(blt_int8u *data, blt_int8u len)
/* check that transmit buffer 1 is ready to accept a new message */ /* check that transmit buffer 1 is ready to accept a new message */
ASSERT_RT((CAN1SR & CAN_TBS1) != 0); ASSERT_RT((CAN1SR & CAN_TBS1) != 0);
/* write dlc and configure message as a standard message with 11-bit identifier */ /* write dlc and configure message as a standard message with 11-bit identifier */
CAN1TFI1 = (len << 16); CAN1TFI1 = (len << 16);
/* write the message identifier */ /* write the message identifier */
CAN1TID1 = BOOT_COM_CAN_TX_MSG_ID; CAN1TID1 = BOOT_COM_CAN_TX_MSG_ID;
/* write the first set of 4 data bytes */ /* write the first set of 4 data bytes */
@ -227,7 +228,7 @@ void CanTransmitPacket(blt_int8u *data, blt_int8u len)
/* write transmission request for transmit buffer 1 */ /* write transmission request for transmit buffer 1 */
CAN1CMR = CAN_TR | CAN_STB1; CAN1CMR = CAN_TR | CAN_STB1;
/* wait for transmit completion */ /* wait for transmit completion */
while ((CAN1SR & CAN_TCS1) == 0) while ((CAN1SR & CAN_TCS1) == 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
@ -254,14 +255,14 @@ blt_bool CanReceivePacket(blt_int8u *data)
return BLT_FALSE; return BLT_FALSE;
} }
/* store the message data */ /* store the message data */
data[0] = (blt_int8u)CAN1RDA; data[0] = (blt_int8u)CAN1RDA;
data[1] = (blt_int8u)(CAN1RDA >> 8); data[1] = (blt_int8u)(CAN1RDA >> 8);
data[2] = (blt_int8u)(CAN1RDA >> 16); data[2] = (blt_int8u)(CAN1RDA >> 16);
data[3] = (blt_int8u)(CAN1RDA >> 24); data[3] = (blt_int8u)(CAN1RDA >> 24);
data[4] = (blt_int8u)CAN1RDB; data[4] = (blt_int8u)CAN1RDB;
data[5] = (blt_int8u)(CAN1RDB >> 8); data[5] = (blt_int8u)(CAN1RDB >> 8);
data[6] = (blt_int8u)(CAN1RDB >> 16); data[6] = (blt_int8u)(CAN1RDB >> 16);
data[7] = (blt_int8u)(CAN1RDB >> 24); data[7] = (blt_int8u)(CAN1RDB >> 24);
/* release the receive buffer */ /* release the receive buffer */
CAN1CMR = CAN_RRB; CAN1CMR = CAN_RRB;
/* inform called that a new data was received */ /* inform called that a new data was received */

30
Target/Source/ARM7_LPC2000/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -71,43 +71,43 @@ extern void Reset_Handler(void); /* reset service routine in cst
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
void CpuStartUserProgram(void) void CpuStartUserProgram(void)
{ {
void (*pProgResetHandler)(void); void (*pProgResetHandler)(void);
/* check if a user program is present by verifying the checksum */ /* check if a user program is present by verifying the checksum */
if (NvmVerifyChecksum() == BLT_FALSE) if (NvmVerifyChecksum() == BLT_FALSE)
{ {
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* copy the user program's interrupt vector table to RAM */ /* copy the user program's interrupt vector table to RAM */
CpuMemCopy(CPU_RAM_VECTORS_START_ADDR, CPU_USER_PROG_VECTORS_START_ADDR, \ CpuMemCopy(CPU_RAM_VECTORS_START_ADDR, CPU_USER_PROG_VECTORS_START_ADDR, \
CPU_VECTORS_TABLE_SIZE); CPU_VECTORS_TABLE_SIZE);
/* select RAM vector table */ /* select RAM vector table */
MEMMAP = 0x02; MEMMAP = 0x02;
/* set the address where the bootloader needs to jump to */ /* set the address where the bootloader needs to jump to */
pProgResetHandler = (void*)CPU_RAM_VECTORS_START_ADDR; pProgResetHandler = (void *)CPU_RAM_VECTORS_START_ADDR;
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
@ -118,7 +118,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -131,7 +131,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;
@ -151,7 +151,7 @@ void CpuReset(void)
/* perform a software reset by calling the reset ISR routine. note that this requires /* perform a software reset by calling the reset ISR routine. note that this requires
* access to the processor status registers (PSRs), which works because the entire * access to the processor status registers (PSRs), which works because the entire
* bootloader runs in supervisor mode. * bootloader runs in supervisor mode.
*/ */
Reset_Handler(); Reset_Handler();
} /*** end of CpuReset ***/ } /*** end of CpuReset ***/

22
Target/Source/ARM7_LPC2000/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

8
Target/Source/ARM7_LPC2000/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -133,7 +133,7 @@ blt_int32u TimerGet(void)
* detection. * detection.
*/ */
TimerUpdate(); TimerUpdate();
/* read and return the amount of milliseconds that passed since initialization */ /* read and return the amount of milliseconds that passed since initialization */
return millisecond_counter; return millisecond_counter;
} /*** end of TimerGet ***/ } /*** end of TimerGet ***/

6
Target/Source/ARM7_LPC2000/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

42
Target/Source/ARM7_LPC2000/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -100,11 +100,11 @@ static blt_bool UartTransmitByte(blt_int8u data);
void UartInit(void) void UartInit(void)
{ {
blt_int32u baud_reg_value; /* baudrate register value */ blt_int32u baud_reg_value; /* baudrate register value */
/* the current implementation supports UART0. throw an assertion error in case /* the current implementation supports UART0. throw an assertion error in case
* a different UART channel is configured. * a different UART channel is configured.
*/ */
ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0);
/* disable UART related interrupt generation. this driver works in polling mode */ /* disable UART related interrupt generation. this driver works in polling mode */
U0IER = 0; U0IER = 0;
/* clear interrupt id register */ /* clear interrupt id register */
@ -113,19 +113,19 @@ void UartInit(void)
U0LSR = 0; U0LSR = 0;
/* set divisor latch DLAB = 1 so buadrate can be configured */ /* set divisor latch DLAB = 1 so buadrate can be configured */
U0LCR = UART_DLAB; U0LCR = UART_DLAB;
/* Baudrate calculation: /* Baudrate calculation:
* y = BOOT_CPU_SYSTEM_SPEED_KHZ * 1000 / 16 / BOOT_COM_UART_BAUDRATE and add * y = BOOT_CPU_SYSTEM_SPEED_KHZ * 1000 / 16 / BOOT_COM_UART_BAUDRATE and add
* smartness to automatically round the value up/down using the following trick: * smartness to automatically round the value up/down using the following trick:
* y = x/n can round with y = (x + (n + 1)/2 ) / n * y = x/n can round with y = (x + (n + 1)/2 ) / n
*/ */
/* check that baudrate register value is not 0 */ /* check that baudrate register value is not 0 */
ASSERT_CT((((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+((BOOT_COM_UART_BAUDRATE+1)/2))/ \ ASSERT_CT((((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+((BOOT_COM_UART_BAUDRATE+1)/2))/ \
BOOT_COM_UART_BAUDRATE) > 0); BOOT_COM_UART_BAUDRATE) > 0);
/* check that baudrate register value is not greater than max 16-bit unsigned value */ /* check that baudrate register value is not greater than max 16-bit unsigned value */
ASSERT_CT((((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+((BOOT_COM_UART_BAUDRATE+1)/2))/ \ ASSERT_CT((((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+((BOOT_COM_UART_BAUDRATE+1)/2))/ \
BOOT_COM_UART_BAUDRATE) <= 65535); BOOT_COM_UART_BAUDRATE) <= 65535);
baud_reg_value = (((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+ \ baud_reg_value = (((BOOT_CPU_SYSTEM_SPEED_KHZ*1000/16)+ \
((BOOT_COM_UART_BAUDRATE+1)/2))/BOOT_COM_UART_BAUDRATE); ((BOOT_COM_UART_BAUDRATE+1)/2))/BOOT_COM_UART_BAUDRATE);
/* write the calculated baudrate selector value to the registers */ /* write the calculated baudrate selector value to the registers */
U0DLL = (blt_int8u)baud_reg_value; U0DLL = (blt_int8u)baud_reg_value;
U0DLM = (blt_int8u)(baud_reg_value >> 8); U0DLM = (blt_int8u)(baud_reg_value >> 8);
@ -149,12 +149,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -162,7 +162,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -209,7 +209,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -242,7 +242,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
static blt_bool UartReceiveByte(blt_int8u *data) static blt_bool UartReceiveByte(blt_int8u *data)
{ {
/* check if a new byte was received by means of the RDR-bit */ /* check if a new byte was received by means of the RDR-bit */
if((U0LSR & UART_RDR) != 0) if ((U0LSR & UART_RDR) != 0)
{ {
/* store the received byte */ /* store the received byte */
data[0] = U0RBR; data[0] = U0RBR;
@ -271,8 +271,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit holding register */ /* write byte to transmit holding register */
U0THR = data; U0THR = data;
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while((U0LSR & UART_THRE) == 0) while ((U0LSR & UART_THRE) == 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

14
Target/Source/ARMCM3_EFM32/Crossworks/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -47,7 +47,7 @@ extern void reset_handler(void); /* implemented in cstart.s
* External data declarations * External data declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Stack end address (memory.x) */ /** \brief Stack end address (memory.x) */
extern blt_int32u __stack_end__; extern blt_int32u __stack_end__;
/************************************************************************************//** /************************************************************************************//**
@ -70,13 +70,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".vectors"))) __attribute__((section(".vectors")))
const tIsrFunc _vectors[] = const tIsrFunc _vectors[] =
{ {
{ .ptr = (blt_int32u)&__stack_end__ }, /* the initial stack pointer */ { .ptr = (blt_int32u) &__stack_end__ }, /* the initial stack pointer */
reset_handler, /* the reset handler */ reset_handler, /* the reset handler */
UnusedISR, /* NMI Handler */ UnusedISR, /* NMI Handler */
UnusedISR, /* Hard Fault Handler */ UnusedISR, /* Hard Fault Handler */

12
Target/Source/ARMCM3_EFM32/GCC/cstart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -57,7 +57,7 @@ extern blt_int32u _estack;
/************************************************************************************//** /************************************************************************************//**
** \brief Reset interrupt service routine. Configures the stack, initializes ** \brief Reset interrupt service routine. Configures the stack, initializes
** RAM and jumps to function main. ** RAM and jumps to function main.
** \return none. ** \return none.
** **
@ -70,11 +70,11 @@ void reset_handler(void)
__asm(" cpsid i"); __asm(" cpsid i");
/* copy the data segment initializers from flash to SRAM */ /* copy the data segment initializers from flash to SRAM */
pSrc = &_etext; pSrc = &_etext;
for(pDest = &_data; pDest < &_edata; ) for (pDest = &_data; pDest < &_edata;)
{ {
*pDest++ = *pSrc++; *pDest++ = *pSrc++;
} }
/* zero fill the bss segment. this is done with inline assembly since this will /* zero fill the bss segment. this is done with inline assembly since this will
* clear the value of pDest if it is not kept in a register. * clear the value of pDest if it is not kept in a register.
*/ */
__asm(" ldr r0, =_bss\n" __asm(" ldr r0, =_bss\n"

12
Target/Source/ARMCM3_EFM32/GCC/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -64,13 +64,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".isr_vector"))) __attribute__((section(".isr_vector")))
const tIsrFunc _vectab[] = const tIsrFunc _vectab[] =
{ {
{ .ptr = (blt_int32u)&_estack }, /* the initial stack pointer */ { .ptr = (blt_int32u) &_estack }, /* the initial stack pointer */
{ reset_handler }, /* the reset handler */ { reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

12
Target/Source/ARMCM3_EFM32/IAR/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -40,7 +40,7 @@
/**************************************************************************************** /****************************************************************************************
* External functions * External functions
****************************************************************************************/ ****************************************************************************************/
extern void reset_handler( void ); extern void reset_handler(void);
/**************************************************************************************** /****************************************************************************************
@ -51,7 +51,7 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
void *ptr; /**< for stack pointer entry */ void *ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/************************************************************************************//** /************************************************************************************//**
@ -75,7 +75,7 @@ void UnusedISR(void)
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__root const tIsrFunc __vector_table[] @ ".intvec" = __root const tIsrFunc __vector_table[] @ ".intvec" =
{ {
{ .ptr = __sfe( "CSTACK" ) }, /* the initial stack pointer */ { .ptr = __sfe("CSTACK") }, /* the initial stack pointer */
{ &reset_handler }, /* the reset handler */ { &reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

22
Target/Source/ARMCM3_EFM32/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ extern void reset_handler(void); /* implemented in cstart.s
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -83,18 +83,18 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* remap user program's vector table */ /* remap user program's vector table */
@ -103,7 +103,7 @@ void CpuStartUserProgram(void)
* the 2nd entry in the user program's vector table. this address points to the * the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -113,7 +113,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -126,7 +126,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

176
Target/Source/ARMCM3_EFM32/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -57,7 +57,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -65,10 +65,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -83,7 +83,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -97,13 +97,13 @@ static blt_int32u FlashCalcPageSize(void);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout does not reflect the minimum sector size of the * The current flash layout does not reflect the minimum sector size of the
* physical flash (1 - 2kb), because this would make the table quit long and * physical flash (1 - 2kb), because this would make the table quit long and
* a waste of ROM. The minimum sector size is only really needed when erasing * a waste of ROM. The minimum sector size is only really needed when erasing
* the flash. This can still be done in combination with macro * the flash. This can still be done in combination with macro
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -159,30 +159,30 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -190,7 +190,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -206,12 +206,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -219,10 +219,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -238,24 +238,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -270,27 +270,27 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* for the EFM32 target we defined the checksum as the Two's complement value of the /* for the EFM32 target we defined the checksum as the Two's complement value of the
* sum of the first 7 exception addresses. * sum of the first 7 exception addresses.
* *
* Layout of the vector table: * Layout of the vector table:
* 0x00000000 Initial stack pointer * 0x00000000 Initial stack pointer
* 0x00000004 Reset Handler * 0x00000004 Reset Handler
* 0x00000008 NMI Handler * 0x00000008 NMI Handler
* 0x0000000C Hard Fault Handler * 0x0000000C Hard Fault Handler
* 0x00000010 MPU Fault Handler * 0x00000010 MPU Fault Handler
* 0x00000014 Bus Fault Handler * 0x00000014 Bus Fault Handler
* 0x00000018 Usage Fault Handler * 0x00000018 Usage Fault Handler
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
* *
* the bootloader writes this 32-bit checksum value right after the vector table * the bootloader writes this 32-bit checksum value right after the vector table
* of the user program. note that this means one extra dummy entry must be added * of the user program. note that this means one extra dummy entry must be added
* at the end of the user program's vector table to reserve storage space for the * at the end of the user program's vector table to reserve storage space for the
@ -301,49 +301,49 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x14])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x14]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -358,7 +358,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -371,7 +371,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -382,7 +382,7 @@ blt_bool FlashDone(void)
} }
/* disable the flash controller for writing */ /* disable the flash controller for writing */
MSC_Deinit(); MSC_Deinit();
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -400,16 +400,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -420,8 +420,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -440,14 +440,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -466,7 +466,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -488,13 +488,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -518,7 +518,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -579,7 +579,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u));
prog_data = *(volatile blt_int32u*)(&block->data[word_cnt * sizeof(blt_int32u)]); prog_data = *(volatile blt_int32u *)(&block->data[word_cnt * sizeof(blt_int32u)]);
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program a word */ /* program a word */
@ -589,7 +589,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
break; break;
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (*(volatile blt_int32u*)prog_addr != prog_data) if (*(volatile blt_int32u *)prog_addr != prog_data)
{ {
result = BLT_FALSE; result = BLT_FALSE;
break; break;
@ -608,14 +608,14 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
****************************************************************************************/ ****************************************************************************************/
static blt_int32u FlashCalcPageSize(void) static blt_int32u FlashCalcPageSize(void)
{ {
blt_int8u family = *(blt_int8u*)0x0FE081FE; blt_int8u family = *(blt_int8u *)0x0FE081FE;
if ( ( family == 71 ) || ( family == 73 ) ) if ((family == 71) || (family == 73))
{ {
/* Gecko and Tiny, 'G' or 'I' */ /* Gecko and Tiny, 'G' or 'I' */
return 512; return 512;
} }
else if ( family == 72 ) else if (family == 72)
{ {
/* Giant, 'H' */ /* Giant, 'H' */
return 4096; return 4096;
@ -648,8 +648,8 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -659,7 +659,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
start_addr = FlashGetSectorBaseAddr(first_sector); start_addr = FlashGetSectorBaseAddr(first_sector);
end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1; end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1;
nr_of_blocks = (end_addr - start_addr + 1) / erase_block_size; nr_of_blocks = (end_addr - start_addr + 1) / erase_block_size;
/* erase all blocks one by one */ /* erase all blocks one by one */
for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++) for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++)
{ {
@ -686,16 +686,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;
@ -715,7 +715,7 @@ static blt_int8u FlashGetSector(blt_addr address)
static blt_addr FlashGetSectorBaseAddr(blt_int8u sector) static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -740,7 +740,7 @@ static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
static blt_addr FlashGetSectorSize(blt_int8u sector) static blt_addr FlashGetSectorSize(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {

6
Target/Source/ARMCM3_EFM32/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/ARMCM3_EFM32/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_EFM32/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_EFM32/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

22
Target/Source/ARMCM3_EFM32/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -110,12 +110,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -123,7 +123,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -170,7 +170,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -233,8 +233,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit holding register */ /* write byte to transmit holding register */
LEUART_Tx(LEUART1, data); LEUART_Tx(LEUART1, data);
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while((LEUART1->STATUS & LEUART_STATUS_TXBL) == 0) while ((LEUART1->STATUS & LEUART_STATUS_TXBL) == 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

14
Target/Source/ARMCM3_LM3S/Crossworks/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -47,7 +47,7 @@ extern void reset_handler(void); /* implemented in cstart.s
* External data declarations * External data declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Stack end address (memory.x) */ /** \brief Stack end address (memory.x) */
extern blt_int32u __stack_end__; extern blt_int32u __stack_end__;
/************************************************************************************//** /************************************************************************************//**
@ -70,13 +70,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".vectors"))) __attribute__((section(".vectors")))
const tIsrFunc _vectors[] = const tIsrFunc _vectors[] =
{ {
{ .ptr = (blt_int32u)&__stack_end__ }, /* the initial stack pointer */ { .ptr = (blt_int32u) &__stack_end__ }, /* the initial stack pointer */
reset_handler, /* the reset handler */ reset_handler, /* the reset handler */
UnusedISR, /* NMI Handler */ UnusedISR, /* NMI Handler */
UnusedISR, /* Hard Fault Handler */ UnusedISR, /* Hard Fault Handler */

12
Target/Source/ARMCM3_LM3S/GCC/cstart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -56,7 +56,7 @@ extern blt_int32u _estack;
/************************************************************************************//** /************************************************************************************//**
** \brief Reset interrupt service routine. Configures the stack, initializes ** \brief Reset interrupt service routine. Configures the stack, initializes
** RAM and jumps to function main. ** RAM and jumps to function main.
** \return none. ** \return none.
** **
@ -69,11 +69,11 @@ void reset_handler(void)
__asm(" cpsid i"); __asm(" cpsid i");
/* copy the data segment initializers from flash to SRAM */ /* copy the data segment initializers from flash to SRAM */
pSrc = &_etext; pSrc = &_etext;
for(pDest = &_data; pDest < &_edata; ) for (pDest = &_data; pDest < &_edata;)
{ {
*pDest++ = *pSrc++; *pDest++ = *pSrc++;
} }
/* zero fill the bss segment. this is done with inline assembly since this will /* zero fill the bss segment. this is done with inline assembly since this will
* clear the value of pDest if it is not kept in a register. * clear the value of pDest if it is not kept in a register.
*/ */
__asm(" ldr r0, =_bss\n" __asm(" ldr r0, =_bss\n"

12
Target/Source/ARMCM3_LM3S/GCC/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -64,13 +64,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".isr_vector"))) __attribute__((section(".isr_vector")))
const tIsrFunc _vectab[] = const tIsrFunc _vectab[] =
{ {
{ .ptr = (blt_int32u)&_estack }, /* the initial stack pointer */ { .ptr = (blt_int32u) &_estack }, /* the initial stack pointer */
{ reset_handler }, /* the reset handler */ { reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

12
Target/Source/ARMCM3_LM3S/IAR/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -40,7 +40,7 @@
/**************************************************************************************** /****************************************************************************************
* External functions * External functions
****************************************************************************************/ ****************************************************************************************/
extern void reset_handler( void ); extern void reset_handler(void);
/**************************************************************************************** /****************************************************************************************
@ -51,7 +51,7 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
void *ptr; /**< for stack pointer entry */ void *ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/************************************************************************************//** /************************************************************************************//**
@ -75,7 +75,7 @@ void UnusedISR(void)
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__root const tIsrFunc __vector_table[] @ ".intvec" = __root const tIsrFunc __vector_table[] @ ".intvec" =
{ {
{ .ptr = __sfe( "CSTACK" ) }, /* the initial stack pointer */ { .ptr = __sfe("CSTACK") }, /* the initial stack pointer */
{ &reset_handler }, /* the reset handler */ { &reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

20
Target/Source/ARMCM3_LM3S/can.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -66,8 +66,8 @@ static const blt_int16u canBitNum2Mask[] =
/************************************************************************************//** /************************************************************************************//**
** \brief Attempts to match the bittiming parameters to the requested baudrate ** \brief Attempts to match the bittiming parameters to the requested baudrate
** for a sample point between 65 and 75%, through a linear search ** for a sample point between 65 and 75%, through a linear search
** algorithm. It is based on the equation: ** algorithm. It is based on the equation:
** baudrate = CAN Clock Freq/((1+PropSeg+Phase1Seg+Phase2Seg)*Prescaler) ** baudrate = CAN Clock Freq/((1+PropSeg+Phase1Seg+Phase2Seg)*Prescaler)
** \return BLT_TRUE if a valid bittiming configuration was found and set. BLT_FALSE ** \return BLT_TRUE if a valid bittiming configuration was found and set. BLT_FALSE
@ -91,7 +91,7 @@ static blt_int8u CanSetBittiming(void)
{ {
samplepoint = ((1+bitClkParms.uSyncPropPhase1Seg) * 100) / (1+bitClkParms.uSyncPropPhase1Seg+bitClkParms.uPhase2Seg); samplepoint = ((1+bitClkParms.uSyncPropPhase1Seg) * 100) / (1+bitClkParms.uSyncPropPhase1Seg+bitClkParms.uPhase2Seg);
/* check that sample points is within the preferred range */ /* check that sample points is within the preferred range */
if ( (samplepoint >= 65) && (samplepoint <= 75) ) if ((samplepoint >= 65) && (samplepoint <= 75))
{ {
/* does a prescaler exist to get the exact baudrate with these bittiming /* does a prescaler exist to get the exact baudrate with these bittiming
* settings? * settings?
@ -104,7 +104,7 @@ static blt_int8u CanSetBittiming(void)
*/ */
if (bitClkParms.uPhase2Seg < 4) if (bitClkParms.uPhase2Seg < 4)
{ {
bitClkParms.uSJW = bitClkParms.uPhase2Seg; bitClkParms.uSJW = bitClkParms.uPhase2Seg;
} }
/* calculate the actual prescaler value */ /* calculate the actual prescaler value */
bitClkParms.uQuantumPrescaler = ((BOOT_CPU_XTAL_SPEED_KHZ*1000)/BOOT_COM_CAN_BAUDRATE)/(1+bitClkParms.uSyncPropPhase1Seg+bitClkParms.uPhase2Seg); bitClkParms.uQuantumPrescaler = ((BOOT_CPU_XTAL_SPEED_KHZ*1000)/BOOT_COM_CAN_BAUDRATE)/(1+bitClkParms.uSyncPropPhase1Seg+bitClkParms.uPhase2Seg);
@ -131,10 +131,10 @@ void CanInit(void)
blt_bool result; blt_bool result;
tCANMsgObject rxMsgObject; tCANMsgObject rxMsgObject;
/* the current implementation supports CAN0. throw an assertion error in case a /* the current implementation supports CAN0. throw an assertion error in case a
* different CAN channel is configured. * different CAN channel is configured.
*/ */
ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0);
/* enable the CAN controller */ /* enable the CAN controller */
SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0); SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);
/* reset the state of the CAN controller, including the message objects */ /* reset the state of the CAN controller, including the message objects */

24
Target/Source/ARMCM3_LM3S/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -45,7 +45,7 @@
/** \brief Pointer to the user program's vector table. */ /** \brief Pointer to the user program's vector table. */
#define CPU_USER_PROGRAM_VECTABLE_OFFSET ((blt_int32u)NvmGetUserProgBaseAddress()) #define CPU_USER_PROGRAM_VECTABLE_OFFSET ((blt_int32u)NvmGetUserProgBaseAddress())
/**************************************************************************************** /****************************************************************************************
* Register definitions * Register definitions
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ extern void reset_handler(void); /* implemented in cstart.s
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -83,18 +83,18 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* remap user program's vector table */ /* remap user program's vector table */
@ -103,7 +103,7 @@ void CpuStartUserProgram(void)
* the 2nd entry in the user program's vector table. this address points to the * the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -113,7 +113,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -126,7 +126,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

168
Target/Source/ARMCM3_LM3S/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -61,7 +61,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -69,10 +69,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -87,7 +87,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -100,13 +100,13 @@ static blt_addr FlashGetSectorSize(blt_int8u sector);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout does not reflect the minimum sector size of the * The current flash layout does not reflect the minimum sector size of the
* physical flash (1 - 2kb), because this would make the table quit long and * physical flash (1 - 2kb), because this would make the table quit long and
* a waste of ROM. The minimum sector size is only really needed when erasing * a waste of ROM. The minimum sector size is only really needed when erasing
* the flash. This can still be done in combination with macro * the flash. This can still be done in combination with macro
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -162,30 +162,30 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -193,7 +193,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -207,12 +207,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -220,10 +220,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -239,24 +239,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -271,27 +271,27 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* for the LM3S target we defined the checksum as the Two's complement value of the /* for the LM3S target we defined the checksum as the Two's complement value of the
* sum of the first 7 exception addresses. * sum of the first 7 exception addresses.
* *
* Layout of the vector table: * Layout of the vector table:
* 0x00000000 Initial stack pointer * 0x00000000 Initial stack pointer
* 0x00000004 Reset Handler * 0x00000004 Reset Handler
* 0x00000008 NMI Handler * 0x00000008 NMI Handler
* 0x0000000C Hard Fault Handler * 0x0000000C Hard Fault Handler
* 0x00000010 MPU Fault Handler * 0x00000010 MPU Fault Handler
* 0x00000014 Bus Fault Handler * 0x00000014 Bus Fault Handler
* 0x00000018 Usage Fault Handler * 0x00000018 Usage Fault Handler
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
* *
* the bootloader writes this 32-bit checksum value right after the vector table * the bootloader writes this 32-bit checksum value right after the vector table
* of the user program. note that this means one extra dummy entry must be added * of the user program. note that this means one extra dummy entry must be added
* at the end of the user program's vector table to reserve storage space for the * at the end of the user program's vector table to reserve storage space for the
@ -302,49 +302,49 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x14])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x14]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -359,7 +359,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -372,7 +372,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -381,7 +381,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -399,16 +399,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -419,8 +419,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -439,14 +439,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -465,7 +465,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -487,13 +487,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -517,7 +517,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -576,7 +576,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u));
prog_data = *(volatile blt_int32u*)(&block->data[word_cnt * sizeof(blt_int32u)]); prog_data = *(volatile blt_int32u *)(&block->data[word_cnt * sizeof(blt_int32u)]);
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program the word to flash */ /* program the word to flash */
@ -586,7 +586,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
break; break;
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (*(volatile blt_int32u*)prog_addr != prog_data) if (*(volatile blt_int32u *)prog_addr != prog_data)
{ {
result = BLT_FALSE; result = BLT_FALSE;
break; break;
@ -616,8 +616,8 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -625,7 +625,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
start_addr = FlashGetSectorBaseAddr(first_sector); start_addr = FlashGetSectorBaseAddr(first_sector);
end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1; end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1;
nr_of_blocks = (end_addr - start_addr + 1) / FLASH_ERASE_BLOCK_SIZE; nr_of_blocks = (end_addr - start_addr + 1) / FLASH_ERASE_BLOCK_SIZE;
/* erase all blocks one by one */ /* erase all blocks one by one */
for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++) for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++)
{ {
@ -651,16 +651,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;
@ -680,7 +680,7 @@ static blt_int8u FlashGetSector(blt_addr address)
static blt_addr FlashGetSectorBaseAddr(blt_int8u sector) static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -705,7 +705,7 @@ static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
static blt_addr FlashGetSectorSize(blt_int8u sector) static blt_addr FlashGetSectorSize(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {

6
Target/Source/ARMCM3_LM3S/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/ARMCM3_LM3S/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_LM3S/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_LM3S/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

34
Target/Source/ARMCM3_LM3S/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -67,16 +67,16 @@ static blt_bool UartTransmitByte(blt_int8u data);
****************************************************************************************/ ****************************************************************************************/
void UartInit(void) void UartInit(void)
{ {
/* the current implementation supports UART0. throw an assertion error in case a /* the current implementation supports UART0. throw an assertion error in case a
* different UART channel is configured. * different UART channel is configured.
*/ */
ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0);
/* enable the UART0 peripheral */ /* enable the UART0 peripheral */
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
/* configure the UART0 baudrate and communication parameters */ /* configure the UART0 baudrate and communication parameters */
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), BOOT_COM_UART_BAUDRATE, UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), BOOT_COM_UART_BAUDRATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE)); UART_CONFIG_PAR_NONE));
} /*** end of UartInit ***/ } /*** end of UartInit ***/
@ -93,12 +93,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -106,7 +106,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -153,7 +153,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -190,7 +190,7 @@ static blt_bool UartReceiveByte(blt_int8u *data)
/* try to read a newly received byte */ /* try to read a newly received byte */
result = UARTCharGetNonBlocking(UART0_BASE); result = UARTCharGetNonBlocking(UART0_BASE);
/* check if a new byte was received */ /* check if a new byte was received */
if(result != -1) if (result != -1)
{ {
/* store the received byte */ /* store the received byte */
data[0] = (blt_int8u)result; data[0] = (blt_int8u)result;
@ -217,8 +217,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
return BLT_FALSE; return BLT_FALSE;
} }
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while(UARTSpaceAvail(UART0_BASE) == false) while (UARTSpaceAvail(UART0_BASE) == false)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

14
Target/Source/ARMCM3_STM32/Crossworks/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -47,7 +47,7 @@ extern void reset_handler(void); /* implemented in cstart.s
* External data declarations * External data declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Stack end address (memory.x) */ /** \brief Stack end address (memory.x) */
extern blt_int32u __stack_end__; extern blt_int32u __stack_end__;
/************************************************************************************//** /************************************************************************************//**
@ -70,13 +70,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".vectors"))) __attribute__((section(".vectors")))
const tIsrFunc _vectors[] = const tIsrFunc _vectors[] =
{ {
{ .ptr = (blt_int32u)&__stack_end__ }, /* the initial stack pointer */ { .ptr = (blt_int32u) &__stack_end__ }, /* the initial stack pointer */
reset_handler, /* the reset handler */ reset_handler, /* the reset handler */
UnusedISR, /* NMI Handler */ UnusedISR, /* NMI Handler */
UnusedISR, /* Hard Fault Handler */ UnusedISR, /* Hard Fault Handler */

12
Target/Source/ARMCM3_STM32/GCC/cstart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -56,7 +56,7 @@ extern blt_int32u _estack;
/************************************************************************************//** /************************************************************************************//**
** \brief Reset interrupt service routine. Configures the stack, initializes ** \brief Reset interrupt service routine. Configures the stack, initializes
** RAM and jumps to function main. ** RAM and jumps to function main.
** \return none. ** \return none.
** **
@ -69,11 +69,11 @@ void reset_handler(void)
__asm(" cpsid i"); __asm(" cpsid i");
/* copy the data segment initializers from flash to SRAM */ /* copy the data segment initializers from flash to SRAM */
pSrc = &_etext; pSrc = &_etext;
for(pDest = &_data; pDest < &_edata; ) for (pDest = &_data; pDest < &_edata;)
{ {
*pDest++ = *pSrc++; *pDest++ = *pSrc++;
} }
/* zero fill the bss segment. this is done with inline assembly since this will /* zero fill the bss segment. this is done with inline assembly since this will
* clear the value of pDest if it is not kept in a register. * clear the value of pDest if it is not kept in a register.
*/ */
__asm(" ldr r0, =_bss\n" __asm(" ldr r0, =_bss\n"

12
Target/Source/ARMCM3_STM32/GCC/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -64,13 +64,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".isr_vector"))) __attribute__((section(".isr_vector")))
const tIsrFunc _vectab[] = const tIsrFunc _vectab[] =
{ {
{ .ptr = (blt_int32u)&_estack }, /* the initial stack pointer */ { .ptr = (blt_int32u) &_estack }, /* the initial stack pointer */
{ reset_handler }, /* the reset handler */ { reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

12
Target/Source/ARMCM3_STM32/IAR/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -40,7 +40,7 @@
/**************************************************************************************** /****************************************************************************************
* External functions * External functions
****************************************************************************************/ ****************************************************************************************/
extern void reset_handler( void ); extern void reset_handler(void);
/**************************************************************************************** /****************************************************************************************
@ -51,7 +51,7 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
void *ptr; /**< for stack pointer entry */ void *ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/************************************************************************************//** /************************************************************************************//**
@ -75,7 +75,7 @@ void UnusedISR(void)
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__root const tIsrFunc __vector_table[] @ ".intvec" = __root const tIsrFunc __vector_table[] @ ".intvec" =
{ {
{ .ptr = __sfe( "CSTACK" ) }, /* the initial stack pointer */ { .ptr = __sfe("CSTACK") }, /* the initial stack pointer */
{ &reset_handler }, /* the reset handler */ { &reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

75
Target/Source/ARMCM3_STM32/can.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -58,7 +58,7 @@ typedef struct
volatile blt_int32u RDTR; volatile blt_int32u RDTR;
volatile blt_int32u RDLR; volatile blt_int32u RDLR;
volatile blt_int32u RDHR; volatile blt_int32u RDHR;
} tCanRxFIFOMailBox; } tCanRxFIFOMailBox;
/** \brief CAN filter register layout. */ /** \brief CAN filter register layout. */
typedef struct typedef struct
@ -92,7 +92,7 @@ typedef struct
volatile blt_int32u FA1R; volatile blt_int32u FA1R;
blt_int32u RESERVED5[8]; blt_int32u RESERVED5[8];
tCanFilter sFilterRegister[14]; tCanFilter sFilterRegister[14];
} tCanRegs; } tCanRegs;
/**************************************************************************************** /****************************************************************************************
@ -140,48 +140,49 @@ typedef struct t_can_bus_timing
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief CAN bittiming table for dynamically calculating the bittiming settings. /** \brief CAN bittiming table for dynamically calculating the bittiming settings.
* \details According to the CAN protocol 1 bit-time can be made up of between 8..25 * \details According to the CAN protocol 1 bit-time can be made up of between 8..25
* time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC * time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC
* always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) * * always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) *
* 100%. This array contains possible and valid time quanta configurations with * 100%. This array contains possible and valid time quanta configurations with
* a sample point between 68..78%. * a sample point between 68..78%.
*/ */
static const tCanBusTiming canTiming[] = static const tCanBusTiming canTiming[] =
{ /* TQ | TSEG1 | TSEG2 | SP */ {
/* ------------------------- */ /* TQ | TSEG1 | TSEG2 | SP */
{ 5, 2 }, /* 8 | 5 | 2 | 75% */ /* ------------------------- */
{ 6, 2 }, /* 9 | 6 | 2 | 78% */ { 5, 2 }, /* 8 | 5 | 2 | 75% */
{ 6, 3 }, /* 10 | 6 | 3 | 70% */ { 6, 2 }, /* 9 | 6 | 2 | 78% */
{ 7, 3 }, /* 11 | 7 | 3 | 73% */ { 6, 3 }, /* 10 | 6 | 3 | 70% */
{ 8, 3 }, /* 12 | 8 | 3 | 75% */ { 7, 3 }, /* 11 | 7 | 3 | 73% */
{ 9, 3 }, /* 13 | 9 | 3 | 77% */ { 8, 3 }, /* 12 | 8 | 3 | 75% */
{ 9, 4 }, /* 14 | 9 | 4 | 71% */ { 9, 3 }, /* 13 | 9 | 3 | 77% */
{ 10, 4 }, /* 15 | 10 | 4 | 73% */ { 9, 4 }, /* 14 | 9 | 4 | 71% */
{ 11, 4 }, /* 16 | 11 | 4 | 75% */ { 10, 4 }, /* 15 | 10 | 4 | 73% */
{ 12, 4 }, /* 17 | 12 | 4 | 76% */ { 11, 4 }, /* 16 | 11 | 4 | 75% */
{ 12, 5 }, /* 18 | 12 | 5 | 72% */ { 12, 4 }, /* 17 | 12 | 4 | 76% */
{ 13, 5 }, /* 19 | 13 | 5 | 74% */ { 12, 5 }, /* 18 | 12 | 5 | 72% */
{ 14, 5 }, /* 20 | 14 | 5 | 75% */ { 13, 5 }, /* 19 | 13 | 5 | 74% */
{ 15, 5 }, /* 21 | 15 | 5 | 76% */ { 14, 5 }, /* 20 | 14 | 5 | 75% */
{ 15, 6 }, /* 22 | 15 | 6 | 73% */ { 15, 5 }, /* 21 | 15 | 5 | 76% */
{ 16, 6 }, /* 23 | 16 | 6 | 74% */ { 15, 6 }, /* 22 | 15 | 6 | 73% */
{ 16, 7 }, /* 24 | 16 | 7 | 71% */ { 16, 6 }, /* 23 | 16 | 6 | 74% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */ { 16, 7 }, /* 24 | 16 | 7 | 71% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */
}; };
/************************************************************************************//** /************************************************************************************//**
** \brief Search algorithm to match the desired baudrate to a possible bus ** \brief Search algorithm to match the desired baudrate to a possible bus
** timing configuration. ** timing configuration.
** \param baud The desired baudrate in kbps. Valid values are 10..1000. ** \param baud The desired baudrate in kbps. Valid values are 10..1000.
** \param prescaler Pointer to where the value for the prescaler will be stored. ** \param prescaler Pointer to where the value for the prescaler will be stored.
** \param tseg1 Pointer to where the value for TSEG2 will be stored. ** \param tseg1 Pointer to where the value for TSEG2 will be stored.
** \param tseg2 Pointer to where the value for TSEG2 will be stored. ** \param tseg2 Pointer to where the value for TSEG2 will be stored.
** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE ** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE
** otherwise. ** otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler, static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler,
blt_int8u *tseg1, blt_int8u *tseg2) blt_int8u *tseg1, blt_int8u *tseg2)
{ {
blt_int8u cnt; blt_int8u cnt;
@ -195,7 +196,7 @@ static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler,
*prescaler = (BOOT_CPU_SYSTEM_SPEED_KHZ/2)/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)); *prescaler = (BOOT_CPU_SYSTEM_SPEED_KHZ/2)/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1));
/* make sure the prescaler is valid */ /* make sure the prescaler is valid */
if ( (*prescaler > 0) && (*prescaler <= 1024) ) if ((*prescaler > 0) && (*prescaler <= 1024))
{ {
/* store the bustiming configuration */ /* store the bustiming configuration */
*tseg1 = canTiming[cnt].tseg1; *tseg1 = canTiming[cnt].tseg1;
@ -221,10 +222,10 @@ void CanInit(void)
blt_int8u tseg1, tseg2; blt_int8u tseg1, tseg2;
blt_bool result; blt_bool result;
/* the current implementation supports CAN1. throw an assertion error in case a /* the current implementation supports CAN1. throw an assertion error in case a
* different CAN channel is configured. * different CAN channel is configured.
*/ */
ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0);
/* obtain bittiming configuration information */ /* obtain bittiming configuration information */
result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &prescaler, &tseg1, &tseg2); result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &prescaler, &tseg1, &tseg2);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
@ -267,8 +268,8 @@ void CanInit(void)
/* 32-bit scale for the filter */ /* 32-bit scale for the filter */
CANx->FS1R |= CAN_BIT_FILTER0; CANx->FS1R |= CAN_BIT_FILTER0;
/* open up the acceptance filter to receive all messages */ /* open up the acceptance filter to receive all messages */
CANx->sFilterRegister[0].FR1 = 0; CANx->sFilterRegister[0].FR1 = 0;
CANx->sFilterRegister[0].FR2 = 0; CANx->sFilterRegister[0].FR2 = 0;
/* select id/mask mode for the filter */ /* select id/mask mode for the filter */
CANx->FM1R &= ~CAN_BIT_FILTER0; CANx->FM1R &= ~CAN_BIT_FILTER0;
/* FIFO 0 assignation for the filter */ /* FIFO 0 assignation for the filter */

22
Target/Source/ARMCM3_STM32/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ extern void reset_handler(void); /* implemented in cstart.s
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -83,18 +83,18 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* remap user program's vector table */ /* remap user program's vector table */
@ -103,7 +103,7 @@ void CpuStartUserProgram(void)
* the 2nd entry in the user program's vector table. this address points to the * the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -113,7 +113,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -126,7 +126,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

176
Target/Source/ARMCM3_STM32/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -75,7 +75,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -83,10 +83,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -98,7 +98,7 @@ typedef struct
/** \brief Flash controller register layout type. */ /** \brief Flash controller register layout type. */
typedef struct typedef struct
{ {
volatile blt_int32u ACR; /**< flash access control register */ volatile blt_int32u ACR; /**< flash access control register */
volatile blt_int32u KEYR; /**< FPEC key register */ volatile blt_int32u KEYR; /**< FPEC key register */
volatile blt_int32u OPTKEYR; /**< flash OPTKEY register */ volatile blt_int32u OPTKEYR; /**< flash OPTKEY register */
volatile blt_int32u SR; /**< flash status register */ volatile blt_int32u SR; /**< flash status register */
@ -107,7 +107,7 @@ typedef struct
volatile blt_int32u RESERVED; volatile blt_int32u RESERVED;
volatile blt_int32u OBR; /**< option byte register */ volatile blt_int32u OBR; /**< option byte register */
volatile blt_int32u WRPR; /**< write protection register */ volatile blt_int32u WRPR; /**< write protection register */
} tFlashRegs; } tFlashRegs;
/**************************************************************************************** /****************************************************************************************
@ -115,7 +115,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -130,13 +130,13 @@ static blt_addr FlashGetSectorSize(blt_int8u sector);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout does not reflect the minimum sector size of the * The current flash layout does not reflect the minimum sector size of the
* physical flash (1 - 2kb), because this would make the table quit long and * physical flash (1 - 2kb), because this would make the table quit long and
* a waste of ROM. The minimum sector size is only really needed when erasing * a waste of ROM. The minimum sector size is only really needed when erasing
* the flash. This can still be done in combination with macro * the flash. This can still be done in combination with macro
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -192,30 +192,30 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -223,7 +223,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -237,12 +237,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -250,10 +250,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -269,24 +269,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -301,27 +301,27 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* for the STM32 target we defined the checksum as the Two's complement value of the /* for the STM32 target we defined the checksum as the Two's complement value of the
* sum of the first 7 exception addresses. * sum of the first 7 exception addresses.
* *
* Layout of the vector table: * Layout of the vector table:
* 0x08000000 Initial stack pointer * 0x08000000 Initial stack pointer
* 0x08000004 Reset Handler * 0x08000004 Reset Handler
* 0x08000008 NMI Handler * 0x08000008 NMI Handler
* 0x0800000C Hard Fault Handler * 0x0800000C Hard Fault Handler
* 0x08000010 MPU Fault Handler * 0x08000010 MPU Fault Handler
* 0x08000014 Bus Fault Handler * 0x08000014 Bus Fault Handler
* 0x08000018 Usage Fault Handler * 0x08000018 Usage Fault Handler
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
* *
* the bootloader writes this 32-bit checksum value right after the vector table * the bootloader writes this 32-bit checksum value right after the vector table
* of the user program. note that this means one extra dummy entry must be added * of the user program. note that this means one extra dummy entry must be added
* at the end of the user program's vector table to reserve storage space for the * at the end of the user program's vector table to reserve storage space for the
@ -332,49 +332,49 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x14])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x14]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -389,7 +389,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -402,7 +402,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -411,7 +411,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -429,16 +429,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -449,8 +449,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -469,14 +469,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -495,7 +495,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -517,13 +517,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -547,7 +547,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -618,9 +618,9 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u));
prog_data = *(volatile blt_int32u*)(&block->data[word_cnt * sizeof(blt_int32u)]); prog_data = *(volatile blt_int32u *)(&block->data[word_cnt * sizeof(blt_int32u)]);
/* program the first half word */ /* program the first half word */
*(volatile blt_int16u*)prog_addr = (blt_int16u)prog_data; *(volatile blt_int16u *)prog_addr = (blt_int16u)prog_data;
/* wait for the program operation to complete */ /* wait for the program operation to complete */
while ((FLASH->SR & FLASH_BSY_BIT) == FLASH_BSY_BIT) while ((FLASH->SR & FLASH_BSY_BIT) == FLASH_BSY_BIT)
{ {
@ -628,7 +628,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
CopService(); CopService();
} }
/* program the second half word */ /* program the second half word */
*(volatile blt_int16u*)(prog_addr+2) = (blt_int16u)(prog_data >> 16); *(volatile blt_int16u *)(prog_addr+2) = (blt_int16u)(prog_data >> 16);
/* wait for the program operation to complete */ /* wait for the program operation to complete */
while ((FLASH->SR & FLASH_BSY_BIT) == FLASH_BSY_BIT) while ((FLASH->SR & FLASH_BSY_BIT) == FLASH_BSY_BIT)
{ {
@ -636,7 +636,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
CopService(); CopService();
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (*(volatile blt_int32u*)prog_addr != prog_data) if (*(volatile blt_int32u *)prog_addr != prog_data)
{ {
result = BLT_FALSE; result = BLT_FALSE;
break; break;
@ -670,8 +670,8 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -692,7 +692,7 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
start_addr = FlashGetSectorBaseAddr(first_sector); start_addr = FlashGetSectorBaseAddr(first_sector);
end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1; end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1;
nr_of_blocks = (end_addr - start_addr + 1) / FLASH_ERASE_BLOCK_SIZE; nr_of_blocks = (end_addr - start_addr + 1) / FLASH_ERASE_BLOCK_SIZE;
/* erase all blocks one by one */ /* erase all blocks one by one */
for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++) for (block_cnt=0; block_cnt<nr_of_blocks; block_cnt++)
{ {
@ -754,16 +754,16 @@ static void FlashLock(void)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;
@ -783,7 +783,7 @@ static blt_int8u FlashGetSector(blt_addr address)
static blt_addr FlashGetSectorBaseAddr(blt_int8u sector) static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -808,7 +808,7 @@ static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
static blt_addr FlashGetSectorSize(blt_int8u sector) static blt_addr FlashGetSectorSize(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {

6
Target/Source/ARMCM3_STM32/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/ARMCM3_STM32/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_STM32/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM3_STM32/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

28
Target/Source/ARMCM3_STM32/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -109,10 +109,10 @@ static blt_bool UartTransmitByte(blt_int8u data);
****************************************************************************************/ ****************************************************************************************/
void UartInit(void) void UartInit(void)
{ {
/* the current implementation supports USART1 and USART2. throw an assertion error in /* the current implementation supports USART1 and USART2. throw an assertion error in
* case a different UART channel is configured. * case a different UART channel is configured.
*/ */
ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) || (BOOT_COM_UART_CHANNEL_INDEX == 1)); ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) || (BOOT_COM_UART_CHANNEL_INDEX == 1));
/* first reset the UART configuration. note that this already configures the UART /* first reset the UART configuration. note that this already configures the UART
* for 1 stopbit, 8 databits and no parity. * for 1 stopbit, 8 databits and no parity.
*/ */
@ -145,10 +145,10 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -156,7 +156,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -203,7 +203,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -236,7 +236,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
static blt_bool UartReceiveByte(blt_int8u *data) static blt_bool UartReceiveByte(blt_int8u *data)
{ {
/* check if a new byte was received by means of the RDR-bit */ /* check if a new byte was received by means of the RDR-bit */
if((UARTx->SR & UART_BIT_RXNE) != 0) if ((UARTx->SR & UART_BIT_RXNE) != 0)
{ {
/* store the received byte */ /* store the received byte */
data[0] = UARTx->DR; data[0] = UARTx->DR;
@ -265,8 +265,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit holding register */ /* write byte to transmit holding register */
UARTx->DR = data; UARTx->DR = data;
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while((UARTx->SR & UART_BIT_TXE) == 0) while ((UARTx->SR & UART_BIT_TXE) == 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

66
Target/Source/ARMCM3_STM32/usb.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -65,7 +65,7 @@ typedef struct t_fifo_ctrl
blt_int8u *writeptr; /**< pointer to next free location */ blt_int8u *writeptr; /**< pointer to next free location */
blt_int8u length; /**< number of buffer elements */ blt_int8u length; /**< number of buffer elements */
blt_int8u entries; /**< # of full buffer elements */ blt_int8u entries; /**< # of full buffer elements */
blt_int8u handle; /**< handle of the buffer */ blt_int8u handle; /**< handle of the buffer */
struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */ struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */
} tFifoCtrl; } tFifoCtrl;
@ -123,15 +123,15 @@ void UsbInit(void)
fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE); fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE);
fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE); fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE);
/* validate fifo handles */ /* validate fifo handles */
ASSERT_RT( (fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \ ASSERT_RT((fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \
(fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE) ); (fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE));
/* initialize the low level USB driver */ /* initialize the low level USB driver */
USB_Init(); USB_Init();
} /*** end of UsbInit ***/ } /*** end of UsbInit ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Releases the USB communication interface. ** \brief Releases the USB communication interface.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -155,12 +155,12 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UsbTransmitByte(len); result = UsbTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -168,7 +168,7 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UsbTransmitByte(data[data_index]); result = UsbTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UsbTransmitPacket ***/ } /*** end of UsbTransmitPacket ***/
@ -215,7 +215,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
@ -238,7 +238,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
static blt_bool UsbReceiveByte(blt_int8u *data) static blt_bool UsbReceiveByte(blt_int8u *data)
{ {
blt_bool result; blt_bool result;
/* obtain data from the fifo */ /* obtain data from the fifo */
result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data); result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data);
return result; return result;
@ -254,7 +254,7 @@ static blt_bool UsbReceiveByte(blt_int8u *data)
static blt_bool UsbTransmitByte(blt_int8u data) static blt_bool UsbTransmitByte(blt_int8u data)
{ {
blt_bool result; blt_bool result;
/* write data from to fifo */ /* write data from to fifo */
result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data); result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data);
return result; return result;
@ -333,14 +333,14 @@ void UsbTransmitPipeBulkIN(void)
result = UsbFifoMgrRead(fifoPipeBulkIN.handle, &byte_value); result = UsbFifoMgrRead(fifoPipeBulkIN.handle, &byte_value);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* store it in the endpoint's RAM */ /* store it in the endpoint's RAM */
USB_Tx_Buffer[byte_counter] = byte_value; USB_Tx_Buffer[byte_counter] = byte_value;
} }
/* store it in the endpoint's RAM */ /* store it in the endpoint's RAM */
UserToPMABufferCopy(&USB_Tx_Buffer[0], ENDP1_TXADDR, nr_of_bytes_for_tx_endpoint); UserToPMABufferCopy(&USB_Tx_Buffer[0], ENDP1_TXADDR, nr_of_bytes_for_tx_endpoint);
/* set the number of bytes that need to be transmitted from this endpoint */ /* set the number of bytes that need to be transmitted from this endpoint */
SetEPTxCount(ENDP1, nr_of_bytes_for_tx_endpoint); SetEPTxCount(ENDP1, nr_of_bytes_for_tx_endpoint);
/* inform the endpoint that it can start its transmission because the data is valid */ /* inform the endpoint that it can start its transmission because the data is valid */
SetEPTxValid(ENDP1); SetEPTxValid(ENDP1);
} /*** end of UsbTransmitPipeBulkIN ***/ } /*** end of UsbTransmitPipeBulkIN ***/
@ -356,12 +356,12 @@ void UsbReceivePipeBulkOUT(void)
uint16_t USB_Rx_Cnt; uint16_t USB_Rx_Cnt;
uint16_t byte_counter; uint16_t byte_counter;
blt_bool result; blt_bool result;
/* Get the received data buffer and update the counter */ /* Get the received data buffer and update the counter */
USB_Rx_Cnt = USB_SIL_Read(EP1_OUT, USB_Rx_Buffer); USB_Rx_Cnt = USB_SIL_Read(EP1_OUT, USB_Rx_Buffer);
/* USB data will be immediately processed, this allow next USB traffic being /* USB data will be immediately processed, this allow next USB traffic being
* NAKed till the end of the USART Xfer * NAKed till the end of the USART Xfer
*/ */
for (byte_counter=0; byte_counter<USB_Rx_Cnt; byte_counter++) for (byte_counter=0; byte_counter<USB_Rx_Cnt; byte_counter++)
{ {
@ -383,23 +383,23 @@ void UsbReceivePipeBulkOUT(void)
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
static void IntToUnicode (blt_int32u value , blt_int8u *pbuf , blt_int8u len) static void IntToUnicode(blt_int32u value , blt_int8u *pbuf , blt_int8u len)
{ {
blt_int8u idx = 0; blt_int8u idx = 0;
for( idx = 0 ; idx < len ; idx ++) for (idx = 0 ; idx < len ; idx ++)
{ {
if( ((value >> 28)) < 0xA ) if (((value >> 28)) < 0xA)
{ {
pbuf[ 2* idx] = (value >> 28) + '0'; pbuf[ 2* idx] = (value >> 28) + '0';
} }
else else
{ {
pbuf[2* idx] = (value >> 28) + 'A' - 10; pbuf[2* idx] = (value >> 28) + 'A' - 10;
} }
value = value << 4; value = value << 4;
pbuf[ 2* idx + 1] = 0; pbuf[ 2* idx + 1] = 0;
} }
} /*** end of IntToUnicode ***/ } /*** end of IntToUnicode ***/
@ -414,9 +414,9 @@ void UsbGetSerialNum(void)
{ {
blt_int32u Device_Serial0, Device_Serial1, Device_Serial2; blt_int32u Device_Serial0, Device_Serial1, Device_Serial2;
Device_Serial0 = *(volatile blt_int32u*)(0x1FFFF7E8); Device_Serial0 = *(volatile blt_int32u *)(0x1FFFF7E8);
Device_Serial1 = *(volatile blt_int32u*)(0x1FFFF7EC); Device_Serial1 = *(volatile blt_int32u *)(0x1FFFF7EC);
Device_Serial2 = *(volatile blt_int32u*)(0x1FFFF7F0); Device_Serial2 = *(volatile blt_int32u *)(0x1FFFF7F0);
Device_Serial0 += Device_Serial2; Device_Serial0 += Device_Serial2;
@ -488,7 +488,7 @@ static blt_int8u UsbFifoMgrCreate(blt_int8u *buffer, blt_int8u length)
pbc->writeptr = buffer; pbc->writeptr = buffer;
pbc->entries = 0; pbc->entries = 0;
pbc->startptr = buffer; pbc->startptr = buffer;
pbc->endptr = (blt_int8u*)(buffer + length - 1); pbc->endptr = (blt_int8u *)(buffer + length - 1);
/* return the handle to the successfully created fifo control */ /* return the handle to the successfully created fifo control */
return pbc->handle; return pbc->handle;
@ -524,7 +524,7 @@ static blt_bool UsbFifoMgrWrite(blt_int8u handle, blt_int8u data)
/* set write pointer to start of the cyclic fifo */ /* set write pointer to start of the cyclic fifo */
fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr; fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr;
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of UsbFifoMgrWrite ***/ } /*** end of UsbFifoMgrWrite ***/

14
Target/Source/ARMCM4_STM32/Crossworks/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -47,7 +47,7 @@ extern void reset_handler(void); /* implemented in cstart.s
* External data declarations * External data declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Stack end address (memory.x) */ /** \brief Stack end address (memory.x) */
extern blt_int32u __stack_end__; extern blt_int32u __stack_end__;
/************************************************************************************//** /************************************************************************************//**
@ -70,13 +70,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".vectors"))) __attribute__((section(".vectors")))
const tIsrFunc _vectors[] = const tIsrFunc _vectors[] =
{ {
{ .ptr = (blt_int32u)&__stack_end__ }, /* the initial stack pointer */ { .ptr = (blt_int32u) &__stack_end__ }, /* the initial stack pointer */
reset_handler, /* the reset handler */ reset_handler, /* the reset handler */
UnusedISR, /* NMI Handler */ UnusedISR, /* NMI Handler */
UnusedISR, /* Hard Fault Handler */ UnusedISR, /* Hard Fault Handler */

12
Target/Source/ARMCM4_STM32/GCC/cstart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -56,7 +56,7 @@ extern blt_int32u _estack;
/************************************************************************************//** /************************************************************************************//**
** \brief Reset interrupt service routine. Configures the stack, initializes ** \brief Reset interrupt service routine. Configures the stack, initializes
** RAM and jumps to function main. ** RAM and jumps to function main.
** \return none. ** \return none.
** **
@ -69,11 +69,11 @@ void reset_handler(void)
__asm(" cpsid i"); __asm(" cpsid i");
/* copy the data segment initializers from flash to SRAM */ /* copy the data segment initializers from flash to SRAM */
pSrc = &_etext; pSrc = &_etext;
for(pDest = &_data; pDest < &_edata; ) for (pDest = &_data; pDest < &_edata;)
{ {
*pDest++ = *pSrc++; *pDest++ = *pSrc++;
} }
/* zero fill the bss segment. this is done with inline assembly since this will /* zero fill the bss segment. this is done with inline assembly since this will
* clear the value of pDest if it is not kept in a register. * clear the value of pDest if it is not kept in a register.
*/ */
__asm(" ldr r0, =_bss\n" __asm(" ldr r0, =_bss\n"

12
Target/Source/ARMCM4_STM32/GCC/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -64,13 +64,13 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
blt_int32u ptr; /**< for stack pointer entry */ blt_int32u ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__attribute__ ((section(".isr_vector"))) __attribute__((section(".isr_vector")))
const tIsrFunc _vectab[] = const tIsrFunc _vectab[] =
{ {
{ .ptr = (blt_int32u)&_estack }, /* the initial stack pointer */ { .ptr = (blt_int32u) &_estack }, /* the initial stack pointer */
{ reset_handler }, /* the reset handler */ { reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

12
Target/Source/ARMCM4_STM32/IAR/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -40,7 +40,7 @@
/**************************************************************************************** /****************************************************************************************
* External functions * External functions
****************************************************************************************/ ****************************************************************************************/
extern void reset_handler( void ); extern void reset_handler(void);
/**************************************************************************************** /****************************************************************************************
@ -51,7 +51,7 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
void *ptr; /**< for stack pointer entry */ void *ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/************************************************************************************//** /************************************************************************************//**
@ -75,7 +75,7 @@ void UnusedISR(void)
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__root const tIsrFunc __vector_table[] @ ".intvec" = __root const tIsrFunc __vector_table[] @ ".intvec" =
{ {
{ .ptr = __sfe( "CSTACK" ) }, /* the initial stack pointer */ { .ptr = __sfe("CSTACK") }, /* the initial stack pointer */
{ &reset_handler }, /* the reset handler */ { &reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

81
Target/Source/ARMCM4_STM32/can.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -58,7 +58,7 @@ typedef struct
volatile blt_int32u RDTR; volatile blt_int32u RDTR;
volatile blt_int32u RDLR; volatile blt_int32u RDLR;
volatile blt_int32u RDHR; volatile blt_int32u RDHR;
} tCanRxFIFOMailBox; } tCanRxFIFOMailBox;
/** \brief CAN filter register layout. */ /** \brief CAN filter register layout. */
typedef struct typedef struct
@ -92,7 +92,7 @@ typedef struct
volatile blt_int32u FA1R; volatile blt_int32u FA1R;
blt_int32u RESERVED5[8]; blt_int32u RESERVED5[8];
tCanFilter sFilterRegister[28]; tCanFilter sFilterRegister[28];
} tCanRegs; } tCanRegs;
/**************************************************************************************** /****************************************************************************************
@ -149,48 +149,49 @@ typedef struct t_can_bus_timing
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief CAN bittiming table for dynamically calculating the bittiming settings. /** \brief CAN bittiming table for dynamically calculating the bittiming settings.
* \details According to the CAN protocol 1 bit-time can be made up of between 8..25 * \details According to the CAN protocol 1 bit-time can be made up of between 8..25
* time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC * time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC
* always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) * * always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) *
* 100%. This array contains possible and valid time quanta configurations with * 100%. This array contains possible and valid time quanta configurations with
* a sample point between 68..78%. * a sample point between 68..78%.
*/ */
static const tCanBusTiming canTiming[] = static const tCanBusTiming canTiming[] =
{ /* TQ | TSEG1 | TSEG2 | SP */ {
/* ------------------------- */ /* TQ | TSEG1 | TSEG2 | SP */
{ 5, 2 }, /* 8 | 5 | 2 | 75% */ /* ------------------------- */
{ 6, 2 }, /* 9 | 6 | 2 | 78% */ { 5, 2 }, /* 8 | 5 | 2 | 75% */
{ 6, 3 }, /* 10 | 6 | 3 | 70% */ { 6, 2 }, /* 9 | 6 | 2 | 78% */
{ 7, 3 }, /* 11 | 7 | 3 | 73% */ { 6, 3 }, /* 10 | 6 | 3 | 70% */
{ 8, 3 }, /* 12 | 8 | 3 | 75% */ { 7, 3 }, /* 11 | 7 | 3 | 73% */
{ 9, 3 }, /* 13 | 9 | 3 | 77% */ { 8, 3 }, /* 12 | 8 | 3 | 75% */
{ 9, 4 }, /* 14 | 9 | 4 | 71% */ { 9, 3 }, /* 13 | 9 | 3 | 77% */
{ 10, 4 }, /* 15 | 10 | 4 | 73% */ { 9, 4 }, /* 14 | 9 | 4 | 71% */
{ 11, 4 }, /* 16 | 11 | 4 | 75% */ { 10, 4 }, /* 15 | 10 | 4 | 73% */
{ 12, 4 }, /* 17 | 12 | 4 | 76% */ { 11, 4 }, /* 16 | 11 | 4 | 75% */
{ 12, 5 }, /* 18 | 12 | 5 | 72% */ { 12, 4 }, /* 17 | 12 | 4 | 76% */
{ 13, 5 }, /* 19 | 13 | 5 | 74% */ { 12, 5 }, /* 18 | 12 | 5 | 72% */
{ 14, 5 }, /* 20 | 14 | 5 | 75% */ { 13, 5 }, /* 19 | 13 | 5 | 74% */
{ 15, 5 }, /* 21 | 15 | 5 | 76% */ { 14, 5 }, /* 20 | 14 | 5 | 75% */
{ 15, 6 }, /* 22 | 15 | 6 | 73% */ { 15, 5 }, /* 21 | 15 | 5 | 76% */
{ 16, 6 }, /* 23 | 16 | 6 | 74% */ { 15, 6 }, /* 22 | 15 | 6 | 73% */
{ 16, 7 }, /* 24 | 16 | 7 | 71% */ { 16, 6 }, /* 23 | 16 | 6 | 74% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */ { 16, 7 }, /* 24 | 16 | 7 | 71% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */
}; };
/************************************************************************************//** /************************************************************************************//**
** \brief Search algorithm to match the desired baudrate to a possible bus ** \brief Search algorithm to match the desired baudrate to a possible bus
** timing configuration. ** timing configuration.
** \param baud The desired baudrate in kbps. Valid values are 10..1000. ** \param baud The desired baudrate in kbps. Valid values are 10..1000.
** \param prescaler Pointer to where the value for the prescaler will be stored. ** \param prescaler Pointer to where the value for the prescaler will be stored.
** \param tseg1 Pointer to where the value for TSEG2 will be stored. ** \param tseg1 Pointer to where the value for TSEG2 will be stored.
** \param tseg2 Pointer to where the value for TSEG2 will be stored. ** \param tseg2 Pointer to where the value for TSEG2 will be stored.
** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE ** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE
** otherwise. ** otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler, static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler,
blt_int8u *tseg1, blt_int8u *tseg2) blt_int8u *tseg1, blt_int8u *tseg2)
{ {
blt_int8u cnt; blt_int8u cnt;
@ -204,7 +205,7 @@ static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler,
*prescaler = (BOOT_CPU_SYSTEM_SPEED_KHZ/4)/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)); *prescaler = (BOOT_CPU_SYSTEM_SPEED_KHZ/4)/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1));
/* make sure the prescaler is valid */ /* make sure the prescaler is valid */
if ( (*prescaler > 0) && (*prescaler <= 1024) ) if ((*prescaler > 0) && (*prescaler <= 1024))
{ {
/* store the bustiming configuration */ /* store the bustiming configuration */
*tseg1 = canTiming[cnt].tseg1; *tseg1 = canTiming[cnt].tseg1;
@ -230,10 +231,10 @@ void CanInit(void)
blt_int8u tseg1, tseg2; blt_int8u tseg1, tseg2;
blt_bool result; blt_bool result;
/* the current implementation supports CAN1 and 2. throw an assertion error in case a /* the current implementation supports CAN1 and 2. throw an assertion error in case a
* different CAN channel is configured. * different CAN channel is configured.
*/ */
ASSERT_CT((BOOT_COM_CAN_CHANNEL_INDEX == 0 || BOOT_COM_CAN_CHANNEL_INDEX == 1)); ASSERT_CT((BOOT_COM_CAN_CHANNEL_INDEX == 0 || BOOT_COM_CAN_CHANNEL_INDEX == 1));
/* obtain bittiming configuration information */ /* obtain bittiming configuration information */
result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &prescaler, &tseg1, &tseg2); result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &prescaler, &tseg1, &tseg2);
@ -279,8 +280,8 @@ void CanInit(void)
/* 32-bit scale for the filter */ /* 32-bit scale for the filter */
CAN1->FS1R |= CAN_BIT_FILTER0; CAN1->FS1R |= CAN_BIT_FILTER0;
/* open up the acceptance filter to receive all messages */ /* open up the acceptance filter to receive all messages */
CAN1->sFilterRegister[0].FR1 = 0; CAN1->sFilterRegister[0].FR1 = 0;
CAN1->sFilterRegister[0].FR2 = 0; CAN1->sFilterRegister[0].FR2 = 0;
/* select id/mask mode for the filter */ /* select id/mask mode for the filter */
CAN1->FM1R &= ~CAN_BIT_FILTER0; CAN1->FM1R &= ~CAN_BIT_FILTER0;
/* FIFO 0 assignation for the filter */ /* FIFO 0 assignation for the filter */
@ -297,8 +298,8 @@ void CanInit(void)
/* 32-bit scale for the filter */ /* 32-bit scale for the filter */
CAN1->FS1R |= CAN_BIT_FILTER14; CAN1->FS1R |= CAN_BIT_FILTER14;
/* open up the acceptance filter to receive all messages */ /* open up the acceptance filter to receive all messages */
CAN1->sFilterRegister[14].FR1 = 0; CAN1->sFilterRegister[14].FR1 = 0;
CAN1->sFilterRegister[14].FR2 = 0; CAN1->sFilterRegister[14].FR2 = 0;
/* select id/mask mode for the filter */ /* select id/mask mode for the filter */
CAN1->FM1R &= ~CAN_BIT_FILTER14; CAN1->FM1R &= ~CAN_BIT_FILTER14;
/* FIFO 0 assignation for the filter */ /* FIFO 0 assignation for the filter */
@ -307,7 +308,7 @@ void CanInit(void)
CAN1->FA1R |= CAN_BIT_FILTER14; CAN1->FA1R |= CAN_BIT_FILTER14;
/* leave initialisation mode for the acceptance filter */ /* leave initialisation mode for the acceptance filter */
CAN1->FMR &= ~CAN_BIT_FINIT; CAN1->FMR &= ~CAN_BIT_FINIT;
#endif #endif
} /*** end of CanInit ***/ } /*** end of CanInit ***/

22
Target/Source/ARMCM4_STM32/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ extern void reset_handler(void); /* implemented in cstart.s
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -83,18 +83,18 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* remap user program's vector table */ /* remap user program's vector table */
@ -103,7 +103,7 @@ void CpuStartUserProgram(void)
* the 2nd entry in the user program's vector table. this address points to the * the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -113,7 +113,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -126,7 +126,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

182
Target/Source/ARMCM4_STM32/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -58,7 +58,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -66,10 +66,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -84,7 +84,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -95,8 +95,8 @@ static blt_int8u FlashGetSector(blt_addr address);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -177,30 +177,30 @@ static const blt_int16u flashSectorNumToMask[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -208,7 +208,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -222,12 +222,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -235,10 +235,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -254,24 +254,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -286,27 +286,27 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* for the STM32 target we defined the checksum as the Two's complement value of the /* for the STM32 target we defined the checksum as the Two's complement value of the
* sum of the first 7 exception addresses. * sum of the first 7 exception addresses.
* *
* Layout of the vector table: * Layout of the vector table:
* 0x08000000 Initial stack pointer * 0x08000000 Initial stack pointer
* 0x08000004 Reset Handler * 0x08000004 Reset Handler
* 0x08000008 NMI Handler * 0x08000008 NMI Handler
* 0x0800000C Hard Fault Handler * 0x0800000C Hard Fault Handler
* 0x08000010 MPU Fault Handler * 0x08000010 MPU Fault Handler
* 0x08000014 Bus Fault Handler * 0x08000014 Bus Fault Handler
* 0x08000018 Usage Fault Handler * 0x08000018 Usage Fault Handler
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
* *
* the bootloader writes this 32-bit checksum value right after the vector table * the bootloader writes this 32-bit checksum value right after the vector table
* of the user program. note that this means one extra dummy entry must be added * of the user program. note that this means one extra dummy entry must be added
* at the end of the user program's vector table to reserve storage space for the * at the end of the user program's vector table to reserve storage space for the
@ -317,49 +317,49 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x14])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x14]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -374,7 +374,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -387,7 +387,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -396,7 +396,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -414,16 +414,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -434,8 +434,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -454,14 +454,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -480,7 +480,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -502,13 +502,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -532,7 +532,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -589,14 +589,14 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
} }
/* unlock the flash array */ /* unlock the flash array */
FLASH_Unlock(); FLASH_Unlock();
/* clear pending flags (if any) */ /* clear pending flags (if any) */
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
/* check that the flash peripheral is not busy */ /* check that the flash peripheral is not busy */
if (FLASH_GetStatus() == FLASH_BUSY) if (FLASH_GetStatus() == FLASH_BUSY)
{ {
/* lock the flash array again */ /* lock the flash array again */
FLASH_Lock(); FLASH_Lock();
/* could not perform erase operation */ /* could not perform erase operation */
return BLT_FALSE; return BLT_FALSE;
} }
@ -604,7 +604,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u));
prog_data = *(volatile blt_int32u*)(&block->data[word_cnt * sizeof(blt_int32u)]); prog_data = *(volatile blt_int32u *)(&block->data[word_cnt * sizeof(blt_int32u)]);
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program the word */ /* program the word */
@ -614,14 +614,14 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
break; break;
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (*(volatile blt_int32u*)prog_addr != prog_data) if (*(volatile blt_int32u *)prog_addr != prog_data)
{ {
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
} }
/* lock the flash array again */ /* lock the flash array again */
FLASH_Lock(); FLASH_Lock();
/* still here so all is okay */ /* still here so all is okay */
return result; return result;
} /*** end of FlashWriteBlock ***/ } /*** end of FlashWriteBlock ***/
@ -643,21 +643,21 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* unlock the flash array */ /* unlock the flash array */
FLASH_Unlock(); FLASH_Unlock();
/* clear pending flags (if any) */ /* clear pending flags (if any) */
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
/* check that the flash peripheral is not busy */ /* check that the flash peripheral is not busy */
if (FLASH_GetStatus() == FLASH_BUSY) if (FLASH_GetStatus() == FLASH_BUSY)
{ {
/* lock the flash array again */ /* lock the flash array again */
FLASH_Lock(); FLASH_Lock();
/* could not perform erase operation */ /* could not perform erase operation */
return BLT_FALSE; return BLT_FALSE;
} }
@ -670,13 +670,13 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
if (FLASH_EraseSector(flashSectorNumToMask[sector_cnt], VoltageRange_3) != FLASH_COMPLETE) if (FLASH_EraseSector(flashSectorNumToMask[sector_cnt], VoltageRange_3) != FLASH_COMPLETE)
{ {
/* lock the flash array again */ /* lock the flash array again */
FLASH_Lock(); FLASH_Lock();
/* could not perform erase operation */ /* could not perform erase operation */
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* lock the flash array again */ /* lock the flash array again */
FLASH_Lock(); FLASH_Lock();
/* still here so all went okay */ /* still here so all went okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashEraseSectors ***/ } /*** end of FlashEraseSectors ***/
@ -691,16 +691,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;

6
Target/Source/ARMCM4_STM32/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/ARMCM4_STM32/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM4_STM32/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM4_STM32/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

30
Target/Source/ARMCM4_STM32/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -85,15 +85,15 @@ void UartInit(void)
{ {
USART_InitTypeDef USART_InitStructure; USART_InitTypeDef USART_InitStructure;
/* the current implementation supports USART1 - USART6. throw an assertion error in /* the current implementation supports USART1 - USART6. throw an assertion error in
* case a different UART channel is configured. * case a different UART channel is configured.
*/ */
ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) || ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) ||
(BOOT_COM_UART_CHANNEL_INDEX == 1) || (BOOT_COM_UART_CHANNEL_INDEX == 1) ||
(BOOT_COM_UART_CHANNEL_INDEX == 2) || (BOOT_COM_UART_CHANNEL_INDEX == 2) ||
(BOOT_COM_UART_CHANNEL_INDEX == 3) || (BOOT_COM_UART_CHANNEL_INDEX == 3) ||
(BOOT_COM_UART_CHANNEL_INDEX == 4) || (BOOT_COM_UART_CHANNEL_INDEX == 4) ||
(BOOT_COM_UART_CHANNEL_INDEX == 5)); (BOOT_COM_UART_CHANNEL_INDEX == 5));
/* initialize the uart for the specified communication speed */ /* initialize the uart for the specified communication speed */
USART_InitStructure.USART_BaudRate = BOOT_COM_UART_BAUDRATE; USART_InitStructure.USART_BaudRate = BOOT_COM_UART_BAUDRATE;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_WordLength = USART_WordLength_8b;
@ -117,15 +117,15 @@ void UartInit(void)
void UartTransmitPacket(blt_int8u *data, blt_int8u len) void UartTransmitPacket(blt_int8u *data, blt_int8u len)
{ {
blt_int16u data_index; blt_int16u data_index;
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -133,7 +133,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -180,7 +180,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -242,8 +242,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit holding register */ /* write byte to transmit holding register */
USART_SendData(USART_CHANNEL, data); USART_SendData(USART_CHANNEL, data);
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while (USART_GetFlagStatus(USART_CHANNEL, USART_FLAG_TXE) == RESET) while (USART_GetFlagStatus(USART_CHANNEL, USART_FLAG_TXE) == RESET)
{ {
; ;
} }
/* byte transmitted */ /* byte transmitted */

46
Target/Source/ARMCM4_STM32/usb.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ typedef struct t_fifo_ctrl
blt_int8u *writeptr; /**< pointer to next free location */ blt_int8u *writeptr; /**< pointer to next free location */
blt_int8u length; /**< number of buffer elements */ blt_int8u length; /**< number of buffer elements */
blt_int8u entries; /**< # of full buffer elements */ blt_int8u entries; /**< # of full buffer elements */
blt_int8u handle; /**< handle of the buffer */ blt_int8u handle; /**< handle of the buffer */
struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */ struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */
} tFifoCtrl; } tFifoCtrl;
@ -122,15 +122,15 @@ void UsbInit(void)
fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE); fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE);
fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE); fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE);
/* validate fifo handles */ /* validate fifo handles */
ASSERT_RT( (fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \ ASSERT_RT((fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \
(fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE) ); (fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE));
/* initialize the low level USB driver */ /* initialize the low level USB driver */
USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_bulk_cb, &USR_cb); USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_bulk_cb, &USR_cb);
} /*** end of UsbInit ***/ } /*** end of UsbInit ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Releases the USB communication interface. ** \brief Releases the USB communication interface.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -156,12 +156,12 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UsbTransmitByte(len); result = UsbTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -169,7 +169,7 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UsbTransmitByte(data[data_index]); result = UsbTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UsbTransmitPacket ***/ } /*** end of UsbTransmitPacket ***/
@ -187,7 +187,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
static blt_bool xcpCtoRxInProgress = BLT_FALSE; static blt_bool xcpCtoRxInProgress = BLT_FALSE;
/* poll USB interrupt flags to process USB related events */ /* poll USB interrupt flags to process USB related events */
USBD_OTG_ISR_Handler (&USB_OTG_dev); USBD_OTG_ISR_Handler(&USB_OTG_dev);
/* start of cto packet received? */ /* start of cto packet received? */
if (xcpCtoRxInProgress == BLT_FALSE) if (xcpCtoRxInProgress == BLT_FALSE)
@ -216,7 +216,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
@ -239,7 +239,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
static blt_bool UsbReceiveByte(blt_int8u *data) static blt_bool UsbReceiveByte(blt_int8u *data)
{ {
blt_bool result; blt_bool result;
/* obtain data from the fifo */ /* obtain data from the fifo */
result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data); result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data);
return result; return result;
@ -255,7 +255,7 @@ static blt_bool UsbReceiveByte(blt_int8u *data)
static blt_bool UsbTransmitByte(blt_int8u data) static blt_bool UsbTransmitByte(blt_int8u data)
{ {
blt_bool result; blt_bool result;
/* write data from to fifo */ /* write data from to fifo */
result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data); result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data);
return result; return result;
@ -296,7 +296,7 @@ void UsbTransmitPipeBulkIN(void)
result = UsbFifoMgrRead(fifoPipeBulkIN.handle, &byte_value); result = UsbFifoMgrRead(fifoPipeBulkIN.handle, &byte_value);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* store it in the endpoint's RAM */ /* store it in the endpoint's RAM */
USB_Tx_Buffer[byte_counter] = byte_value; USB_Tx_Buffer[byte_counter] = byte_value;
} }
/* copy data to endpoint's RAM and start the transmission */ /* copy data to endpoint's RAM and start the transmission */
DCD_EP_Tx(&USB_OTG_dev, BULK_IN_EP, &USB_Tx_Buffer[0], nr_of_bytes_for_tx_endpoint); DCD_EP_Tx(&USB_OTG_dev, BULK_IN_EP, &USB_Tx_Buffer[0], nr_of_bytes_for_tx_endpoint);
@ -313,12 +313,12 @@ void UsbReceivePipeBulkOUT(uint8_t epnum)
uint16_t USB_Rx_Cnt=0; uint16_t USB_Rx_Cnt=0;
uint16_t byte_counter; uint16_t byte_counter;
blt_bool result; blt_bool result;
/* Get the received data buffer and update the counter */ /* Get the received data buffer and update the counter */
USB_Rx_Cnt = USB_OTG_dev.dev.out_ep[epnum].xfer_count; USB_Rx_Cnt = USB_OTG_dev.dev.out_ep[epnum].xfer_count;
/* USB data will be immediately processed, this allow next USB traffic being /* USB data will be immediately processed, this allow next USB traffic being
* NAKed till the end of the USART Xfer * NAKed till the end of the USART Xfer
*/ */
for (byte_counter=0; byte_counter<USB_Rx_Cnt; byte_counter++) for (byte_counter=0; byte_counter<USB_Rx_Cnt; byte_counter++)
{ {
@ -394,7 +394,7 @@ static blt_int8u UsbFifoMgrCreate(blt_int8u *buffer, blt_int8u length)
pbc->writeptr = buffer; pbc->writeptr = buffer;
pbc->entries = 0; pbc->entries = 0;
pbc->startptr = buffer; pbc->startptr = buffer;
pbc->endptr = (blt_int8u*)(buffer + length - 1); pbc->endptr = (blt_int8u *)(buffer + length - 1);
/* return the handle to the successfully created fifo control */ /* return the handle to the successfully created fifo control */
return pbc->handle; return pbc->handle;
@ -430,7 +430,7 @@ static blt_bool UsbFifoMgrWrite(blt_int8u handle, blt_int8u data)
/* set write pointer to start of the cyclic fifo */ /* set write pointer to start of the cyclic fifo */
fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr; fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr;
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of UsbFifoMgrWrite ***/ } /*** end of UsbFifoMgrWrite ***/

12
Target/Source/ARMCM4_TM4C/IAR/vectors.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -40,7 +40,7 @@
/**************************************************************************************** /****************************************************************************************
* External functions * External functions
****************************************************************************************/ ****************************************************************************************/
extern void reset_handler( void ); extern void reset_handler(void);
/**************************************************************************************** /****************************************************************************************
@ -51,7 +51,7 @@ typedef union
{ {
void (*func)(void); /**< for ISR function pointers */ void (*func)(void); /**< for ISR function pointers */
void *ptr; /**< for stack pointer entry */ void *ptr; /**< for stack pointer entry */
}tIsrFunc; } tIsrFunc;
/************************************************************************************//** /************************************************************************************//**
@ -75,7 +75,7 @@ void UnusedISR(void)
/** \brief Interrupt vector table. */ /** \brief Interrupt vector table. */
__root const tIsrFunc __vector_table[] @ ".intvec" = __root const tIsrFunc __vector_table[] @ ".intvec" =
{ {
{ .ptr = __sfe( "CSTACK" ) }, /* the initial stack pointer */ { .ptr = __sfe("CSTACK") }, /* the initial stack pointer */
{ &reset_handler }, /* the reset handler */ { &reset_handler }, /* the reset handler */
{ UnusedISR }, /* NMI Handler */ { UnusedISR }, /* NMI Handler */
{ UnusedISR }, /* Hard Fault Handler */ { UnusedISR }, /* Hard Fault Handler */

24
Target/Source/ARMCM4_TM4C/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -45,7 +45,7 @@
/** \brief Pointer to the user program's vector table. */ /** \brief Pointer to the user program's vector table. */
#define CPU_USER_PROGRAM_VECTABLE_OFFSET ((blt_int32u)NvmGetUserProgBaseAddress()) #define CPU_USER_PROGRAM_VECTABLE_OFFSET ((blt_int32u)NvmGetUserProgBaseAddress())
/**************************************************************************************** /****************************************************************************************
* Register definitions * Register definitions
****************************************************************************************/ ****************************************************************************************/
@ -69,7 +69,7 @@ extern void reset_handler(void); /* implemented in cstart.s
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -83,18 +83,18 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* remap user program's vector table */ /* remap user program's vector table */
@ -103,7 +103,7 @@ void CpuStartUserProgram(void)
* the 2nd entry in the user program's vector table. this address points to the * the 2nd entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -113,7 +113,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -126,7 +126,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

170
Target/Source/ARMCM4_TM4C/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -63,7 +63,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -71,10 +71,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -89,7 +89,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -102,13 +102,13 @@ static blt_addr FlashGetSectorSize(blt_int8u sector);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* The current flash layout does not reflect the minimum sector size of the * The current flash layout does not reflect the minimum sector size of the
* physical flash (1 - 2kb), because this would make the table quit long and * physical flash (1 - 2kb), because this would make the table quit long and
* a waste of ROM. The minimum sector size is only really needed when erasing * a waste of ROM. The minimum sector size is only really needed when erasing
* the flash. This can still be done in combination with macro * the flash. This can still be done in combination with macro
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -164,30 +164,30 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -195,7 +195,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -209,12 +209,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -222,10 +222,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -241,24 +241,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -273,27 +273,27 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* for the TM4C target we defined the checksum as the Two's complement value of the /* for the TM4C target we defined the checksum as the Two's complement value of the
* sum of the first 7 exception addresses. * sum of the first 7 exception addresses.
* *
* Layout of the vector table: * Layout of the vector table:
* 0x00000000 Initial stack pointer * 0x00000000 Initial stack pointer
* 0x00000004 Reset Handler * 0x00000004 Reset Handler
* 0x00000008 NMI Handler * 0x00000008 NMI Handler
* 0x0000000C Hard Fault Handler * 0x0000000C Hard Fault Handler
* 0x00000010 MPU Fault Handler * 0x00000010 MPU Fault Handler
* 0x00000014 Bus Fault Handler * 0x00000014 Bus Fault Handler
* 0x00000018 Usage Fault Handler * 0x00000018 Usage Fault Handler
* *
* signature_checksum = Two's complement of (SUM(exception address values)) * signature_checksum = Two's complement of (SUM(exception address values))
* *
* the bootloader writes this 32-bit checksum value right after the vector table * the bootloader writes this 32-bit checksum value right after the vector table
* of the user program. note that this means one extra dummy entry must be added * of the user program. note that this means one extra dummy entry must be added
* at the end of the user program's vector table to reserve storage space for the * at the end of the user program's vector table to reserve storage space for the
@ -304,49 +304,49 @@ blt_bool FlashWriteChecksum(void)
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the user program's vectors are not yet written /* compute the checksum. note that the user program's vectors are not yet written
* to flash but are present in the bootblock data structure at this point. * to flash but are present in the bootblock data structure at this point.
*/ */
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x00])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x00]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x04])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x04]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x08])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x08]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x0C])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x0C]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x10])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x10]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x14])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x14]));
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[0+0x18])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[0+0x18]));
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
{ {
blt_int32u signature_checksum = 0; blt_int32u signature_checksum = 0;
/* verify the checksum based on how it was written by CpuWriteChecksum() */ /* verify the checksum based on how it was written by CpuWriteChecksum() */
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x04)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x04));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x08)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x08));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x0C)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x0C));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x10)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x10));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x14)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x14));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+0x18)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+0x18));
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start+FLASH_VECTOR_TABLE_CS_OFFSET));
/* sum should add up to an unsigned 32-bit value of 0 */ /* sum should add up to an unsigned 32-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -361,7 +361,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -374,7 +374,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -383,7 +383,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -401,16 +401,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -421,8 +421,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -441,14 +441,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -467,7 +467,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -489,13 +489,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -519,7 +519,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -574,12 +574,12 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* program all words in the block one by one */ /* program all words in the block one by one */
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int32u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int32u));
prog_data = *(volatile blt_int32u*)(&block->data[word_cnt * sizeof(blt_int32u)]); prog_data = *(volatile blt_int32u *)(&block->data[word_cnt * sizeof(blt_int32u)]);
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program the word to flash */ /* program the word to flash */
@ -589,7 +589,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
break; break;
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (*(volatile blt_int32u*)prog_addr != prog_data) if (*(volatile blt_int32u *)prog_addr != prog_data)
{ {
result = BLT_FALSE; result = BLT_FALSE;
break; break;
@ -619,12 +619,12 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* determine how many blocks need to be erased */ /* determine how many blocks need to be erased */
start_addr = FlashGetSectorBaseAddr(first_sector); start_addr = FlashGetSectorBaseAddr(first_sector);
end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1; end_addr = FlashGetSectorBaseAddr(last_sector) + FlashGetSectorSize(last_sector) - 1;
@ -655,16 +655,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;
@ -684,7 +684,7 @@ static blt_int8u FlashGetSector(blt_addr address)
static blt_addr FlashGetSectorBaseAddr(blt_int8u sector) static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -709,7 +709,7 @@ static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
static blt_addr FlashGetSectorSize(blt_int8u sector) static blt_addr FlashGetSectorSize(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {

6
Target/Source/ARMCM4_TM4C/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/ARMCM4_TM4C/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM4_TM4C/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/ARMCM4_TM4C/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

34
Target/Source/ARMCM4_TM4C/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -69,16 +69,16 @@ static blt_bool UartTransmitByte(blt_int8u data);
****************************************************************************************/ ****************************************************************************************/
void UartInit(void) void UartInit(void)
{ {
/* the current implementation supports UART0. throw an assertion error in case a /* the current implementation supports UART0. throw an assertion error in case a
* different UART channel is configured. * different UART channel is configured.
*/ */
ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0); ASSERT_CT(BOOT_COM_UART_CHANNEL_INDEX == 0);
/* enable the UART0 peripheral */ /* enable the UART0 peripheral */
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
/* configure the UART0 baudrate and communication parameters */ /* configure the UART0 baudrate and communication parameters */
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), BOOT_COM_UART_BAUDRATE, UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), BOOT_COM_UART_BAUDRATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE)); UART_CONFIG_PAR_NONE));
} /*** end of UartInit ***/ } /*** end of UartInit ***/
@ -95,12 +95,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -108,7 +108,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -155,7 +155,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -192,7 +192,7 @@ static blt_bool UartReceiveByte(blt_int8u *data)
/* try to read a newly received byte */ /* try to read a newly received byte */
result = UARTCharGetNonBlocking(UART0_BASE); result = UARTCharGetNonBlocking(UART0_BASE);
/* check if a new byte was received */ /* check if a new byte was received */
if(result != -1) if (result != -1)
{ {
/* store the received byte */ /* store the received byte */
data[0] = (blt_int8u)result; data[0] = (blt_int8u)result;
@ -219,8 +219,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
return BLT_FALSE; return BLT_FALSE;
} }
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while(UARTSpaceAvail(UART0_BASE) == false) while (UARTSpaceAvail(UART0_BASE) == false)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

50
Target/Source/ARMCM4_TM4C/usb.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -67,7 +67,7 @@ typedef struct t_fifo_ctrl
blt_int8u *writeptr; /**< pointer to next free location */ blt_int8u *writeptr; /**< pointer to next free location */
blt_int8u length; /**< number of buffer elements */ blt_int8u length; /**< number of buffer elements */
blt_int8u entries; /**< # of full buffer elements */ blt_int8u entries; /**< # of full buffer elements */
blt_int8u handle; /**< handle of the buffer */ blt_int8u handle; /**< handle of the buffer */
struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */ struct t_fifo_ctrl *fifoctrlptr; /**< pointer to free buffer control */
} tFifoCtrl; } tFifoCtrl;
@ -129,8 +129,8 @@ void UsbInit(void)
fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE); fifoPipeBulkIN.handle = UsbFifoMgrCreate(fifoPipeBulkIN.data, FIFO_PIPE_SIZE);
fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE); fifoPipeBulkOUT.handle = UsbFifoMgrCreate(fifoPipeBulkOUT.data, FIFO_PIPE_SIZE);
/* validate fifo handles */ /* validate fifo handles */
ASSERT_RT( (fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \ ASSERT_RT((fifoPipeBulkIN.handle != FIFO_ERR_INVALID_HANDLE) && \
(fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE) ); (fifoPipeBulkOUT.handle != FIFO_ERR_INVALID_HANDLE));
/* initialize the transmit and receive buffers */ /* initialize the transmit and receive buffers */
USBBufferInit(&g_sTxBuffer); USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer); USBBufferInit(&g_sRxBuffer);
@ -141,7 +141,7 @@ void UsbInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Releases the USB communication interface. ** \brief Releases the USB communication interface.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -167,12 +167,12 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-parameter */ /* verify validity of the len-parameter */
ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_USB_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UsbTransmitByte(len); result = UsbTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -180,9 +180,9 @@ void UsbTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UsbTransmitByte(data[data_index]); result = UsbTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
/* start the transmission */ /* start the transmission */
UsbTransmitPipeBulkIN(); UsbTransmitPipeBulkIN();
} /*** end of UsbTransmitPacket ***/ } /*** end of UsbTransmitPacket ***/
@ -202,7 +202,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
/* poll for USB events */ /* poll for USB events */
USB0DeviceIntHandler(); USB0DeviceIntHandler();
/* start of cto packet received? */ /* start of cto packet received? */
if (xcpCtoRxInProgress == BLT_FALSE) if (xcpCtoRxInProgress == BLT_FALSE)
{ {
@ -230,7 +230,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
@ -253,7 +253,7 @@ blt_bool UsbReceivePacket(blt_int8u *data)
static blt_bool UsbReceiveByte(blt_int8u *data) static blt_bool UsbReceiveByte(blt_int8u *data)
{ {
blt_bool result; blt_bool result;
/* obtain data from the fifo */ /* obtain data from the fifo */
result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data); result = UsbFifoMgrRead(fifoPipeBulkOUT.handle, data);
return result; return result;
@ -269,7 +269,7 @@ static blt_bool UsbReceiveByte(blt_int8u *data)
static blt_bool UsbTransmitByte(blt_int8u data) static blt_bool UsbTransmitByte(blt_int8u data)
{ {
blt_bool result; blt_bool result;
/* write data from to fifo */ /* write data from to fifo */
result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data); result = UsbFifoMgrWrite(fifoPipeBulkIN.handle, data);
return result; return result;
@ -291,7 +291,7 @@ static void UsbTransmitPipeBulkIN(void)
blt_int8u byte_counter; blt_int8u byte_counter;
blt_int8u byte_value; blt_int8u byte_value;
blt_bool result; blt_bool result;
/* read how many bytes should be transmitted */ /* read how many bytes should be transmitted */
nr_of_bytes_for_tx_endpoint = UsbFifoMgrScan(fifoPipeBulkIN.handle); nr_of_bytes_for_tx_endpoint = UsbFifoMgrScan(fifoPipeBulkIN.handle);
/* only continue if there is actually data left to transmit */ /* only continue if there is actually data left to transmit */
@ -343,11 +343,11 @@ static void UsbReceivePipeBulkOUT(blt_int8u *data, blt_int32u len)
blt_int32u byte_counter; blt_int32u byte_counter;
blt_bool result; blt_bool result;
blt_int32u rxReadIdx; blt_int32u rxReadIdx;
/* determine read index for the rx buffer */ /* determine read index for the rx buffer */
rxReadIdx = (uint32_t)(data - g_pui8USBRxBuffer); rxReadIdx = (uint32_t)(data - g_pui8USBRxBuffer);
/* store the received data in the reception fifo */ /* store the received data in the reception fifo */
for (byte_counter=0; byte_counter<len; byte_counter++) for (byte_counter=0; byte_counter<len; byte_counter++)
{ {
@ -377,7 +377,7 @@ static void UsbReceivePipeBulkOUT(blt_int8u *data, blt_int32u len)
****************************************************************************************/ ****************************************************************************************/
uint32_t UsbBulkTxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData) uint32_t UsbBulkTxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData)
{ {
if(ui32Event == USB_EVENT_TX_COMPLETE) if (ui32Event == USB_EVENT_TX_COMPLETE)
{ {
/* check if more data is waiting to be transmitted */ /* check if more data is waiting to be transmitted */
UsbTransmitPipeBulkIN(); UsbTransmitPipeBulkIN();
@ -399,7 +399,7 @@ uint32_t UsbBulkTxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgVa
uint32_t UsbBulkRxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData) uint32_t UsbBulkRxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData)
{ {
/* which event are we being sent? */ /* which event are we being sent? */
switch(ui32Event) switch (ui32Event)
{ {
/* we are connected to a host and communication is now possible */ /* we are connected to a host and communication is now possible */
case USB_EVENT_CONNECTED: case USB_EVENT_CONNECTED:
@ -504,7 +504,7 @@ static blt_int8u UsbFifoMgrCreate(blt_int8u *buffer, blt_int8u length)
pbc->writeptr = buffer; pbc->writeptr = buffer;
pbc->entries = 0; pbc->entries = 0;
pbc->startptr = buffer; pbc->startptr = buffer;
pbc->endptr = (blt_int8u*)(buffer + length - 1); pbc->endptr = (blt_int8u *)(buffer + length - 1);
/* return the handle to the successfully created fifo control */ /* return the handle to the successfully created fifo control */
return pbc->handle; return pbc->handle;
@ -540,7 +540,7 @@ static blt_bool UsbFifoMgrWrite(blt_int8u handle, blt_int8u data)
/* set write pointer to start of the cyclic fifo */ /* set write pointer to start of the cyclic fifo */
fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr; fifoCtrl[handle].writeptr = fifoCtrl[handle].startptr;
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of UsbFifoMgrWrite ***/ } /*** end of UsbFifoMgrWrite ***/

503
Target/Source/HCS12/CodeWarrior/cstartup.c
View File

@ -17,7 +17,7 @@ Note: C++ destructors of global objects are NOT yet supported in the HIWARE Obje
/*#define __BANKED_COPY_DOWN : allow to allocate .copy in flash area */ /*#define __BANKED_COPY_DOWN : allow to allocate .copy in flash area */
#if defined(__BANKED_COPY_DOWN) && (!defined(__HCS12X__) || !defined(__ELF_OBJECT_FILE_FORMAT__)) #if defined(__BANKED_COPY_DOWN) && (!defined(__HCS12X__) || !defined(__ELF_OBJECT_FILE_FORMAT__))
#error /* the __BANKED_COPY_DOWN switch is only supported for the HCS12X with ELF */ #error /* the __BANKED_COPY_DOWN switch is only supported for the HCS12X with ELF */
/* (and not for the HC12, HCS12 or for the HIWARE object file format) */ /* (and not for the HC12, HCS12 or for the HIWARE object file format) */
#endif #endif
#include "hidef.h" #include "hidef.h"
@ -49,7 +49,7 @@ Note: C++ destructors of global objects are NOT yet supported in the HIWARE Obje
/* by default, the startup code assumes that the startup data structure */ /* by default, the startup code assumes that the startup data structure */
/* _startupData, the zero out areas and the .copy section are all */ /* _startupData, the zero out areas and the .copy section are all */
/* allocated in NON_BANKED memory. Especially the .copy section can be */ /* allocated in NON_BANKED memory. Especially the .copy section can be */
/* huge if there are many or huge RAM areas to initialize. */ /* huge if there are many or huge RAM areas to initialize. */
/* For the HCS12X, which also copies the XGATE RAM located code via .copy */ /* For the HCS12X, which also copies the XGATE RAM located code via .copy */
/* section, the startup code supports to allocate .copy in a banked flash */ /* section, the startup code supports to allocate .copy in a banked flash */
/* The placement of .copy in the prm file has to be adapted when adding or */ /* The placement of .copy in the prm file has to be adapted when adding or */
@ -71,8 +71,8 @@ __EXTERN_C void main(void); /* prototype of main function */
#pragma DATA_SEG __NEAR_SEG STARTUP_DATA /* _startupData can be accessed using 16 bit accesses. */ #pragma DATA_SEG __NEAR_SEG STARTUP_DATA /* _startupData can be accessed using 16 bit accesses. */
/* This is needed because it contains the stack top, and without stack, far data cannot be accessed */ /* This is needed because it contains the stack top, and without stack, far data cannot be accessed */
struct _tagStartup _startupData; /* read-only: */ struct _tagStartup _startupData; /* read-only: */
/* _startupData is allocated in ROM and */ /* _startupData is allocated in ROM and */
/* initialized by the linker */ /* initialized by the linker */
#pragma DATA_SEG DEFAULT #pragma DATA_SEG DEFAULT
#endif /* __ONLY_INIT_SP */ #endif /* __ONLY_INIT_SP */
@ -86,8 +86,8 @@ struct _tagStartup _startupData; /* read-only: */
/*lint -esym(752,_SET_PAGE) , symbol '_SET_PAGE' is referenced in HLI */ /*lint -esym(752,_SET_PAGE) , symbol '_SET_PAGE' is referenced in HLI */
__EXTERN_C void _SET_PAGE(void); /* the inline assembler needs a prototype */ __EXTERN_C void _SET_PAGE(void); /* the inline assembler needs a prototype */
/* this is a runtime routine with a special */ /* this is a runtime routine with a special */
/* calling convention, do not use it in c code! */ /* calling convention, do not use it in c code! */
#else #else
/*lint -e451 default.sgm contains a conditionally compiled CODE_SEG pragma */ /*lint -e451 default.sgm contains a conditionally compiled CODE_SEG pragma */
#include "default.sgm" #include "default.sgm"
@ -127,198 +127,300 @@ static void __far Init(void)
#else #else
static void Init(void) static void Init(void)
#endif #endif
{ {
/* purpose: 1) zero out RAM-areas where data is allocated */ /* purpose: 1) zero out RAM-areas where data is allocated */
/* 2) copy initialization data from ROM to RAM */ /* 2) copy initialization data from ROM to RAM */
/* 3) call global constructors in C++ */ /* 3) call global constructors in C++ */
/* called from: _Startup, LibInits */ /* called from: _Startup, LibInits */
asm { asm
ZeroOut: {
ZeroOut:
#if defined(__HIWARE_OBJECT_FILE_FORMAT__) && defined(__LARGE__) #if defined(__HIWARE_OBJECT_FILE_FORMAT__) && defined(__LARGE__)
LDX _startupData.pZeroOut:1 ; in the large memory model in the HIWARE format, pZeroOut is a 24 bit pointer LDX _startupData.pZeroOut:1 ;
in the large memory model in the HIWARE format, pZeroOut is a 24 bit pointer
#else #else
LDX _startupData.pZeroOut ; *pZeroOut LDX _startupData.pZeroOut ;
*pZeroOut
#endif #endif
LDY _startupData.nofZeroOuts ; nofZeroOuts LDY _startupData.nofZeroOuts ;
BEQ CopyDown ; if nothing to zero out nofZeroOuts
BEQ CopyDown ;
if nothing to zero out
NextZeroOut: PSHY ; save nofZeroOuts NextZeroOut: PSHY ;
save nofZeroOuts
#if defined(FAR_DATA) #if defined(FAR_DATA)
LDAB 1,X+ ; load page of destination address LDAB 1,X+ ;
LDY 2,X+ ; load offset of destination address load page of destination address
LDY 2,X+ ;
load offset of destination address
#if defined(__HCS12X__) #if defined(__HCS12X__)
STAB __GPAGE_ADR__ STAB __GPAGE_ADR__
#else /* defined(__HCS12X__) */ #else /* defined(__HCS12X__) */
__PIC_JSR(_SET_PAGE) ; sets the page in the correct page register __PIC_JSR(_SET_PAGE) ;
sets the page in the correct page register
#endif /* defined(__HCS12X__) */ #endif /* defined(__HCS12X__) */
#else /* FAR_DATA */ #else /* FAR_DATA */
LDY 2,X+ ; start address and advance *pZeroOut (X = X+4) LDY 2,X+ ;
start address and advance *pZeroOut(X = X+4)
#endif /* FAR_DATA */ #endif /* FAR_DATA */
#if defined(__HCS12X__) && defined(FAR_DATA) #if defined(__HCS12X__) && defined(FAR_DATA)
PSHX PSHX
LDX 0,X ; byte count LDX 0,X ;
byte count
#if defined(__OPTIMIZE_FOR_SIZE__) #if defined(__OPTIMIZE_FOR_SIZE__)
CLRA CLRA
NextWord: GSTAA 1,Y+ ; clear memory byte NextWord:
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ GSTAA 1,Y+ ;
DBNE X, NextWord ; dec byte count clear memory byte
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE X, NextWord ;
dec byte count
#else #else
LDD #0 LDD #0
LSRX LSRX
BEQ LoopClrW1 ; do we copy more than 1 byte? BEQ LoopClrW1 ;
NextWord: GSTD 2,Y+ ; clear memory word do we copy more than 1 byte?
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ NextWord: GSTD 2,Y+ ;
DBNE X, NextWord ; dec word count clear memory word
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE X, NextWord ;
dec word count
LoopClrW1: LoopClrW1:
BCC LastClr ; handle last byte BCC LastClr ;
GSTAA 1,Y+ ; handle last byte handle last byte
GSTAA 1,Y+ ;
handle last byte
LastClr: LastClr:
#endif #endif
PULX PULX
LEAX 2,X LEAX 2,X
#elif defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */ #elif defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */
LDD 2,X+ ; byte count LDD 2,X+ ;
NextWord: CLR 1,Y+ ; clear memory byte byte count
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ NextWord:
DBNE D, NextWord ; dec byte count CLR 1,Y+ ;
clear memory byte
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D, NextWord ;
dec byte count
#else /* __OPTIMIZE_FOR_TIME__ */ #else /* __OPTIMIZE_FOR_TIME__ */
LDD 2,X+ ; byte count LDD 2,X+ ;
LSRD ; /2 and save bit 0 in the carry byte count
BEQ LoopClrW1 ; do we copy more than 1 byte? LSRD ;
PSHX /2 and save bit 0 in the carry
LDX #0 BEQ LoopClrW1 ;
LoopClrW: STX 2,Y+ ; Word-Clear do we copy more than 1 byte?
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ PSHX
DBNE D, LoopClrW LDX #0
PULX LoopClrW: STX 2,Y+ ;
Word-Clear
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D, LoopClrW
PULX
LoopClrW1: LoopClrW1:
BCC LastClr ; handle last byte BCC LastClr ;
CLR 1,Y+ handle last byte
CLR 1,Y+
LastClr: LastClr:
#endif /* __OPTIMIZE_FOR_SIZE__/__OPTIMIZE_FOR_TIME__ */ #endif /* __OPTIMIZE_FOR_SIZE__/__OPTIMIZE_FOR_TIME__ */
PULY ; restore nofZeroOuts PULY ;
DEY ; dec nofZeroOuts restore nofZeroOuts
BNE NextZeroOut DEY ;
dec nofZeroOuts
BNE NextZeroOut
CopyDown: CopyDown:
#if defined(__BANKED_COPY_DOWN) #if defined(__BANKED_COPY_DOWN)
LDAA _startupData.toCopyDownBeg:0 ; get PAGE address of .copy section LDAA _startupData.toCopyDownBeg:0 ;
STAA __PPAGE_ADR__ ; set PPAGE address get PAGE address of .copy section
LDX _startupData.toCopyDownBeg:1 ; load address of copy down desc. STAA __PPAGE_ADR__ ;
set PPAGE address
LDX _startupData.toCopyDownBeg:1 ;
load address of copy down desc.
#elif defined(__ELF_OBJECT_FILE_FORMAT__) #elif defined(__ELF_OBJECT_FILE_FORMAT__)
LDX _startupData.toCopyDownBeg ; load address of copy down desc. LDX _startupData.toCopyDownBeg ;
load address of copy down desc.
#else #else
LDX _startupData.toCopyDownBeg:2 ; load address of copy down desc. LDX _startupData.toCopyDownBeg:2 ;
load address of copy down desc.
#endif #endif
NextBlock: NextBlock:
LDD 2,X+ ; size of init-data -> D LDD 2,X+ ;
BEQ funcInits ; end of copy down desc. size of init-data -> D
BEQ funcInits ;
end of copy down desc.
#ifdef FAR_DATA #ifdef FAR_DATA
PSHD ; save counter PSHD ;
LDAB 1,X+ ; load destination page save counter
LDY 2,X+ ; destination address LDAB 1,X+ ;
load destination page
LDY 2,X+ ;
destination address
#if defined(__HCS12X__) #if defined(__HCS12X__)
STAB __GPAGE_ADR__ STAB __GPAGE_ADR__
#else /* __HCS12X__ */ #else /* __HCS12X__ */
__PIC_JSR(_SET_PAGE) ; sets the destinations page register __PIC_JSR(_SET_PAGE) ;
sets the destinations page register
#endif /* __HCS12X__ */ #endif /* __HCS12X__ */
PULD ; restore counter PULD ;
restore counter
#else /* FAR_DATA */ #else /* FAR_DATA */
LDY 2,X+ ; load destination address LDY 2,X+ ;
load destination address
#endif /* FAR_DATA */ #endif /* FAR_DATA */
#if defined(__HCS12X__) && defined(FAR_DATA) #if defined(__HCS12X__) && defined(FAR_DATA)
#if defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */ #if defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */
Copy: PSHA Copy:
LDAA 1,X+ PSHA
GSTAA 1,Y+ ; move a byte from ROM to the data area LDAA 1,X+
PULA GSTAA 1,Y+ ;
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ move a byte from ROM to the data area
DBNE D,Copy ; copy-byte loop PULA
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D,Copy ;
copy-byte loop
#else #else
LSRD ; /2 and save bit 0 in the carry LSRD ;
BEQ Copy1 ; do we copy more than 1 byte? /2 and save bit 0 in the carry
BEQ Copy1 ;
do we copy more than 1 byte?
Copy: PSHD Copy: PSHD
LDD 2,X+ LDD 2,X+
GSTD 2,Y+ ; move a word from ROM to the data area GSTD 2,Y+ ;
PULD move a word from ROM to the data area
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ PULD
DBNE D,Copy ; copy-word loop __FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D,Copy ;
copy-word loop
Copy1: Copy1:
BCC NextBlock ; handle last byte? BCC NextBlock ;
LDAA 1,X+ handle last byte?
GSTAA 1,Y+ ; move a byte from ROM to the data area LDAA 1,X+
GSTAA 1,Y+ ;
move a byte from ROM to the data area
#endif #endif
#elif defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */ #elif defined(__OPTIMIZE_FOR_SIZE__) /* -os, default */
Copy: MOVB 1,X+,1,Y+ ; move a byte from ROM to the data area Copy:
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ MOVB 1,X+,1,Y+ ;
DBNE D,Copy ; copy-byte loop move a byte from ROM to the data area
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D,Copy ;
copy-byte loop
#else /* __OPTIMIZE_FOR_TIME__ */ #else /* __OPTIMIZE_FOR_TIME__ */
LSRD ; /2 and save bit 0 in the carry LSRD ;
BEQ Copy1 ; do we copy more than 1 byte? /2 and save bit 0 in the carry
Copy: MOVW 2,X+,2,Y+ ; move a word from ROM to the data area BEQ Copy1 ;
__FEED_COP_IN_HLI() ; feed the COP if necessary /*lint !e505 !e522 asm code */ do we copy more than 1 byte?
DBNE D,Copy ; copy-word loop Copy: MOVW 2,X+,2,Y+ ;
move a word from ROM to the data area
__FEED_COP_IN_HLI() ;
feed the COP if necessary /*lint !e505 !e522 asm code */
DBNE D,Copy ;
copy-word loop
Copy1: Copy1:
BCC NextBlock ; handle last byte? BCC NextBlock ;
MOVB 1,X+,1,Y+ ; copy the last byte handle last byte?
MOVB 1,X+,1,Y+ ;
copy the last byte
#endif /* __OPTIMIZE_FOR_SIZE__/__OPTIMIZE_FOR_TIME__ */ #endif /* __OPTIMIZE_FOR_SIZE__/__OPTIMIZE_FOR_TIME__ */
BRA NextBlock BRA NextBlock
funcInits: ; call of global construtors is only in c++ necessary funcInits:
;
call of global construtors is only in c++ necessary
#if defined(__cplusplus) #if defined(__cplusplus)
#if defined(__ELF_OBJECT_FILE_FORMAT__) #if defined(__ELF_OBJECT_FILE_FORMAT__)
#if defined( __BANKED__) || defined(__LARGE__) #if defined( __BANKED__) || defined(__LARGE__)
LDY _startupData.nofInitBodies; load number of cpp. LDY _startupData.nofInitBodies;
BEQ done ; if cppcount == 0, goto done load number of cpp.
LDX _startupData.initBodies ; load address of first module to initialize BEQ done ;
if cppcount == 0, goto done
LDX _startupData.initBodies ;
load address of first module to initialize
nextInit: nextInit:
LEAX 3,X ; increment to next init LEAX 3,X ;
PSHX ; save address of next function to initialize increment to next init
PSHY ; save cpp counter PSHX ;
CALL [-3,X] ; use double indirect call to load the page register also save address of next function to initialize
PULY ; restore cpp counter PSHY ;
PULX ; restore actual address save cpp counter
DEY ; decrement cpp counter CALL [-3,X] ;
BNE nextInit use double indirect call to load the page register also
PULY ;
restore cpp counter
PULX ;
restore actual address
DEY ;
decrement cpp counter
BNE nextInit
#else /* defined( __BANKED__) || defined(__LARGE__) */ #else /* defined( __BANKED__) || defined(__LARGE__) */
LDD _startupData.nofInitBodies; load number of cpp. LDD _startupData.nofInitBodies;
BEQ done ; if cppcount == 0, goto done load number of cpp.
LDX _startupData.initBodies ; load address of first module to initialize BEQ done ;
if cppcount == 0, goto done
LDX _startupData.initBodies ;
load address of first module to initialize
nextInit: nextInit:
LDY 2,X+ ; load address of first module to initialize LDY 2,X+ ;
PSHD load address of first module to initialize
PSHX ; save actual address PSHD
JSR 0,Y ; call initialization function PSHX ;
PULX ; restore actual address save actual address
PULD ; restore cpp counter JSR 0,Y ;
DBNE D, nextInit call initialization function
PULX ;
restore actual address
PULD ;
restore cpp counter
DBNE D, nextInit
#endif /* defined( __BANKED__) || defined(__LARGE__) */ #endif /* defined( __BANKED__) || defined(__LARGE__) */
#else /* __ELF_OBJECT_FILE_FORMAT__ */ #else /* __ELF_OBJECT_FILE_FORMAT__ */
LDX _startupData.mInits ; load address of first module to initialize LDX _startupData.mInits ;
load address of first module to initialize
#if defined( __BANKED__) || defined(__LARGE__) #if defined( __BANKED__) || defined(__LARGE__)
nextInit: LDY 3,X+ ; load address of initialization function nextInit:
BEQ done ; stop when address == 0 LDY 3,X+ ;
; in common environments the offset of a function is never 0, so this test could be avoided load address of initialization function
BEQ done ;
stop when address == 0
;
in common environments the offset of a function is never 0, so this test could be avoided
#ifdef __InitFunctionsMayHaveOffset0__ #ifdef __InitFunctionsMayHaveOffset0__
BRCLR -1,X, done, 0xff ; stop when address == 0 BRCLR -1,X, done, 0xff ;
stop when address == 0
#endif /* __InitFunctionsMayHaveOffset0__ */ #endif /* __InitFunctionsMayHaveOffset0__ */
PSHX ; save address of next function to initialize PSHX ;
CALL [-3,X] ; use double indirect call to load the page register also save address of next function to initialize
CALL [-3,X] ;
use double indirect call to load the page register also
#else /* defined( __BANKED__) || defined(__LARGE__) */ #else /* defined( __BANKED__) || defined(__LARGE__) */
nextInit: nextInit:
LDY 2,X+ ; load address of first module to initialize LDY 2,X+ ;
BEQ done ; stop when address of function == 0 load address of first module to initialize
PSHX ; save actual address BEQ done ;
JSR 0,Y ; call initialization function stop when address of function == 0
PSHX ;
save actual address
JSR 0,Y ;
call initialization function
#endif /* defined( __BANKED__) || defined(__LARGE__) */ #endif /* defined( __BANKED__) || defined(__LARGE__) */
PULX ; restore actual address PULX ;
BRA nextInit restore actual address
BRA nextInit
#endif /* __ELF_OBJECT_FILE_FORMAT__ */ #endif /* __ELF_OBJECT_FILE_FORMAT__ */
done: done:
#endif /* __cplusplus */ #endif /* __cplusplus */
} }
} }
#endif /* __ONLY_INIT_SP */ #endif /* __ONLY_INIT_SP */
@ -330,38 +432,57 @@ static void __far Fini(void)
static void Fini(void) static void Fini(void)
#endif #endif
{ {
/* purpose: 1) call global destructors in C++ */ /* purpose: 1) call global destructors in C++ */
asm { asm
{
#if defined( __BANKED__) || defined(__LARGE__) #if defined( __BANKED__) || defined(__LARGE__)
LDY _startupData.nofFiniBodies; load number of cpp. LDY _startupData.nofFiniBodies;
BEQ done ; if cppcount == 0, goto done load number of cpp.
LDX _startupData.finiBodies ; load address of first module to finalize BEQ done ;
nextInit2: if cppcount == 0, goto done
LEAX 3,X ; increment to next init LDX _startupData.finiBodies ;
PSHX ; save address of next function to finalize load address of first module to finalize
PSHY ; save cpp counter nextInit2:
CALL [-3,X] ; use double indirect call to load the page register also LEAX 3,X ;
PULY ; restore cpp counter increment to next init
PULX ; restore actual address PSHX ;
DEY ; decrement cpp counter save address of next function to finalize
BNE nextInit2 PSHY ;
save cpp counter
CALL [-3,X] ;
use double indirect call to load the page register also
PULY ;
restore cpp counter
PULX ;
restore actual address
DEY ;
decrement cpp counter
BNE nextInit2
#else /* defined( __BANKED__) || defined(__LARGE__) */ #else /* defined( __BANKED__) || defined(__LARGE__) */
LDD _startupData.nofFiniBodies; load number of cpp. LDD _startupData.nofFiniBodies;
BEQ done ; if cppcount == 0, goto done load number of cpp.
LDX _startupData.finiBodies ; load address of first module to finalize BEQ done ;
nextInit2: if cppcount == 0, goto done
LDY 2,X+ ; load address of first module to finalize LDX _startupData.finiBodies ;
PSHD load address of first module to finalize
PSHX ; save actual address nextInit2:
JSR 0,Y ; call finalize function LDY 2,X+ ;
PULX ; restore actual address load address of first module to finalize
PULD ; restore cpp counter PSHD
DBNE D, nextInit2 PSHX ;
save actual address
JSR 0,Y ;
call finalize function
PULX ;
restore actual address
PULD ;
restore cpp counter
DBNE D, nextInit2
#endif /* defined(__BANKED__) || defined(__LARGE__) */ #endif /* defined(__BANKED__) || defined(__LARGE__) */
done:; done:;
} }
} }
#endif #endif
@ -390,35 +511,37 @@ done:;
/* the reset vector must be set so that the application has a defined entry point */ /* the reset vector must be set so that the application has a defined entry point */
#if defined(__SET_RESET_VECTOR__) #if defined(__SET_RESET_VECTOR__)
__EXTERN_C void __interrupt 0 _Startup(void) { __EXTERN_C void __interrupt 0 _Startup(void)
{
#else #else
__EXTERN_C void _Startup(void) { __EXTERN_C void _Startup(void)
{
#endif #endif
/* purpose: 1) initialize the stack /* purpose: 1) initialize the stack
2) initialize the RAM, copy down init data etc (Init) 2) initialize the RAM, copy down init data etc (Init)
3) call main; 3) call main;
parameters: NONE parameters: NONE
called from: _PRESTART-code generated by the Linker called from: _PRESTART-code generated by the Linker
or directly referenced by the reset vector */ or directly referenced by the reset vector */
/* initialize the stack pointer */ /* initialize the stack pointer */
/*lint -e{960} , MISRA 14.3 REQ, macro INIT_SP_FROM_STARTUP_DESC() expands to HLI code */ /*lint -e{960} , MISRA 14.3 REQ, macro INIT_SP_FROM_STARTUP_DESC() expands to HLI code */
/*lint -e{522} , MISRA 14.2 REQ, macro INIT_SP_FROM_STARTUP_DESC() expands to HLI code */ /*lint -e{522} , MISRA 14.2 REQ, macro INIT_SP_FROM_STARTUP_DESC() expands to HLI code */
/* With OpenBLT this function is not directly called at reset, but called by a custom /* With OpenBLT this function is not directly called at reset, but called by a custom
* reset handler. For this to work, the stackpointer must be initialized before this * reset handler. For this to work, the stackpointer must be initialized before this
* function is called, otherwise the RTS instruction won't know where to go. * function is called, otherwise the RTS instruction won't know where to go.
*/ */
/*INIT_SP_FROM_STARTUP_DESC();*/ /* HLI macro definition in hidef.h */ /*INIT_SP_FROM_STARTUP_DESC();*/ /* HLI macro definition in hidef.h */
/* Here user defined code could be inserted, the stack could be used */ /* Here user defined code could be inserted, the stack could be used */
#if defined(_DO_DISABLE_COP_) #if defined(_DO_DISABLE_COP_)
_DISABLE_COP(); _DISABLE_COP();
#endif #endif
/* Example : Set up WinDef Register to allow Paging */ /* Example : Set up WinDef Register to allow Paging */
#ifdef HC812A4 /* HC12 A4 derivative needs WINDEF to configure which pages are available */ #ifdef HC812A4 /* HC12 A4 derivative needs WINDEF to configure which pages are available */
#if (__ENABLE_EPAGE__ != 0 || __ENABLE_DPAGE__ != 0 || __ENABLE_PPAGE__ != 0) #if (__ENABLE_EPAGE__ != 0 || __ENABLE_DPAGE__ != 0 || __ENABLE_PPAGE__ != 0)
WINDEF= __ENABLE_EPAGE__ | __ENABLE_DPAGE__ | __ENABLE_PPAGE__; WINDEF= __ENABLE_EPAGE__ | __ENABLE_DPAGE__ | __ENABLE_PPAGE__;
#endif #endif
#endif #endif
@ -449,23 +572,23 @@ __EXTERN_C void _Startup(void) {
_MMCTL1_SET(_MMCTL1_BIT_ROMON | _MMCTL1_BIT_EROMON | _MMCTL1_BIT_ROMHM); _MMCTL1_SET(_MMCTL1_BIT_ROMON | _MMCTL1_BIT_EROMON | _MMCTL1_BIT_ROMHM);
#else /* RAM */ #else /* RAM */
_MMCTL1_SET(_MMCTL1_BIT_ROMON | _MMCTL1_BIT_EROMON | _MMCTL1_BIT_RAMHM | _MMCTL1_BIT_ROMHM); _MMCTL1_SET(_MMCTL1_BIT_ROMON | _MMCTL1_BIT_EROMON | _MMCTL1_BIT_RAMHM | _MMCTL1_BIT_ROMHM);
#endif #endif
#endif #endif
#ifndef __ONLY_INIT_SP #ifndef __ONLY_INIT_SP
/*lint -e{522} , MISRA 14.2 REQ, function Init() contains HLI only */ /*lint -e{522} , MISRA 14.2 REQ, function Init() contains HLI only */
Init(); /* zero out, copy down, call constructors */ Init(); /* zero out, copy down, call constructors */
#endif #endif
/* Here user defined code could be inserted, all global variables are initilized */ /* Here user defined code could be inserted, all global variables are initilized */
#if defined(_DO_ENABLE_COP_) #if defined(_DO_ENABLE_COP_)
_ENABLE_COP(1); _ENABLE_COP(1);
#endif #endif
/* OpenBLT modifcation: do not call main. instead do this in the reset handler found in /* OpenBLT modifcation: do not call main. instead do this in the reset handler found in
* vectors.c * vectors.c
*/ */
/* main(); */ /* main(); */
} }

268
Target/Source/HCS12/CodeWarrior/vectors.c
View File

File diff suppressed because it is too large Load Diff

83
Target/Source/HCS12/can.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -44,7 +44,7 @@
****************************************************************************************/ ****************************************************************************************/
/** \brief Structure type with the layout of a CAN reception message slot. */ /** \brief Structure type with the layout of a CAN reception message slot. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u idr[4]; /**< identifier register 0..3 */ volatile blt_int8u idr[4]; /**< identifier register 0..3 */
volatile blt_int8u dsr[8]; /**< data segment register 0..7 */ volatile blt_int8u dsr[8]; /**< data segment register 0..7 */
volatile blt_int8u dlr; /**< data length register */ volatile blt_int8u dlr; /**< data length register */
@ -54,7 +54,7 @@ typedef volatile struct
/** \brief Structure type with the layout of a CAN transmit message slot. */ /** \brief Structure type with the layout of a CAN transmit message slot. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u idr[4]; /**< identifier register 0..3 */ volatile blt_int8u idr[4]; /**< identifier register 0..3 */
volatile blt_int8u dsr[8]; /**< data segment register 0..7 */ volatile blt_int8u dsr[8]; /**< data segment register 0..7 */
volatile blt_int8u dlr; /**< data length register */ volatile blt_int8u dlr; /**< data length register */
@ -64,7 +64,7 @@ typedef volatile struct
/** \brief Structure type with the layout of the CAN related control registers. */ /** \brief Structure type with the layout of the CAN related control registers. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u cctl0; /**< control register 0 */ volatile blt_int8u cctl0; /**< control register 0 */
volatile blt_int8u cctl1; /**< control register 1 */ volatile blt_int8u cctl1; /**< control register 1 */
volatile blt_int8u cbtr0; /**< bus timing register 0 */ volatile blt_int8u cbtr0; /**< bus timing register 0 */
@ -187,26 +187,27 @@ static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int8u *btr0, blt_int8u *b
* with a sample point between 68..78%. * with a sample point between 68..78%.
*/ */
static const tCanBusTiming canTiming[] = static const tCanBusTiming canTiming[] =
{ /* TQ | TSEG1 | TSEG2 | SP */ {
/* ------------------------- */ /* TQ | TSEG1 | TSEG2 | SP */
{ 5, 2 }, /* 8 | 5 | 2 | 75% */ /* ------------------------- */
{ 6, 2 }, /* 9 | 6 | 2 | 78% */ { 5, 2 }, /* 8 | 5 | 2 | 75% */
{ 6, 3 }, /* 10 | 6 | 3 | 70% */ { 6, 2 }, /* 9 | 6 | 2 | 78% */
{ 7, 3 }, /* 11 | 7 | 3 | 73% */ { 6, 3 }, /* 10 | 6 | 3 | 70% */
{ 8, 3 }, /* 12 | 8 | 3 | 75% */ { 7, 3 }, /* 11 | 7 | 3 | 73% */
{ 9, 3 }, /* 13 | 9 | 3 | 77% */ { 8, 3 }, /* 12 | 8 | 3 | 75% */
{ 9, 4 }, /* 14 | 9 | 4 | 71% */ { 9, 3 }, /* 13 | 9 | 3 | 77% */
{ 10, 4 }, /* 15 | 10 | 4 | 73% */ { 9, 4 }, /* 14 | 9 | 4 | 71% */
{ 11, 4 }, /* 16 | 11 | 4 | 75% */ { 10, 4 }, /* 15 | 10 | 4 | 73% */
{ 12, 4 }, /* 17 | 12 | 4 | 76% */ { 11, 4 }, /* 16 | 11 | 4 | 75% */
{ 12, 5 }, /* 18 | 12 | 5 | 72% */ { 12, 4 }, /* 17 | 12 | 4 | 76% */
{ 13, 5 }, /* 19 | 13 | 5 | 74% */ { 12, 5 }, /* 18 | 12 | 5 | 72% */
{ 14, 5 }, /* 20 | 14 | 5 | 75% */ { 13, 5 }, /* 19 | 13 | 5 | 74% */
{ 15, 5 }, /* 21 | 15 | 5 | 76% */ { 14, 5 }, /* 20 | 14 | 5 | 75% */
{ 15, 6 }, /* 22 | 15 | 6 | 73% */ { 15, 5 }, /* 21 | 15 | 5 | 76% */
{ 16, 6 }, /* 23 | 16 | 6 | 74% */ { 15, 6 }, /* 22 | 15 | 6 | 73% */
{ 16, 7 }, /* 24 | 16 | 7 | 71% */ { 16, 6 }, /* 23 | 16 | 6 | 74% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */ { 16, 7 }, /* 24 | 16 | 7 | 71% */
{ 16, 8 } /* 25 | 16 | 8 | 68% */
}; };
@ -221,11 +222,11 @@ void CanInit(void)
blt_bool result; blt_bool result;
blt_int32u accept_code; blt_int32u accept_code;
blt_int32u accept_mask; blt_int32u accept_mask;
/* the current implementation supports CAN0..4. throw an assertion error in case a /* the current implementation supports CAN0..4. throw an assertion error in case a
* different CAN channel is configured. * different CAN channel is configured.
*/ */
ASSERT_CT((BOOT_COM_CAN_CHANNEL_INDEX >= 0) && (BOOT_COM_CAN_CHANNEL_INDEX <= 4)); ASSERT_CT((BOOT_COM_CAN_CHANNEL_INDEX >= 0) && (BOOT_COM_CAN_CHANNEL_INDEX <= 4));
/* enter initialization mode. note that this automatically disables CAN interrupts */ /* enter initialization mode. note that this automatically disables CAN interrupts */
CAN->cctl0 = INITRQ_BIT; CAN->cctl0 = INITRQ_BIT;
@ -243,7 +244,7 @@ void CanInit(void)
/* configure baudrate */ /* configure baudrate */
result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &btrRegValues[0], &btrRegValues[1]); result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &btrRegValues[0], &btrRegValues[1]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* configure the baudrate */ /* configure the baudrate */
CAN->cbtr0 = btrRegValues[0]; CAN->cbtr0 = btrRegValues[0];
CAN->cbtr1 = btrRegValues[1]; CAN->cbtr1 = btrRegValues[1];
@ -253,7 +254,7 @@ void CanInit(void)
* identifiers and filter 0 to receive standard 11-bit identifiers. * identifiers and filter 0 to receive standard 11-bit identifiers.
*/ */
CAN->cidac &= ~(IDAM1_BIT | IDAM0_BIT); CAN->cidac &= ~(IDAM1_BIT | IDAM0_BIT);
/* set the acceptance filter code and mask to a value that only BOOT_COM_CAN_RX_MSG_ID /* set the acceptance filter code and mask to a value that only BOOT_COM_CAN_RX_MSG_ID
* is received. * is received.
*/ */
@ -305,7 +306,7 @@ void CanInit(void)
void CanTransmitPacket(blt_int8u *data, blt_int8u len) void CanTransmitPacket(blt_int8u *data, blt_int8u len)
{ {
blt_int8u byte_idx; blt_int8u byte_idx;
/* double check that the transmit slot is really available */ /* double check that the transmit slot is really available */
ASSERT_RT((CAN->ctflg & TXE0_BIT) != 0); ASSERT_RT((CAN->ctflg & TXE0_BIT) != 0);
@ -367,25 +368,25 @@ blt_bool CanReceivePacket(blt_int8u *data)
if ((CAN->crflg & RXF_BIT) == RXF_BIT) if ((CAN->crflg & RXF_BIT) == RXF_BIT)
{ {
/* check IDE-bit to determine if it is a 11-bit or 29-bit identifier */ /* check IDE-bit to determine if it is a 11-bit or 29-bit identifier */
if ((CAN->rxSlot.idr[1] & IDE_BIT) == 0) if ((CAN->rxSlot.idr[1] & IDE_BIT) == 0)
{ {
/* 11-bit id */ /* 11-bit id */
rxMsgId = (*(blt_int16u*)(&CAN->rxSlot.idr[0])) >> 5; rxMsgId = (*(blt_int16u *)(&CAN->rxSlot.idr[0])) >> 5;
} }
else else
{ {
/* 29-bit id */ /* 29-bit id */
rxMsgId = (blt_int32u)(((*(blt_int32u*)(&CAN->rxSlot.idr[0])) & 0x0007ffff) >> 1) | rxMsgId = (blt_int32u)(((*(blt_int32u *)(&CAN->rxSlot.idr[0])) & 0x0007ffff) >> 1) |
(blt_int32u)(((*(blt_int32u*)(&CAN->rxSlot.idr[0])) & 0xffe00000) >> 3); (blt_int32u)(((*(blt_int32u *)(&CAN->rxSlot.idr[0])) & 0xffe00000) >> 3);
} }
/* is this the packet identifier? */ /* is this the packet identifier? */
if (rxMsgId == BOOT_COM_CAN_RX_MSG_ID) if (rxMsgId == BOOT_COM_CAN_RX_MSG_ID)
{ {
result = BLT_TRUE; result = BLT_TRUE;
/* store the dlc */ /* store the dlc */
rxMsgLen = CAN->rxSlot.dlr & 0xf; rxMsgLen = CAN->rxSlot.dlr & 0xf;
/* copy message data */ /* copy message data */
for (byte_idx=0; byte_idx<rxMsgLen; byte_idx++) for (byte_idx=0; byte_idx<rxMsgLen; byte_idx++)
{ {
data[byte_idx] = CAN->rxSlot.dsr[byte_idx]; data[byte_idx] = CAN->rxSlot.dsr[byte_idx];
} }
@ -403,7 +404,7 @@ blt_bool CanReceivePacket(blt_int8u *data)
** \param baud The desired baudrate in kbps. Valid values are 10..1000. ** \param baud The desired baudrate in kbps. Valid values are 10..1000.
** \param btr0 Pointer to where the value for register CANxBTR0 will be stored. ** \param btr0 Pointer to where the value for register CANxBTR0 will be stored.
** \param btr1 Pointer to where the value for register CANxBTR1 will be stored. ** \param btr1 Pointer to where the value for register CANxBTR1 will be stored.
** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE ** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE
** otherwise. ** otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
@ -421,7 +422,7 @@ static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int8u *btr0, blt_int8u *b
prescaler = (blt_int8u)(BOOT_CPU_XTAL_SPEED_KHZ/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1))); prescaler = (blt_int8u)(BOOT_CPU_XTAL_SPEED_KHZ/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)));
/* make sure the prescaler is valid */ /* make sure the prescaler is valid */
if ( (prescaler > 0) && (prescaler <= 64) ) if ((prescaler > 0) && (prescaler <= 64))
{ {
/* store the MSCAN bustiming register values */ /* store the MSCAN bustiming register values */
*btr0 = prescaler - 1; *btr0 = prescaler - 1;

24
Target/Source/HCS12/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -41,7 +41,7 @@
* Macro definitions * Macro definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Start address of the user program. This is the address of the reset vector /** \brief Start address of the user program. This is the address of the reset vector
* in the user program's vector table. * in the user program's vector table.
* \attention This value must be updated if the memory reserved for the bootloader * \attention This value must be updated if the memory reserved for the bootloader
* changes. * changes.
*/ */
@ -64,7 +64,7 @@ extern void reset_handler(void); /* implemented in C startu
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -78,25 +78,25 @@ void CpuStartUserProgram(void)
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* set the address where the bootloader needs to jump to. this is the address of /* set the address where the bootloader needs to jump to. this is the address of
* the last entry in the user program's vector table. this address points to the * the last entry in the user program's vector table. this address points to the
* user program's reset handler. * user program's reset handler.
*/ */
pProgResetHandler = (void(*)(void))(*((blt_int16u*)CPU_USER_PROGRAM_STARTADDR_PTR)); pProgResetHandler = (void(*)(void))(*((blt_int16u *)CPU_USER_PROGRAM_STARTADDR_PTR));
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -106,7 +106,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -119,7 +119,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

208
Target/Source/HCS12/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -59,7 +59,7 @@
/** \brief End address of the bootloader programmable flash. */ /** \brief End address of the bootloader programmable flash. */
#define FLASH_END_ADDRESS (flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ #define FLASH_END_ADDRESS (flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - 1) flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - 1)
/** \brief Size of a flash page on the HCS12. */ /** \brief Size of a flash page on the HCS12. */
#define FLASH_PAGE_SIZE (0x4000) /* flash page size in bytes */ #define FLASH_PAGE_SIZE (0x4000) /* flash page size in bytes */
/** \brief Physical start address of the HCS12 page window. */ /** \brief Physical start address of the HCS12 page window. */
#define FLASH_PAGE_OFFSET (0x8000) /* physical start addr. of pages */ #define FLASH_PAGE_OFFSET (0x8000) /* physical start addr. of pages */
@ -82,7 +82,7 @@
#endif #endif
/** \brief Bitmask for selecting a block with flash pages. */ /** \brief Bitmask for selecting a block with flash pages. */
#define FLASH_BLOCK_SEL_MASK (0x03) #define FLASH_BLOCK_SEL_MASK (0x03)
/**************************************************************************************** /****************************************************************************************
* Register definitions * Register definitions
@ -107,17 +107,17 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Structure type for the flash sectors in the flash layout table. */ /** \brief Structure type for the flash sectors in the flash layout table. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -128,7 +128,7 @@ typedef struct
/** \brief Structure type for the flash control registers. */ /** \brief Structure type for the flash control registers. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u fclkdiv; /**< flash clock devider register */ volatile blt_int8u fclkdiv; /**< flash clock devider register */
volatile blt_int8u fsec; /**< flash security register */ volatile blt_int8u fsec; /**< flash security register */
volatile blt_int8u ftstmod; /**< flash test mode register */ volatile blt_int8u ftstmod; /**< flash test mode register */
@ -136,10 +136,10 @@ typedef volatile struct
volatile blt_int8u fprot; /**< flash protection register */ volatile blt_int8u fprot; /**< flash protection register */
volatile blt_int8u fstat; /**< flash status register */ volatile blt_int8u fstat; /**< flash status register */
volatile blt_int8u fcmd; /**< flash command register */ volatile blt_int8u fcmd; /**< flash command register */
} tFlashRegs; } tFlashRegs;
/** \brief Pointer type to flash command execution function. */ /** \brief Pointer type to flash command execution function. */
typedef void (*pFlashExeCmdFct) (void); typedef void (*pFlashExeCmdFct)(void);
/**************************************************************************************** /****************************************************************************************
@ -147,7 +147,7 @@ typedef void (*pFlashExeCmdFct) (void);
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_int8u FlashGetLinearAddrByte(blt_addr addr); static blt_int8u FlashGetLinearAddrByte(blt_addr addr);
@ -161,12 +161,12 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u data);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* This layout uses linear addresses only. For example, the first address on * This layout uses linear addresses only. For example, the first address on
* page 0x3F is: 0x3F * 0x4000 (page size) = 0xFC000. Note that page 0x3F is * page 0x3F is: 0x3F * 0x4000 (page size) = 0xFC000. Note that page 0x3F is
* where the bootloader also resides and it has been entered as 8 chunks of 2kb. * where the bootloader also resides and it has been entered as 8 chunks of 2kb.
* This allows flexibility for reserving more/less space for the bootloader in * This allows flexibility for reserving more/less space for the bootloader in
* case its size changes in the future. * case its size changes in the future.
*/ */
@ -232,7 +232,7 @@ static const tFlashSector flashLayout[] =
* independent. This allows us to copy it to a ram buffer and execute the code * independent. This allows us to copy it to a ram buffer and execute the code
* from ram. This way the flash driver can be located in flash memory without * from ram. This way the flash driver can be located in flash memory without
* running into problems when erasing/programming the same flash block that * running into problems when erasing/programming the same flash block that
* contains the flash driver. the source code for the machine code is as * contains the flash driver. the source code for the machine code is as
* follows: * follows:
* // launch the command * // launch the command
* FLASH->fstat = CBEIF_BIT; * FLASH->fstat = CBEIF_BIT;
@ -276,46 +276,46 @@ static const blt_int8u flashExecCmd[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
static tFlashBlockInfo bootBlockInfo; static tFlashBlockInfo bootBlockInfo;
/** \brief RAM buffer where the executable flash operation code is copied to. */ /** \brief RAM buffer where the executable flash operation code is copied to. */
static blt_int8u flashExecCmdRam[(sizeof(flashExecCmd)/sizeof(flashExecCmd[0]))]; static blt_int8u flashExecCmdRam[(sizeof(flashExecCmd)/sizeof(flashExecCmd[0]))];
/** \brief Maximum number of supported blocks, which is determined dynamically to have /** \brief Maximum number of supported blocks, which is determined dynamically to have
* code that is independent of the used HCS12 derivative. * code that is independent of the used HCS12 derivative.
*/ */
static blt_int8u flashMaxNrBlocks; static blt_int8u flashMaxNrBlocks;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -332,7 +332,7 @@ void FlashInit(void)
/* init the flash block info structs by setting the address to an invalid address */ /* init the flash block info structs by setting the address to an invalid address */
blockInfo.base_addr = FLASH_INVALID_ADDRESS; blockInfo.base_addr = FLASH_INVALID_ADDRESS;
bootBlockInfo.base_addr = FLASH_INVALID_ADDRESS; bootBlockInfo.base_addr = FLASH_INVALID_ADDRESS;
/* determine how many flash blocks this device supports by first trying to set all /* determine how many flash blocks this device supports by first trying to set all
* all block selection bits. on devices where a specific block is not supported, * all block selection bits. on devices where a specific block is not supported,
* the bit is reserved and will read back 0 afterwards * the bit is reserved and will read back 0 afterwards
@ -340,7 +340,7 @@ void FlashInit(void)
FLASH->fcnfg |= FLASH_BLOCK_SEL_MASK; FLASH->fcnfg |= FLASH_BLOCK_SEL_MASK;
/* read back which ones got set */ /* read back which ones got set */
flashMaxNrBlocks = (FLASH->fcnfg & FLASH_BLOCK_SEL_MASK) + 1; flashMaxNrBlocks = (FLASH->fcnfg & FLASH_BLOCK_SEL_MASK) + 1;
/* set back to default reset value */ /* set back to default reset value */
FLASH->fcnfg &= ~(CBEIE_BIT | CCIE_BIT | KEYACC_BIT | FLASH_BLOCK_SEL_MASK); FLASH->fcnfg &= ~(CBEIE_BIT | CCIE_BIT | KEYACC_BIT | FLASH_BLOCK_SEL_MASK);
/* enable extra prescale factor of 8 when the external crystal is > 12.8 MHz */ /* enable extra prescale factor of 8 when the external crystal is > 12.8 MHz */
@ -358,7 +358,7 @@ void FlashInit(void)
clockFreq = BOOT_CPU_XTAL_SPEED_KHZ / (prescaler * (1 + cnt)); clockFreq = BOOT_CPU_XTAL_SPEED_KHZ / (prescaler * (1 + cnt));
/* is this a valid setting? */ /* is this a valid setting? */
if ( (clockFreq > 150) && (clockFreq < 200) ) if ((clockFreq > 150) && (clockFreq < 200))
{ {
/* configure the setting while taking into account the prescaler */ /* configure the setting while taking into account the prescaler */
if (prescaler == 8) if (prescaler == 8)
@ -375,7 +375,7 @@ void FlashInit(void)
break; break;
} }
} }
/* make sure that a valid clock divider was found */ /* make sure that a valid clock divider was found */
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} /*** end of FlashInit ***/ } /*** end of FlashInit ***/
@ -383,30 +383,30 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
{ {
blt_addr base_addr; blt_addr base_addr;
blt_addr last_block_base_addr; blt_addr last_block_base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS) ) if ((addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* determine the start address of the last block in flash */ /* determine the start address of the last block in flash */
last_block_base_addr = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ last_block_base_addr = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \ flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \
FLASH_WRITE_BLOCK_SIZE; FLASH_WRITE_BLOCK_SIZE;
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
base_addr = (addr/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; base_addr = (addr/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
if (base_addr == last_block_base_addr) if (base_addr == last_block_base_addr)
@ -420,12 +420,12 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
@ -435,25 +435,25 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
blt_int32u total_erase_len; blt_int32u total_erase_len;
blt_int16u block_cnt; blt_int16u block_cnt;
/* determine the base address for the erase operation, by aligning to /* determine the base address for the erase operation, by aligning to
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
erase_base_addr = (addr/FLASH_ERASE_BLOCK_SIZE)*FLASH_ERASE_BLOCK_SIZE; erase_base_addr = (addr/FLASH_ERASE_BLOCK_SIZE)*FLASH_ERASE_BLOCK_SIZE;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (erase_base_addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS) ) if ((erase_base_addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* determine number of bytes to erase from base address */ /* determine number of bytes to erase from base address */
total_erase_len = len + (addr - erase_base_addr); total_erase_len = len + (addr - erase_base_addr);
/* determine the number of blocks to erase */ /* determine the number of blocks to erase */
nr_of_erase_blocks = (blt_int16u) (total_erase_len / FLASH_ERASE_BLOCK_SIZE); nr_of_erase_blocks = (blt_int16u)(total_erase_len / FLASH_ERASE_BLOCK_SIZE);
if ((total_erase_len % FLASH_ERASE_BLOCK_SIZE) > 0) if ((total_erase_len % FLASH_ERASE_BLOCK_SIZE) > 0)
{ {
nr_of_erase_blocks++; nr_of_erase_blocks++;
} }
/* erase all blocks one by one */ /* erase all blocks one by one */
@ -461,17 +461,17 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* erase the block */ /* erase the block */
if (FlashOperate(FLASH_ERASE_SECTOR_CMD, erase_base_addr, 0x55aa) == BLT_FALSE) if (FlashOperate(FLASH_ERASE_SECTOR_CMD, erase_base_addr, 0x55aa) == BLT_FALSE)
{ {
/* error occurred */ /* error occurred */
return BLT_FALSE; return BLT_FALSE;
} }
/* point to the next block's base address */ /* point to the next block's base address */
erase_base_addr += FLASH_ERASE_BLOCK_SIZE; erase_base_addr += FLASH_ERASE_BLOCK_SIZE;
} }
/* erase successful */ /* erase successful */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashErase ***/ } /*** end of FlashErase ***/
@ -483,7 +483,7 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
@ -492,8 +492,8 @@ blt_bool FlashWriteChecksum(void)
blt_int8u byte_counter; blt_int8u byte_counter;
blt_int16u vectab_offset; blt_int16u vectab_offset;
blt_addr checksum_address; blt_addr checksum_address;
/* for the HCS12 target we defined the checksum as the 16-bit Two's complement value /* for the HCS12 target we defined the checksum as the 16-bit Two's complement value
* of the sum of all the 64 interrupt vector addresses, so basically a checksum over * of the sum of all the 64 interrupt vector addresses, so basically a checksum over
* the contents of the entire user program interrupt vector table. * the contents of the entire user program interrupt vector table.
* *
@ -524,8 +524,8 @@ blt_bool FlashWriteChecksum(void)
*/ */
for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++) for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++)
{ {
signature_checksum += bootBlockInfo.data[vectab_offset + byte_counter]; signature_checksum += bootBlockInfo.data[vectab_offset + byte_counter];
} }
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
@ -534,15 +534,15 @@ blt_bool FlashWriteChecksum(void)
checksum_address = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ checksum_address = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \ flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \
FLASH_VECTOR_TABLE_CS_OFFSET; FLASH_VECTOR_TABLE_CS_OFFSET;
return FlashWrite(checksum_address, sizeof(signature_checksum), return FlashWrite(checksum_address, sizeof(signature_checksum),
(blt_int8u*)&signature_checksum); (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
@ -563,11 +563,11 @@ blt_bool FlashVerifyChecksum(void)
/* compute the checksum based on how it was written by FlashWriteChecksum() */ /* compute the checksum based on how it was written by FlashWriteChecksum() */
for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++) for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++)
{ {
signature_checksum += FlashGetLinearAddrByte(vector_table_addr_lin + byte_counter); signature_checksum += FlashGetLinearAddrByte(vector_table_addr_lin + byte_counter);
} }
/* add the 16-bit checksum value */ /* add the 16-bit checksum value */
signature_checksum += (((blt_int16u)FlashGetLinearAddrByte(checksum_addr_lin) << 8) + signature_checksum += (((blt_int16u)FlashGetLinearAddrByte(checksum_addr_lin) << 8) +
FlashGetLinearAddrByte(checksum_addr_lin + 1)); FlashGetLinearAddrByte(checksum_addr_lin + 1));
/* sum should add up to an unsigned 16-bit value of 0 */ /* sum should add up to an unsigned 16-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -582,7 +582,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -597,7 +597,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -606,21 +606,21 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* flash operations complete, so clear the RAM buffer with operation execution code */ /* flash operations complete, so clear the RAM buffer with operation execution code */
for (cnt=0; cnt<(sizeof(flashExecCmd)/sizeof(flashExecCmd[0])); cnt++) for (cnt=0; cnt<(sizeof(flashExecCmd)/sizeof(flashExecCmd[0])); cnt++)
{ {
flashExecCmdRam[cnt] = 0; flashExecCmdRam[cnt] = 0;
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the flash memory available to the user program. ** \brief Obtains the base address of the flash memory available to the user program.
** This is basically the last address in the flashLayout table converted to ** This is basically the last address in the flashLayout table converted to
** the physical address on the last page (0x3f), because this is where the ** the physical address on the last page (0x3f), because this is where the
** address will be in. ** address will be in.
** \return Base address. ** \return Base address.
@ -631,7 +631,7 @@ blt_addr FlashGetUserProgBaseAddress(void)
blt_addr end_address_linear; blt_addr end_address_linear;
blt_addr end_address_physical_page_window; blt_addr end_address_physical_page_window;
blt_addr end_address_physical_page_3f; blt_addr end_address_physical_page_3f;
end_address_linear = FLASH_END_ADDRESS + 1; end_address_linear = FLASH_END_ADDRESS + 1;
end_address_physical_page_window = FlashGetPhysAddr(end_address_linear); end_address_physical_page_window = FlashGetPhysAddr(end_address_linear);
end_address_physical_page_3f = end_address_physical_page_window + FLASH_PAGE_SIZE; end_address_physical_page_3f = end_address_physical_page_window + FLASH_PAGE_SIZE;
@ -640,18 +640,18 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
blt_int8u oldPage; blt_int8u oldPage;
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -662,7 +662,7 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address */ /* set the base address */
block->base_addr = address; block->base_addr = address;
/* backup originally selected page */ /* backup originally selected page */
oldPage = FLASH_PPAGE_REG; oldPage = FLASH_PPAGE_REG;
@ -690,14 +690,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[FLASH_LAST_SECTOR_IDX].sector_start) else if (base_addr == flashLayout[FLASH_LAST_SECTOR_IDX].sector_start)
@ -716,7 +716,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -738,13 +738,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -768,7 +768,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -810,7 +810,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashWriteBlock(tFlashBlockInfo *block) static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
{ {
blt_bool result = BLT_TRUE; blt_bool result = BLT_TRUE;
blt_addr prog_addr; blt_addr prog_addr;
blt_int16u prog_data; blt_int16u prog_data;
@ -826,27 +826,27 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int16u)); word_cnt++) for (word_cnt=0; word_cnt<(FLASH_WRITE_BLOCK_SIZE/sizeof(blt_int16u)); word_cnt++)
{ {
prog_addr = block->base_addr + (word_cnt * sizeof(blt_int16u)); prog_addr = block->base_addr + (word_cnt * sizeof(blt_int16u));
prog_data = *(volatile blt_int16u*)(&block->data[word_cnt * sizeof(blt_int16u)]); prog_data = *(volatile blt_int16u *)(&block->data[word_cnt * sizeof(blt_int16u)]);
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program the word to flash */ /* program the word to flash */
if (FlashOperate(FLASH_PROGRAM_WORD_CMD, prog_addr, prog_data) == BLT_FALSE) if (FlashOperate(FLASH_PROGRAM_WORD_CMD, prog_addr, prog_data) == BLT_FALSE)
{ {
/* error occurred */ /* error occurred */
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
/* verify that the written data is actually there */ /* verify that the written data is actually there */
if (FlashGetLinearAddrByte(prog_addr) != (blt_int8u)(prog_data >> 8)) if (FlashGetLinearAddrByte(prog_addr) != (blt_int8u)(prog_data >> 8))
{ {
/* msb not correctly written */ /* msb not correctly written */
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
if (FlashGetLinearAddrByte(prog_addr+1) != (blt_int8u)(prog_data)) if (FlashGetLinearAddrByte(prog_addr+1) != (blt_int8u)(prog_data))
{ {
/* lsb not correctly written */ /* lsb not correctly written */
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
} }
@ -856,7 +856,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
/************************************************************************************//** /************************************************************************************//**
** \brief Reads the byte value from the linear address. ** \brief Reads the byte value from the linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The byte value located at the linear address. ** \return The byte value located at the linear address.
** **
@ -873,7 +873,7 @@ static blt_int8u FlashGetLinearAddrByte(blt_addr addr)
FLASH_PPAGE_REG = FlashGetPhysPage(addr); FLASH_PPAGE_REG = FlashGetPhysPage(addr);
/* read the byte value from the page address */ /* read the byte value from the page address */
result = *((blt_int8u*)FlashGetPhysAddr(addr)); result = *((blt_int8u *)FlashGetPhysAddr(addr));
/* restore originally selected page */ /* restore originally selected page */
FLASH_PPAGE_REG = oldPage; FLASH_PPAGE_REG = oldPage;
@ -884,7 +884,7 @@ static blt_int8u FlashGetLinearAddrByte(blt_addr addr)
/************************************************************************************//** /************************************************************************************//**
** \brief Extracts the physical flash page number from a linear address. ** \brief Extracts the physical flash page number from a linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The page number. ** \return The page number.
** **
@ -896,8 +896,8 @@ static blt_int8u FlashGetPhysPage(blt_addr addr)
/************************************************************************************//** /************************************************************************************//**
** \brief Extracts the physical address on the flash page number from a ** \brief Extracts the physical address on the flash page number from a
** linear address. ** linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The physical address. ** \return The physical address.
** **
@ -913,14 +913,14 @@ static blt_int16u FlashGetPhysAddr(blt_addr addr)
** stored as location independant machine code in array flashExecCmd[]. ** stored as location independant machine code in array flashExecCmd[].
** The contents of this array are temporarily copied to RAM. This way the ** The contents of this array are temporarily copied to RAM. This way the
** function can be executed from RAM avoiding problem when try to perform ** function can be executed from RAM avoiding problem when try to perform
** a flash operation on the same flash block that this driver is located. ** a flash operation on the same flash block that this driver is located.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
static void FlashExecuteCommand(void) static void FlashExecuteCommand(void)
{ {
/* pointer to command execution function */ /* pointer to command execution function */
pFlashExeCmdFct pExecCommandFct; pFlashExeCmdFct pExecCommandFct;
blt_int8u cnt; blt_int8u cnt;
/* copy code for command execution to ram buffer */ /* copy code for command execution to ram buffer */
@ -930,9 +930,9 @@ static void FlashExecuteCommand(void)
} }
/* init the function pointer */ /* init the function pointer */
pExecCommandFct = (pFlashExeCmdFct) ((void *)flashExecCmdRam); pExecCommandFct = (pFlashExeCmdFct)((void *)flashExecCmdRam);
/* call the command execution function */ /* call the command execution function */
pExecCommandFct(); pExecCommandFct();
} /*** end of FlashExecuteCommand ***/ } /*** end of FlashExecuteCommand ***/
@ -949,16 +949,16 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u data)
blt_bool result; blt_bool result;
blt_int8u oldPage; blt_int8u oldPage;
blt_int8u selPage; blt_int8u selPage;
/* set default result to error */ /* set default result to error */
result = BLT_FALSE; result = BLT_FALSE;
/* backup originally selected page */ /* backup originally selected page */
oldPage = FLASH_PPAGE_REG; oldPage = FLASH_PPAGE_REG;
/* calculate page number */ /* calculate page number */
selPage = FlashGetPhysPage(addr); selPage = FlashGetPhysPage(addr);
/* select correct page */ /* select correct page */
FLASH_PPAGE_REG = selPage; FLASH_PPAGE_REG = selPage;
/* there are always a fixed number of pages per block. to get the block index number /* there are always a fixed number of pages per block. to get the block index number
* we simply divide by this number of pages per block. to one tricky thing is that * we simply divide by this number of pages per block. to one tricky thing is that
* the block number goes from high to low with increasing page numbers so we need to * the block number goes from high to low with increasing page numbers so we need to
@ -968,21 +968,21 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u data)
FLASH->fcnfg |= (~(selPage / FLASH_PAGES_PER_BLOCK)) & FLASH_BLOCK_SEL_MASK; FLASH->fcnfg |= (~(selPage / FLASH_PAGES_PER_BLOCK)) & FLASH_BLOCK_SEL_MASK;
/* clear error flags */ /* clear error flags */
FLASH->fstat = (ACCERR_BIT | PVIOL_BIT); FLASH->fstat = (ACCERR_BIT | PVIOL_BIT);
/* command buffer empty? */ /* command buffer empty? */
if ((FLASH->fstat & CBEIF_BIT) == CBEIF_BIT) if ((FLASH->fstat & CBEIF_BIT) == CBEIF_BIT)
{ {
/* write data value to the physical address to operate on */ /* write data value to the physical address to operate on */
*((blt_int16u*)FlashGetPhysAddr(addr)) = data; *((blt_int16u *)FlashGetPhysAddr(addr)) = data;
/* write the command */ /* write the command */
FLASH->fcmd = cmd; FLASH->fcmd = cmd;
/* launch the actual command */ /* launch the actual command */
FlashExecuteCommand(); FlashExecuteCommand();
/* check error flags */ /* check error flags */
if ((FLASH->fstat & (ACCERR_BIT | PVIOL_BIT)) == 0) if ((FLASH->fstat & (ACCERR_BIT | PVIOL_BIT)) == 0)
{ {
/* operation was successful */ /* operation was successful */
result = BLT_TRUE; result = BLT_TRUE;
} }
} }

6
Target/Source/HCS12/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

226
Target/Source/HCS12/flash_ecc.c
View File

@ -25,11 +25,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -61,7 +61,7 @@
/** \brief End address of the bootloader programmable flash. */ /** \brief End address of the bootloader programmable flash. */
#define FLASH_END_ADDRESS (flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ #define FLASH_END_ADDRESS (flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - 1) flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - 1)
/** \brief Size of a flash page on the HCS12. */ /** \brief Size of a flash page on the HCS12. */
#define FLASH_PAGE_SIZE (0x4000) /* flash page size in bytes */ #define FLASH_PAGE_SIZE (0x4000) /* flash page size in bytes */
/** \brief Physical start address of the HCS12 page window. */ /** \brief Physical start address of the HCS12 page window. */
#define FLASH_PAGE_OFFSET (0x8000) /* physical start addr. of pages */ #define FLASH_PAGE_OFFSET (0x8000) /* physical start addr. of pages */
@ -83,7 +83,7 @@
#define FLASH_ERASE_SECTOR_CMD (0x0A) #define FLASH_ERASE_SECTOR_CMD (0x0A)
/** \brief Program phrase flash command. */ /** \brief Program phrase flash command. */
#define FLASH_PROGRAM_PHRASE_CMD (0x06) #define FLASH_PROGRAM_PHRASE_CMD (0x06)
/**************************************************************************************** /****************************************************************************************
* Register definitions * Register definitions
@ -102,17 +102,17 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Structure type for the flash sectors in the flash layout table. */ /** \brief Structure type for the flash sectors in the flash layout table. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -123,7 +123,7 @@ typedef struct
/** \brief Structure type for the flash control registers. */ /** \brief Structure type for the flash control registers. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u fclkdiv; /**< flash clock devider register */ volatile blt_int8u fclkdiv; /**< flash clock devider register */
volatile blt_int8u fsec; /**< flash security register */ volatile blt_int8u fsec; /**< flash security register */
volatile blt_int8u fccobix; /**< flash CCOB index register */ volatile blt_int8u fccobix; /**< flash CCOB index register */
@ -143,15 +143,15 @@ typedef volatile struct
volatile blt_int8u frsv5; /**< flash reserver register */ volatile blt_int8u frsv5; /**< flash reserver register */
volatile blt_int8u frsv6; /**< flash reserver register */ volatile blt_int8u frsv6; /**< flash reserver register */
volatile blt_int8u frsv7; /**< flash reserver register */ volatile blt_int8u frsv7; /**< flash reserver register */
} tFlashRegs; } tFlashRegs;
/** \brief Pointer type to flash command execution function. */ /** \brief Pointer type to flash command execution function. */
typedef void (*pFlashExeCmdFct) (void); typedef void (*pFlashExeCmdFct)(void);
/** \brief Mapping table for finding the corect flash clock divider prescaler. */ /** \brief Mapping table for finding the corect flash clock divider prescaler. */
typedef struct typedef struct
{ {
blt_int16u sysclock_min; /**< min busclock for this prescaler */ blt_int16u sysclock_min; /**< min busclock for this prescaler */
blt_int16u sysclock_max; /**< max busclock for this prescaler */ blt_int16u sysclock_max; /**< max busclock for this prescaler */
blt_int8u prescaler; /**< prescaler for this busclock range*/ blt_int8u prescaler; /**< prescaler for this busclock range*/
} tFlashPrescalerSysclockMapping; } tFlashPrescalerSysclockMapping;
@ -162,14 +162,14 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_int8u FlashGetGlobalAddrByte(blt_addr addr); static blt_int8u FlashGetGlobalAddrByte(blt_addr addr);
static blt_int8u FlashGetPhysPage(blt_addr addr); static blt_int8u FlashGetPhysPage(blt_addr addr);
static blt_int16u FlashGetPhysAddr(blt_addr addr); static blt_int16u FlashGetPhysAddr(blt_addr addr);
static void FlashExecuteCommand(void); static void FlashExecuteCommand(void);
static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u params[], static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u params[],
blt_int8u param_count); blt_int8u param_count);
@ -177,11 +177,11 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u params[]
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details Also controls what part of the flash memory is reserved for the bootloader. * \details Also controls what part of the flash memory is reserved for the bootloader.
* If the bootloader size changes, the reserved sectors for the bootloader * If the bootloader size changes, the reserved sectors for the bootloader
* might need adjustment to make sure the bootloader doesn't get overwritten. * might need adjustment to make sure the bootloader doesn't get overwritten.
* This layout uses global addresses only. Note that the last part is where the * This layout uses global addresses only. Note that the last part is where the
* bootloader also resides and it has been entered as 8 chunks of 2kb. * bootloader also resides and it has been entered as 8 chunks of 2kb.
* This allows flexibility for reserving more/less space for the bootloader in * This allows flexibility for reserving more/less space for the bootloader in
* case its size changes in the future. * case its size changes in the future.
*/ */
@ -238,7 +238,7 @@ static const tFlashSector flashLayout[] =
/** \brief Lookup table for determining the flash clock divider setting based on the /** \brief Lookup table for determining the flash clock divider setting based on the
* system clock speed. The flash clock must be around 1MHz and is scaled down * system clock speed. The flash clock must be around 1MHz and is scaled down
* from the system clock using a prescaler value. Note that clock speeds in * from the system clock using a prescaler value. Note that clock speeds in
* the table are in kHz. * the table are in kHz.
*/ */
static const tFlashPrescalerSysclockMapping flashFDIVlookup[] = static const tFlashPrescalerSysclockMapping flashFDIVlookup[] =
@ -284,7 +284,7 @@ static const tFlashPrescalerSysclockMapping flashFDIVlookup[] =
* independent. This allows us to copy it to a ram buffer and execute the code * independent. This allows us to copy it to a ram buffer and execute the code
* from ram. This way the flash driver can be located in flash memory without * from ram. This way the flash driver can be located in flash memory without
* running into problems when erasing/programming the same flash block that * running into problems when erasing/programming the same flash block that
* contains the flash driver. the source code for the machine code is as * contains the flash driver. the source code for the machine code is as
* follows: * follows:
* // launch the command * // launch the command
* FLASH->fstat = CCIF_BIT; * FLASH->fstat = CCIF_BIT;
@ -328,41 +328,41 @@ static const blt_int8u flashExecCmd[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
static tFlashBlockInfo bootBlockInfo; static tFlashBlockInfo bootBlockInfo;
/** \brief RAM buffer where the executable flash operation code is copied to. */ /** \brief RAM buffer where the executable flash operation code is copied to. */
static blt_int8u flashExecCmdRam[(sizeof(flashExecCmd)/sizeof(flashExecCmd[0]))]; static blt_int8u flashExecCmdRam[(sizeof(flashExecCmd)/sizeof(flashExecCmd[0]))];
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -370,16 +370,16 @@ void FlashInit(void)
{ {
blt_int8u fdiv_bits = FLASH_FDIV_INVALID; blt_int8u fdiv_bits = FLASH_FDIV_INVALID;
blt_int8u cnt; blt_int8u cnt;
/* init the flash block info structs by setting the address to an invalid address */ /* init the flash block info structs by setting the address to an invalid address */
blockInfo.base_addr = FLASH_INVALID_ADDRESS; blockInfo.base_addr = FLASH_INVALID_ADDRESS;
bootBlockInfo.base_addr = FLASH_INVALID_ADDRESS; bootBlockInfo.base_addr = FLASH_INVALID_ADDRESS;
/* try to find correct flash clock divider setting using the lookup table */ /* try to find correct flash clock divider setting using the lookup table */
for (cnt=0; cnt<(sizeof(flashFDIVlookup)/sizeof(flashFDIVlookup[0])); cnt++) for (cnt=0; cnt<(sizeof(flashFDIVlookup)/sizeof(flashFDIVlookup[0])); cnt++)
{ {
if ( (BOOT_CPU_SYSTEM_SPEED_KHZ > flashFDIVlookup[cnt].sysclock_min) && if ((BOOT_CPU_SYSTEM_SPEED_KHZ > flashFDIVlookup[cnt].sysclock_min) &&
(BOOT_CPU_SYSTEM_SPEED_KHZ <= flashFDIVlookup[cnt].sysclock_max) ) (BOOT_CPU_SYSTEM_SPEED_KHZ <= flashFDIVlookup[cnt].sysclock_max))
{ {
/* matching configuration found in the lookup table so store it */ /* matching configuration found in the lookup table so store it */
fdiv_bits = flashFDIVlookup[cnt].prescaler; fdiv_bits = flashFDIVlookup[cnt].prescaler;
@ -387,12 +387,12 @@ void FlashInit(void)
break; break;
} }
} }
/* make sure that a valid configuration was found */ /* make sure that a valid configuration was found */
ASSERT_RT(fdiv_bits != FLASH_FDIV_INVALID); ASSERT_RT(fdiv_bits != FLASH_FDIV_INVALID);
/* wait until all flash commands are finished */ /* wait until all flash commands are finished */
while((FLASH->fstat & CCIF_BIT) == 0) while ((FLASH->fstat & CCIF_BIT) == 0)
{ {
; ;
} }
@ -403,7 +403,7 @@ void FlashInit(void)
/* double check that the configuration was correctly stored because access to these /* double check that the configuration was correctly stored because access to these
* clock divider bits can be locked. * clock divider bits can be locked.
*/ */
ASSERT_RT((FLASH->fclkdiv & FLASH_FDIV_MASK) == fdiv_bits); ASSERT_RT((FLASH->fclkdiv & FLASH_FDIV_MASK) == fdiv_bits);
/* double check that the flash module registered the clock configuration otherwise /* double check that the flash module registered the clock configuration otherwise
@ -415,30 +415,30 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
{ {
blt_addr base_addr; blt_addr base_addr;
blt_addr last_block_base_addr; blt_addr last_block_base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS) ) if ((addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* determine the start address of the last block in flash */ /* determine the start address of the last block in flash */
last_block_base_addr = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ last_block_base_addr = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \ flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \
FLASH_WRITE_BLOCK_SIZE; FLASH_WRITE_BLOCK_SIZE;
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
base_addr = (addr/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; base_addr = (addr/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
if (base_addr == last_block_base_addr) if (base_addr == last_block_base_addr)
@ -452,12 +452,12 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
@ -467,25 +467,25 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
blt_int32u total_erase_len; blt_int32u total_erase_len;
blt_int16u block_cnt; blt_int16u block_cnt;
/* determine the base address for the erase operation, by aligning to /* determine the base address for the erase operation, by aligning to
* FLASH_ERASE_BLOCK_SIZE. * FLASH_ERASE_BLOCK_SIZE.
*/ */
erase_base_addr = (addr/FLASH_ERASE_BLOCK_SIZE)*FLASH_ERASE_BLOCK_SIZE; erase_base_addr = (addr/FLASH_ERASE_BLOCK_SIZE)*FLASH_ERASE_BLOCK_SIZE;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (erase_base_addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS) ) if ((erase_base_addr < FLASH_START_ADDRESS) || ((addr+len-1) > FLASH_END_ADDRESS))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* determine number of bytes to erase from base address */ /* determine number of bytes to erase from base address */
total_erase_len = len + (addr - erase_base_addr); total_erase_len = len + (addr - erase_base_addr);
/* determine the number of blocks to erase */ /* determine the number of blocks to erase */
nr_of_erase_blocks = (blt_int16u) (total_erase_len / FLASH_ERASE_BLOCK_SIZE); nr_of_erase_blocks = (blt_int16u)(total_erase_len / FLASH_ERASE_BLOCK_SIZE);
if ((total_erase_len % FLASH_ERASE_BLOCK_SIZE) > 0) if ((total_erase_len % FLASH_ERASE_BLOCK_SIZE) > 0)
{ {
nr_of_erase_blocks++; nr_of_erase_blocks++;
} }
/* erase all blocks one by one */ /* erase all blocks one by one */
@ -493,18 +493,18 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* erase the block */ /* erase the block */
if (FlashOperate(FLASH_ERASE_SECTOR_CMD, erase_base_addr, BLT_NULL, 0) == BLT_FALSE) if (FlashOperate(FLASH_ERASE_SECTOR_CMD, erase_base_addr, BLT_NULL, 0) == BLT_FALSE)
{ {
/* error occurred */ /* error occurred */
return BLT_FALSE; return BLT_FALSE;
} }
/* point to the next block's base address */ /* point to the next block's base address */
erase_base_addr += FLASH_ERASE_BLOCK_SIZE; erase_base_addr += FLASH_ERASE_BLOCK_SIZE;
} }
/* erase successful */ /* erase successful */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashErase ***/ } /*** end of FlashErase ***/
@ -516,7 +516,7 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
@ -525,8 +525,8 @@ blt_bool FlashWriteChecksum(void)
blt_int8u byte_counter; blt_int8u byte_counter;
blt_int16u vectab_offset; blt_int16u vectab_offset;
blt_addr checksum_address; blt_addr checksum_address;
/* for the HCS12 target we defined the checksum as the 16-bit Two's complement value /* for the HCS12 target we defined the checksum as the 16-bit Two's complement value
* of the sum of all the 64 interrupt vector addresses, so basically a checksum over * of the sum of all the 64 interrupt vector addresses, so basically a checksum over
* the contents of the entire user program interrupt vector table. * the contents of the entire user program interrupt vector table.
* *
@ -557,8 +557,8 @@ blt_bool FlashWriteChecksum(void)
*/ */
for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++) for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++)
{ {
signature_checksum += bootBlockInfo.data[vectab_offset + byte_counter]; signature_checksum += bootBlockInfo.data[vectab_offset + byte_counter];
} }
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
signature_checksum += 1; /* two's complement */ signature_checksum += 1; /* two's complement */
@ -567,15 +567,15 @@ blt_bool FlashWriteChecksum(void)
checksum_address = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \ checksum_address = flashLayout[FLASH_LAST_SECTOR_IDX].sector_start + \
flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \ flashLayout[FLASH_LAST_SECTOR_IDX].sector_size - \
FLASH_VECTOR_TABLE_CS_OFFSET; FLASH_VECTOR_TABLE_CS_OFFSET;
return FlashWrite(checksum_address, sizeof(signature_checksum), return FlashWrite(checksum_address, sizeof(signature_checksum),
(blt_int8u*)&signature_checksum); (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
@ -596,11 +596,11 @@ blt_bool FlashVerifyChecksum(void)
/* compute the checksum based on how it was written by FlashWriteChecksum() */ /* compute the checksum based on how it was written by FlashWriteChecksum() */
for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++) for (byte_counter=0; byte_counter<FLASH_VECTOR_TABLE_SIZE; byte_counter++)
{ {
signature_checksum += FlashGetGlobalAddrByte(vector_table_addr_glob + byte_counter); signature_checksum += FlashGetGlobalAddrByte(vector_table_addr_glob + byte_counter);
} }
/* add the 16-bit checksum value */ /* add the 16-bit checksum value */
signature_checksum += (((blt_int16u)FlashGetGlobalAddrByte(checksum_addr_glob) << 8) + signature_checksum += (((blt_int16u)FlashGetGlobalAddrByte(checksum_addr_glob) << 8) +
FlashGetGlobalAddrByte(checksum_addr_glob + 1)); FlashGetGlobalAddrByte(checksum_addr_glob + 1));
/* sum should add up to an unsigned 16-bit value of 0 */ /* sum should add up to an unsigned 16-bit value of 0 */
if (signature_checksum == 0) if (signature_checksum == 0)
{ {
@ -615,7 +615,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -630,7 +630,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -639,31 +639,31 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* flash operations complete, so clear the RAM buffer with operation execution code */ /* flash operations complete, so clear the RAM buffer with operation execution code */
for (cnt=0; cnt<(sizeof(flashExecCmd)/sizeof(flashExecCmd[0])); cnt++) for (cnt=0; cnt<(sizeof(flashExecCmd)/sizeof(flashExecCmd[0])); cnt++)
{ {
flashExecCmdRam[cnt] = 0; flashExecCmdRam[cnt] = 0;
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
blt_int8u oldPage; blt_int8u oldPage;
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -674,9 +674,9 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address */ /* set the base address */
block->base_addr = address; block->base_addr = address;
/* backup originally selected page */ /* backup originally selected page */
oldPage = FLASH_PPAGE_REG; oldPage = FLASH_PPAGE_REG;
/* select correct page */ /* select correct page */
@ -703,14 +703,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[FLASH_LAST_SECTOR_IDX].sector_start) else if (base_addr == flashLayout[FLASH_LAST_SECTOR_IDX].sector_start)
@ -729,7 +729,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -751,13 +751,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -781,7 +781,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -823,7 +823,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashWriteBlock(tFlashBlockInfo *block) static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
{ {
blt_bool result = BLT_TRUE; blt_bool result = BLT_TRUE;
blt_bool cmd_result; blt_bool cmd_result;
blt_int16u phrase_cnt; blt_int16u phrase_cnt;
@ -847,17 +847,17 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
{ {
phrase_data[byte_cnt] = block->data[(phrase_cnt * FLASH_PHRASE_SIZE) + byte_cnt]; phrase_data[byte_cnt] = block->data[(phrase_cnt * FLASH_PHRASE_SIZE) + byte_cnt];
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* program the phrase to flash */ /* program the phrase to flash */
cmd_result = FlashOperate(FLASH_PROGRAM_PHRASE_CMD, phrase_addr, cmd_result = FlashOperate(FLASH_PROGRAM_PHRASE_CMD, phrase_addr,
(unsigned short *)phrase_data, 4); (unsigned short *)phrase_data, 4);
if (cmd_result == BLT_FALSE) if (cmd_result == BLT_FALSE)
{ {
/* error occurred */ /* error occurred */
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
@ -867,7 +867,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
if (FlashGetGlobalAddrByte(phrase_addr+byte_cnt) != phrase_data[byte_cnt]) if (FlashGetGlobalAddrByte(phrase_addr+byte_cnt) != phrase_data[byte_cnt])
{ {
/* write verification occurred */ /* write verification occurred */
result = BLT_FALSE; result = BLT_FALSE;
break; break;
} }
} }
@ -879,7 +879,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
/************************************************************************************//** /************************************************************************************//**
** \brief Reads the byte value from the linear address. ** \brief Reads the byte value from the linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The byte value located at the linear address. ** \return The byte value located at the linear address.
** **
@ -896,7 +896,7 @@ static blt_int8u FlashGetGlobalAddrByte(blt_addr addr)
FLASH_PPAGE_REG = FlashGetPhysPage(addr); FLASH_PPAGE_REG = FlashGetPhysPage(addr);
/* read the byte value from the page address */ /* read the byte value from the page address */
result = *((blt_int8u*)FlashGetPhysAddr(addr)); result = *((blt_int8u *)FlashGetPhysAddr(addr));
/* restore originally selected page */ /* restore originally selected page */
FLASH_PPAGE_REG = oldPage; FLASH_PPAGE_REG = oldPage;
@ -907,7 +907,7 @@ static blt_int8u FlashGetGlobalAddrByte(blt_addr addr)
/************************************************************************************//** /************************************************************************************//**
** \brief Extracts the physical flash page number from a linear address. ** \brief Extracts the physical flash page number from a linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The page number. ** \return The page number.
** **
@ -919,8 +919,8 @@ static blt_int8u FlashGetPhysPage(blt_addr addr)
/************************************************************************************//** /************************************************************************************//**
** \brief Extracts the physical address on the flash page number from a ** \brief Extracts the physical address on the flash page number from a
** linear address. ** linear address.
** \param addr Linear address. ** \param addr Linear address.
** \return The physical address. ** \return The physical address.
** **
@ -936,14 +936,14 @@ static blt_int16u FlashGetPhysAddr(blt_addr addr)
** stored as location independant machine code in array flashExecCmd[]. ** stored as location independant machine code in array flashExecCmd[].
** The contents of this array are temporarily copied to RAM. This way the ** The contents of this array are temporarily copied to RAM. This way the
** function can be executed from RAM avoiding problem when try to perform ** function can be executed from RAM avoiding problem when try to perform
** a flash operation on the same flash block that this driver is located on. ** a flash operation on the same flash block that this driver is located on.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
static void FlashExecuteCommand(void) static void FlashExecuteCommand(void)
{ {
/* pointer to command execution function */ /* pointer to command execution function */
pFlashExeCmdFct pExecCommandFct; pFlashExeCmdFct pExecCommandFct;
blt_int8u cnt; blt_int8u cnt;
/* copy code for command execution to ram buffer */ /* copy code for command execution to ram buffer */
@ -953,9 +953,9 @@ static void FlashExecuteCommand(void)
} }
/* init the function pointer */ /* init the function pointer */
pExecCommandFct = (pFlashExeCmdFct) ((void *)flashExecCmdRam); pExecCommandFct = (pFlashExeCmdFct)((void *)flashExecCmdRam);
/* call the command execution function */ /* call the command execution function */
pExecCommandFct(); pExecCommandFct();
} /*** end of FlashExecuteCommand ***/ } /*** end of FlashExecuteCommand ***/
@ -972,23 +972,23 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u params[],
{ {
blt_bool result; blt_bool result;
blt_int8u idx; blt_int8u idx;
/* set default result to error */ /* set default result to error */
result = BLT_FALSE; result = BLT_FALSE;
/* make sure the number of flash parameters is within bounds */ /* make sure the number of flash parameters is within bounds */
ASSERT_RT(param_count <= FLASH_CMD_MAX_PARAMS); ASSERT_RT(param_count <= FLASH_CMD_MAX_PARAMS);
/* it is not expected that flash commands are being executed now, just make sure this /* it is not expected that flash commands are being executed now, just make sure this
* is really the case. * is really the case.
*/ */
if ((FLASH->fstat & CCIF_BIT) == 0) if ((FLASH->fstat & CCIF_BIT) == 0)
{ {
return result; return result;
} }
/* clear possibly pending error flags from the previous command */ /* clear possibly pending error flags from the previous command */
FLASH->fstat = (FPVIOL_BIT | ACCERR_BIT); FLASH->fstat = (FPVIOL_BIT | ACCERR_BIT);
/* write the command and the address to operate on */ /* write the command and the address to operate on */
FLASH->fccobix = 0; FLASH->fccobix = 0;
@ -996,25 +996,25 @@ static blt_bool FlashOperate(blt_int8u cmd, blt_addr addr, blt_int16u params[],
FLASH->fccobix = 1; FLASH->fccobix = 1;
FLASH->fccob = (blt_int16u)addr; FLASH->fccob = (blt_int16u)addr;
/* write command paramaters one by one */ /* write command paramaters one by one */
for (idx=0; idx<param_count; idx++) for (idx=0; idx<param_count; idx++)
{ {
/* select the correct command parameter index */ /* select the correct command parameter index */
FLASH->fccobix = idx + 2; FLASH->fccobix = idx + 2;
/* write the command parameter for this index */ /* write the command parameter for this index */
FLASH->fccob = params[idx]; FLASH->fccob = params[idx];
} }
/* execute the command */ /* execute the command */
FlashExecuteCommand(); FlashExecuteCommand();
/* check the results */ /* check the results */
if ((FLASH->fstat & (ACCERR_BIT | FPVIOL_BIT)) == 0) if ((FLASH->fstat & (ACCERR_BIT | FPVIOL_BIT)) == 0)
{ {
/* operation was successful */ /* operation was successful */
result = BLT_TRUE; result = BLT_TRUE;
} }
return result; return result;
} /*** end of FlashOperate ***/ } /*** end of FlashOperate ***/

22
Target/Source/HCS12/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -92,12 +92,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -133,12 +133,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -175,7 +175,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -187,11 +187,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/HCS12/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

6
Target/Source/HCS12/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

34
Target/Source/HCS12/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -43,7 +43,7 @@
****************************************************************************************/ ****************************************************************************************/
/** \brief Structure type with the layout of the UART related control registers. */ /** \brief Structure type with the layout of the UART related control registers. */
typedef volatile struct typedef volatile struct
{ {
volatile blt_int8u scibdh; /**< baudrate control register [SBR 12..8] */ volatile blt_int8u scibdh; /**< baudrate control register [SBR 12..8] */
volatile blt_int8u scibdl; /**< baudrate control register [SBR 8..0] */ volatile blt_int8u scibdl; /**< baudrate control register [SBR 8..0] */
volatile blt_int8u scicr1; /**< control register 1 */ volatile blt_int8u scicr1; /**< control register 1 */
@ -102,10 +102,10 @@ void UartInit(void)
{ {
blt_int16u baudrate_sbr0_12; blt_int16u baudrate_sbr0_12;
/* the current implementation supports SCI0 and SCI1. throw an assertion error in /* the current implementation supports SCI0 and SCI1. throw an assertion error in
* case a different UART channel is configured. * case a different UART channel is configured.
*/ */
ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) || (BOOT_COM_UART_CHANNEL_INDEX == 1)); ASSERT_CT((BOOT_COM_UART_CHANNEL_INDEX == 0) || (BOOT_COM_UART_CHANNEL_INDEX == 1));
/* reset the SCI subsystem's configuration, which automatically configures it for /* reset the SCI subsystem's configuration, which automatically configures it for
* 8,n,1 communication mode. * 8,n,1 communication mode.
*/ */
@ -114,7 +114,7 @@ void UartInit(void)
UART->scibdh = 0; UART->scibdh = 0;
UART->scibdl = 0; UART->scibdl = 0;
/* configure the baudrate from BOOT_COM_UART_BAUDRATE */ /* configure the baudrate from BOOT_COM_UART_BAUDRATE */
baudrate_sbr0_12 = (BOOT_CPU_SYSTEM_SPEED_KHZ * 1000ul) / 16 / BOOT_COM_UART_BAUDRATE; baudrate_sbr0_12 = (BOOT_CPU_SYSTEM_SPEED_KHZ * 1000ul) / 16 / BOOT_COM_UART_BAUDRATE;
/* baudrate register value cannot be more than 13 bits */ /* baudrate register value cannot be more than 13 bits */
ASSERT_RT((baudrate_sbr0_12 & 0xe000) == 0); ASSERT_RT((baudrate_sbr0_12 & 0xe000) == 0);
/* write first MSB then LSB for the baudrate to latch */ /* write first MSB then LSB for the baudrate to latch */
@ -138,12 +138,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -151,7 +151,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -198,7 +198,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -231,7 +231,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
static blt_bool UartReceiveByte(blt_int8u *data) static blt_bool UartReceiveByte(blt_int8u *data)
{ {
/* check if a new byte was received by means of the RDRF-bit */ /* check if a new byte was received by means of the RDRF-bit */
if((UART->scisr1 & RDRF_BIT) != 0) if ((UART->scisr1 & RDRF_BIT) != 0)
{ {
/* store the received byte */ /* store the received byte */
data[0] = UART->scidrl; data[0] = UART->scidrl;
@ -260,8 +260,8 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit holding register */ /* write byte to transmit holding register */
UART->scidrl = data; UART->scidrl = data;
/* wait for tx holding register to be empty */ /* wait for tx holding register to be empty */
while((UART->scisr1 & TDRE_BIT) == 0) while ((UART->scisr1 & TDRE_BIT) == 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }

18
Target/Source/TRICORE_TC1798/GCC/cpu_comp.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -45,10 +45,10 @@ static void CpuWriteWDTCON0(blt_int32u uwValue);
/************************************************************************************//** /************************************************************************************//**
** \brief This macro clears the EndInit bit, which controls access to system critical ** \brief This macro clears the EndInit bit, which controls access to system critical
** registers. Clearing the EndInit bit unlocks all EndInit protectedd ** registers. Clearing the EndInit bit unlocks all EndInit protectedd
** registers. Modifications of the EndInit bit are monitored by the watchdog ** registers. Modifications of the EndInit bit are monitored by the watchdog
** timer such that after clearing the EndInit, the watchdog timer enters a ** timer such that after clearing the EndInit, the watchdog timer enters a
** defined time-out mode; EndInit must be set again before the time-out ** defined time-out mode; EndInit must be set again before the time-out
** expires. ** expires.
** \return none. ** \return none.
** **
@ -58,7 +58,7 @@ void CpuEnterInitMode(void)
/* request clearing of the EndInit bit */ /* request clearing of the EndInit bit */
CpuWriteWDTCON0(WDT_CON0.reg & ~0x00000001); CpuWriteWDTCON0(WDT_CON0.reg & ~0x00000001);
/* wait for hardware handshake */ /* wait for hardware handshake */
while (WDT_CON0.bits.ENDINIT != 0) while (WDT_CON0.bits.ENDINIT != 0)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
@ -94,16 +94,16 @@ static void CpuWriteWDTCON0(blt_int32u value)
/* set HWPW1 = 1111b */ /* set HWPW1 = 1111b */
dummy |= 0x000000F0; dummy |= 0x000000F0;
/* set HWPW0 = WDTDR */ /* set HWPW0 = WDTDR */
if(WDT_CON1.bits.DR) if (WDT_CON1.bits.DR)
{ {
dummy |= 0x00000008; dummy |= 0x00000008;
} }
else else
{ {
dummy &= ~0x00000008; dummy &= ~0x00000008;
} }
/* set HWPW0 = WDTIR */ /* set HWPW0 = WDTIR */
if(WDT_CON1.bits.IR) if (WDT_CON1.bits.IR)
{ {
dummy |= 0x00000004; dummy |= 0x00000004;
} }

14
Target/Source/TRICORE_TC1798/GCC/cpu_comp.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef CPU_COMP_H #ifndef CPU_COMP_H
@ -36,10 +36,10 @@
/**************************************************************************************** /****************************************************************************************
* Include files * Include files
****************************************************************************************/ ****************************************************************************************/
#include <TC1798.h> #include <TC1798.h>
#include <machine/intrinsics.h> #include <machine/intrinsics.h>
#include <machine/cint.h> #include <machine/cint.h>
#include <sys/types.h> #include <sys/types.h>
/**************************************************************************************** /****************************************************************************************
@ -48,7 +48,7 @@
/** \brief Macro for performing a processor specific desync. This part is located in the /** \brief Macro for performing a processor specific desync. This part is located in the
* compiler specific part because it uses an inline assembly call. * compiler specific part because it uses an inline assembly call.
*/ */
#define CpuSetDSYNC() asm("DSYNC") #define CpuSetDSYNC() asm("DSYNC")
/**************************************************************************************** /****************************************************************************************

26
Target/Source/TRICORE_TC1798/cpu.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -60,39 +60,39 @@ extern void _start(void); /* implemented in crt0-tc1
/************************************************************************************//** /************************************************************************************//**
** \brief Starts the user program, if one is present. In this case this function ** \brief Starts the user program, if one is present. In this case this function
** does not return. ** does not return.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
void CpuStartUserProgram(void) void CpuStartUserProgram(void)
{ {
void (*pProgResetHandler)(void); void (*pProgResetHandler)(void);
/* check if a user program is present by verifying the checksum */ /* check if a user program is present by verifying the checksum */
if (NvmVerifyChecksum() == BLT_FALSE) if (NvmVerifyChecksum() == BLT_FALSE)
{ {
/* not a valid user program so it cannot be started */ /* not a valid user program so it cannot be started */
return; return;
} }
#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) #if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0)
/* invoke callback */ /* invoke callback */
if (CpuUserProgramStartHook() == BLT_FALSE) if (CpuUserProgramStartHook() == BLT_FALSE)
{ {
/* callback requests the user program to not be started */ /* callback requests the user program to not be started */
return; return;
} }
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* release the communication interface */ /* release the communication interface */
ComFree(); ComFree();
#endif #endif
/* reset the timer */ /* reset the timer */
TimerReset(); TimerReset();
/* set the address where the bootloader needs to jump to. the user program entry, /* set the address where the bootloader needs to jump to. the user program entry,
* typically called _start, is expected to be located at the start of the user program * typically called _start, is expected to be located at the start of the user program
* flash. * flash.
*/ */
pProgResetHandler = (void(*)(void))((blt_addr*)CPU_USER_PROGRAM_STARTADDR_PTR); pProgResetHandler = (void(*)(void))((blt_addr *)CPU_USER_PROGRAM_STARTADDR_PTR);
/* start the user program by activating its reset interrupt service routine */ /* start the user program by activating its reset interrupt service routine */
pProgResetHandler(); pProgResetHandler();
} /*** end of CpuStartUserProgram ***/ } /*** end of CpuStartUserProgram ***/
@ -102,7 +102,7 @@ void CpuStartUserProgram(void)
** \brief Copies data from the source to the destination address. ** \brief Copies data from the source to the destination address.
** \param dest Destination address for the data. ** \param dest Destination address for the data.
** \param src Source address of the data. ** \param src Source address of the data.
** \param len length of the data in bytes. ** \param len length of the data in bytes.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -115,7 +115,7 @@ void CpuMemCopy(blt_addr dest, blt_addr src, blt_int16u len)
to = (blt_int8u *)dest; to = (blt_int8u *)dest;
/* copy all bytes from source address to destination address */ /* copy all bytes from source address to destination address */
while(len-- > 0) while (len-- > 0)
{ {
/* store byte value from source to destination */ /* store byte value from source to destination */
*to++ = *from++; *to++ = *from++;

298
Target/Source/TRICORE_TC1798/flash.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -55,7 +55,7 @@
/** \brief The flash driver is setup to operate on the cached PFLASH addresses, whereas /** \brief The flash driver is setup to operate on the cached PFLASH addresses, whereas
* the actual PFLASH commands should operate on non-cached addresses. This * the actual PFLASH commands should operate on non-cached addresses. This
* macro defines the offset between cached (80xxxxxxh) and non-cached * macro defines the offset between cached (80xxxxxxh) and non-cached
* (A0xxxxxxh) addresses. * (A0xxxxxxh) addresses.
*/ */
#define FLASH_NON_CACHED_OFFSET (0x20000000u) #define FLASH_NON_CACHED_OFFSET (0x20000000u)
@ -72,7 +72,7 @@
/** \brief Base address of the PFLASH0 flash status register. */ /** \brief Base address of the PFLASH0 flash status register. */
#define FLASH_PFLASH1_FSR_ADDR (0xF8004010u) #define FLASH_PFLASH1_FSR_ADDR (0xF8004010u)
/** \brief Macro that returns the PFLASHx modules base address, giving any address /** \brief Macro that returns the PFLASHx modules base address, giving any address
* in PFLASH. * in PFLASH.
*/ */
#define FLASH_GET_PFLASH_BASE(addr) ((addr < FLASH_PFLASH1_BASE) ? \ #define FLASH_GET_PFLASH_BASE(addr) ((addr < FLASH_PFLASH1_BASE) ? \
@ -89,7 +89,7 @@
*/ */
#define FLASH_GET_FSR_REG_ADDR(addr) ((addr < FLASH_PFLASH1_BASE) ? \ #define FLASH_GET_FSR_REG_ADDR(addr) ((addr < FLASH_PFLASH1_BASE) ? \
FLASH_PFLASH0_FSR_ADDR : FLASH_PFLASH1_FSR_ADDR) FLASH_PFLASH0_FSR_ADDR : FLASH_PFLASH1_FSR_ADDR)
/** \brief Offset in bytes from the bootblock's base address where the checksum is /** \brief Offset in bytes from the bootblock's base address where the checksum is
* located. * located.
*/ */
@ -109,7 +109,7 @@
* Type definitions * Type definitions
****************************************************************************************/ ****************************************************************************************/
/** \brief Flash sector descriptor type. */ /** \brief Flash sector descriptor type. */
typedef struct typedef struct
{ {
blt_addr sector_start; /**< sector start address */ blt_addr sector_start; /**< sector start address */
blt_int32u sector_size; /**< sector size in bytes */ blt_int32u sector_size; /**< sector size in bytes */
@ -117,10 +117,10 @@ typedef struct
} tFlashSector; } tFlashSector;
/** \brief Structure type for grouping flash block information. /** \brief Structure type for grouping flash block information.
* \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a * \details Programming is done per block of max FLASH_WRITE_BLOCK_SIZE. for this a
* flash block manager is implemented in this driver. this flash block manager * flash block manager is implemented in this driver. this flash block manager
* depends on this flash block info structure. It holds the base address of * depends on this flash block info structure. It holds the base address of
* the flash block and the data that should be programmed into the flash * the flash block and the data that should be programmed into the flash
* block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE. * block. The .base_addr must be a multiple of FLASH_WRITE_BLOCK_SIZE.
*/ */
typedef struct typedef struct
@ -135,7 +135,7 @@ typedef struct
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address); static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address);
static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr); static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_addr);
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len); blt_int8u *data, blt_int32u len);
static blt_bool FlashWriteBlock(tFlashBlockInfo *block); static blt_bool FlashWriteBlock(tFlashBlockInfo *block);
static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector); static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector);
@ -150,10 +150,10 @@ static blt_bool FlashTricoreEraseSector(blt_addr start_addr);
* Local constant declarations * Local constant declarations
****************************************************************************************/ ****************************************************************************************/
/** \brief Array wit the layout of the flash memory. /** \brief Array wit the layout of the flash memory.
* \details The current implementation assumes that the bootloader is in the 2Mbyte * \details The current implementation assumes that the bootloader is in the 2Mbyte
* PFLASH0 and supports flash operations only on the 2Mbyte PFLASH1. The reason * PFLASH0 and supports flash operations only on the 2Mbyte PFLASH1. The reason
* for this is that a flash module cannot be in read mode and command mode at * for this is that a flash module cannot be in read mode and command mode at
* the same time. A future improvement is one where the actual flash command * the same time. A future improvement is one where the actual flash command
* code is copied and run from RAM, to bypass this restriction. * code is copied and run from RAM, to bypass this restriction.
*/ */
static const tFlashSector flashLayout[] = static const tFlashSector flashLayout[] =
@ -185,30 +185,30 @@ static const tFlashSector flashLayout[] =
****************************************************************************************/ ****************************************************************************************/
/** \brief Local variable with information about the flash block that is currently /** \brief Local variable with information about the flash block that is currently
* being operated on. * being operated on.
* \details The smallest amount of flash that can be programmed is * \details The smallest amount of flash that can be programmed is
* FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver * FLASH_WRITE_BLOCK_SIZE. A flash block manager is implemented in this driver
* and stores info in this variable. Whenever new data should be flashed, it * and stores info in this variable. Whenever new data should be flashed, it
* is first added to a RAM buffer, which is part of this variable. Whenever * is first added to a RAM buffer, which is part of this variable. Whenever
* the RAM buffer, which has the size of a flash block, is full or data needs * the RAM buffer, which has the size of a flash block, is full or data needs
* to be written to a different block, the contents of the RAM buffer are * to be written to a different block, the contents of the RAM buffer are
* programmed to flash. The flash block manager requires some software * programmed to flash. The flash block manager requires some software
* overhead, yet results is faster flash programming because data is first * overhead, yet results is faster flash programming because data is first
* harvested, ideally until there is enough to program an entire flash block, * harvested, ideally until there is enough to program an entire flash block,
* before the flash device is actually operated on. * before the flash device is actually operated on.
*/ */
static tFlashBlockInfo blockInfo; static tFlashBlockInfo blockInfo;
/** \brief Local variable with information about the flash boot block. /** \brief Local variable with information about the flash boot block.
* \details The first block of the user program holds the vector table, which on the * \details The first block of the user program holds the vector table, which on the
* STM32 is also the where the checksum is written to. Is it likely that * STM32 is also the where the checksum is written to. Is it likely that
* the vector table is first flashed and then, at the end of the programming * the vector table is first flashed and then, at the end of the programming
* sequence, the checksum. This means that this flash block need to be written * sequence, the checksum. This means that this flash block need to be written
* to twice. Normally this is not a problem with flash memory, as long as you * to twice. Normally this is not a problem with flash memory, as long as you
* write the same values to those bytes that are not supposed to be changed * write the same values to those bytes that are not supposed to be changed
* and the locations where you do write to are still in the erased 0xFF state. * and the locations where you do write to are still in the erased 0xFF state.
* Unfortunately, writing twice to flash this way, does not work reliably on * Unfortunately, writing twice to flash this way, does not work reliably on
* all micros. This is why we need to have an extra block, the bootblock, * all micros. This is why we need to have an extra block, the bootblock,
* placed under the management of the block manager. This way is it possible * placed under the management of the block manager. This way is it possible
* to implement functionality so that the bootblock is only written to once * to implement functionality so that the bootblock is only written to once
* at the end of the programming sequence. * at the end of the programming sequence.
*/ */
@ -216,7 +216,7 @@ static tFlashBlockInfo bootBlockInfo;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the flash driver. ** \brief Initializes the flash driver.
** \return none. ** \return none.
** **
****************************************************************************************/ ****************************************************************************************/
@ -230,12 +230,12 @@ void FlashInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Writes the data to flash through a flash block manager. Note that this ** \brief Writes the data to flash through a flash block manager. Note that this
** function also checks that no data is programmed outside the flash ** function also checks that no data is programmed outside the flash
** memory region, so the bootloader can never be overwritten. ** memory region, so the bootloader can never be overwritten.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \param data Pointer to the data buffer. ** \param data Pointer to the data buffer.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data) blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
@ -243,10 +243,10 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
blt_addr base_addr; blt_addr base_addr;
/* make sure the addresses are within the flash device */ /* make sure the addresses are within the flash device */
if ( (FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \ if ((FlashGetSector(addr) == FLASH_INVALID_SECTOR) || \
(FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR) ) (FlashGetSector(addr+len-1) == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* if this is the bootblock, then let the boot block manager handle it */ /* if this is the bootblock, then let the boot block manager handle it */
@ -262,24 +262,24 @@ blt_bool FlashWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
/************************************************************************************//** /************************************************************************************//**
** \brief Erases the flash memory. Note that this function also checks that no ** \brief Erases the flash memory. Note that this function also checks that no
** data is erased outside the flash memory region, so the bootloader can ** data is erased outside the flash memory region, so the bootloader can
** never be erased. ** never be erased.
** \param addr Start address. ** \param addr Start address.
** \param len Length in bytes. ** \param len Length in bytes.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashErase(blt_addr addr, blt_int32u len) blt_bool FlashErase(blt_addr addr, blt_int32u len)
{ {
blt_int8u first_sector; blt_int8u first_sector;
blt_int8u last_sector; blt_int8u last_sector;
/* obtain the first and last sector number */ /* obtain the first and last sector number */
first_sector = FlashGetSector(addr); first_sector = FlashGetSector(addr);
last_sector = FlashGetSector(addr+len-1); last_sector = FlashGetSector(addr+len-1);
/* check them */ /* check them */
if ( (first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR) ) if ((first_sector == FLASH_INVALID_SECTOR) || (last_sector == FLASH_INVALID_SECTOR))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -294,7 +294,7 @@ blt_bool FlashErase(blt_addr addr, blt_int32u len)
** the checksum, the bootloader can check if the programming session ** the checksum, the bootloader can check if the programming session
** was completed, which indicates that a valid user programming is ** was completed, which indicates that a valid user programming is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashWriteChecksum(void) blt_bool FlashWriteChecksum(void)
@ -304,16 +304,16 @@ blt_bool FlashWriteChecksum(void)
/* for the Tricore TC1798 target, the bootlblock is FLASH_WRITE_BLOCK_SIZE in size. /* for the Tricore TC1798 target, the bootlblock is FLASH_WRITE_BLOCK_SIZE in size.
* the actual 32-bit checksum value in this bootblock is located at: * the actual 32-bit checksum value in this bootblock is located at:
* <bootblock_base_addr> + 4. * <bootblock_base_addr> + 4.
* for this reason the checksum is defined as the one's complement value of the sum * for this reason the checksum is defined as the one's complement value of the sum
* of everything else in the bootblock, so starting at: * of everything else in the bootblock, so starting at:
* <bootblock_base_addr> + 8 and ending at: * <bootblock_base_addr> + 8 and ending at:
* <bootblock_base_addr> + FLASH_WRITE_BLOCK_SIZE - 1; * <bootblock_base_addr> + FLASH_WRITE_BLOCK_SIZE - 1;
* *
* note that the user program need to be modified to reserve 32-bit at * note that the user program need to be modified to reserve 32-bit at
* <bootblock_base_addr> + 4, because the bootload will write the checksum value * <bootblock_base_addr> + 4, because the bootload will write the checksum value
* here. refer to the port specific documentation for additional details. * here. refer to the port specific documentation for additional details.
* *
* keep in mind that this checksum is just used as a user program signature, i.e. as * keep in mind that this checksum is just used as a user program signature, i.e. as
* a flag to figure out if a user program is present or not. the checksum is not * a flag to figure out if a user program is present or not. the checksum is not
* calculated over the full user program size. such a checksum routine is typically * calculated over the full user program size. such a checksum routine is typically
@ -323,35 +323,35 @@ blt_bool FlashWriteChecksum(void)
* You can then implement your own checksum write/verify routines in the hook * You can then implement your own checksum write/verify routines in the hook
* functions NvmWriteChecksumHook() and NvmVerifyChecksumHook(). * functions NvmWriteChecksumHook() and NvmVerifyChecksumHook().
*/ */
/* first check that the bootblock contains valid data. if not, this means the /* first check that the bootblock contains valid data. if not, this means the
* bootblock is not part of the reprogramming this time and therefore no * bootblock is not part of the reprogramming this time and therefore no
* new checksum needs to be written * new checksum needs to be written
*/ */
if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS) if (bootBlockInfo.base_addr == FLASH_INVALID_ADDRESS)
{ {
return BLT_TRUE; return BLT_TRUE;
} }
/* compute the checksum. note that the data in the checksum range is not yet written /* compute the checksum. note that the data in the checksum range is not yet written
* to flash but is present in the bootblock data structure at this point. * to flash but is present in the bootblock data structure at this point.
*/ */
for (wordIdx = 0; wordIdx < FLASH_CS_RANGE_TOTAL_WORDS; wordIdx++) for (wordIdx = 0; wordIdx < FLASH_CS_RANGE_TOTAL_WORDS; wordIdx++)
{ {
signature_checksum += *((blt_int32u*)(&bootBlockInfo.data[(wordIdx*4)+FLASH_CS_RANGE_START_OFFSET])); signature_checksum += *((blt_int32u *)(&bootBlockInfo.data[(wordIdx*4)+FLASH_CS_RANGE_START_OFFSET]));
} }
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
/* write the checksum */ /* write the checksum */
return FlashWrite(flashLayout[0].sector_start+FLASH_CS_OFFSET, return FlashWrite(flashLayout[0].sector_start+FLASH_CS_OFFSET,
sizeof(blt_addr), (blt_int8u*)&signature_checksum); sizeof(blt_addr), (blt_int8u *)&signature_checksum);
} /*** end of FlashWriteChecksum ***/ } /*** end of FlashWriteChecksum ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Verifies the checksum, which indicates that a valid user program is ** \brief Verifies the checksum, which indicates that a valid user program is
** present and can be started. ** present and can be started.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashVerifyChecksum(void) blt_bool FlashVerifyChecksum(void)
@ -363,14 +363,14 @@ blt_bool FlashVerifyChecksum(void)
/* compute the checksum by reading it from flash */ /* compute the checksum by reading it from flash */
for (wordIdx = 0; wordIdx < FLASH_CS_RANGE_TOTAL_WORDS; wordIdx++) for (wordIdx = 0; wordIdx < FLASH_CS_RANGE_TOTAL_WORDS; wordIdx++)
{ {
signature_checksum += *((blt_int32u*)(flashLayout[0].sector_start + (wordIdx*4) + FLASH_CS_RANGE_START_OFFSET)); signature_checksum += *((blt_int32u *)(flashLayout[0].sector_start + (wordIdx*4) + FLASH_CS_RANGE_START_OFFSET));
} }
signature_checksum = ~signature_checksum; /* one's complement */ signature_checksum = ~signature_checksum; /* one's complement */
/* read the checksum value from flash that was writtin by the bootloader at the end /* read the checksum value from flash that was writtin by the bootloader at the end
* of the last firmware update * of the last firmware update
*/ */
signature_checksum_rom = *((blt_int32u*)(flashLayout[0].sector_start + FLASH_CS_OFFSET)); signature_checksum_rom = *((blt_int32u *)(flashLayout[0].sector_start + FLASH_CS_OFFSET));
/* verify that they are both the same */ /* verify that they are both the same */
if (signature_checksum == signature_checksum_rom) if (signature_checksum == signature_checksum_rom)
{ {
@ -385,7 +385,7 @@ blt_bool FlashVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Finalizes the flash driver operations. There could still be data in ** \brief Finalizes the flash driver operations. There could still be data in
** the currently active block that needs to be flashed. ** the currently active block that needs to be flashed.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
blt_bool FlashDone(void) blt_bool FlashDone(void)
@ -398,7 +398,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* check if there is still data waiting to be programmed */ /* check if there is still data waiting to be programmed */
if (blockInfo.base_addr != FLASH_INVALID_ADDRESS) if (blockInfo.base_addr != FLASH_INVALID_ADDRESS)
{ {
@ -407,7 +407,7 @@ blt_bool FlashDone(void)
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* still here so all is okay */ /* still here so all is okay */
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashDone ***/ } /*** end of FlashDone ***/
@ -425,16 +425,16 @@ blt_addr FlashGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Copies data currently in flash to the block->data and sets the ** \brief Copies data currently in flash to the block->data and sets the
** base address. ** base address.
** \param block Pointer to flash block info structure to operate on. ** \param block Pointer to flash block info structure to operate on.
** \param address Base address of the block data. ** \param address Base address of the block data.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address) static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
{ {
/* check address alignment */ /* check address alignment */
if ((address % FLASH_WRITE_BLOCK_SIZE) != 0) if ((address % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
@ -445,8 +445,8 @@ static blt_bool FlashInitBlock(tFlashBlockInfo *block, blt_addr address)
/* block already initialized, so nothing to do */ /* block already initialized, so nothing to do */
return BLT_TRUE; return BLT_TRUE;
} }
/* set the base address and copies the current data from flash */ /* set the base address and copies the current data from flash */
block->base_addr = address; block->base_addr = address;
CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE); CpuMemCopy((blt_addr)block->data, address, FLASH_WRITE_BLOCK_SIZE);
return BLT_TRUE; return BLT_TRUE;
} /*** end of FlashInitBlock ***/ } /*** end of FlashInitBlock ***/
@ -465,14 +465,14 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
{ {
/* check if a switch needs to be made away from the boot block. in this case the boot /* check if a switch needs to be made away from the boot block. in this case the boot
* block shouldn't be written yet, because this is done at the end of the programming * block shouldn't be written yet, because this is done at the end of the programming
* session by FlashDone(), this is right after the checksum was written. * session by FlashDone(), this is right after the checksum was written.
*/ */
if (block == &bootBlockInfo) if (block == &bootBlockInfo)
{ {
/* switch from the boot block to the generic block info structure */ /* switch from the boot block to the generic block info structure */
block = &blockInfo; block = &blockInfo;
} }
/* check if a switch back into the bootblock is needed. in this case the generic block /* check if a switch back into the bootblock is needed. in this case the generic block
* doesn't need to be written here yet. * doesn't need to be written here yet.
*/ */
else if (base_addr == flashLayout[0].sector_start) else if (base_addr == flashLayout[0].sector_start)
@ -491,7 +491,7 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
} }
/* initialize tne new block when necessary */ /* initialize tne new block when necessary */
if (FlashInitBlock(block, base_addr) == BLT_FALSE) if (FlashInitBlock(block, base_addr) == BLT_FALSE)
{ {
return BLT_NULL; return BLT_NULL;
} }
@ -513,13 +513,13 @@ static tFlashBlockInfo *FlashSwitchBlock(tFlashBlockInfo *block, blt_addr base_a
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/
static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address, static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
blt_int8u *data, blt_int32u len) blt_int8u *data, blt_int32u len)
{ {
blt_addr current_base_addr; blt_addr current_base_addr;
blt_int8u *dst; blt_int8u *dst;
blt_int8u *src; blt_int8u *src;
/* determine the current base address */ /* determine the current base address */
current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE; current_base_addr = (address/FLASH_WRITE_BLOCK_SIZE)*FLASH_WRITE_BLOCK_SIZE;
@ -543,7 +543,7 @@ static blt_bool FlashAddToBlock(tFlashBlockInfo *block, blt_addr address,
return BLT_FALSE; return BLT_FALSE;
} }
} }
/* add the data to the current block, but check for block overflow */ /* add the data to the current block, but check for block overflow */
dst = &(block->data[address - block->base_addr]); dst = &(block->data[address - block->base_addr]);
src = data; src = data;
@ -597,7 +597,7 @@ static blt_bool FlashWriteBlock(tFlashBlockInfo *block)
/* the FLASH_WRITE_BLOCK_SIZE is configured to exactly match the size of a page in /* the FLASH_WRITE_BLOCK_SIZE is configured to exactly match the size of a page in
* PFLASH. so here simply need to program one page in PFLASH. * PFLASH. so here simply need to program one page in PFLASH.
*/ */
return FlashTricoreProgramPage(block->base_addr, block->data); return FlashTricoreProgramPage(block->base_addr, block->data);
} /*** end of FlashWriteBlock ***/ } /*** end of FlashWriteBlock ***/
@ -618,8 +618,8 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
if ( (first_sector < flashLayout[0].sector_num) || \ if ((first_sector < flashLayout[0].sector_num) || \
(last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num) ) (last_sector > flashLayout[FLASH_TOTAL_SECTORS-1].sector_num))
{ {
return BLT_FALSE; return BLT_FALSE;
} }
@ -652,16 +652,16 @@ static blt_bool FlashEraseSectors(blt_int8u first_sector, blt_int8u last_sector)
static blt_int8u FlashGetSector(blt_addr address) static blt_int8u FlashGetSector(blt_addr address)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
/* is the address in this sector? */ /* is the address in this sector? */
if ( (address >= flashLayout[sectorIdx].sector_start) && \ if ((address >= flashLayout[sectorIdx].sector_start) && \
(address < (flashLayout[sectorIdx].sector_start + \ (address < (flashLayout[sectorIdx].sector_start + \
flashLayout[sectorIdx].sector_size)) ) flashLayout[sectorIdx].sector_size)))
{ {
/* return the sector number */ /* return the sector number */
return flashLayout[sectorIdx].sector_num; return flashLayout[sectorIdx].sector_num;
@ -681,7 +681,7 @@ static blt_int8u FlashGetSector(blt_addr address)
static blt_addr FlashGetSectorBaseAddr(blt_int8u sector) static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -706,7 +706,7 @@ static blt_addr FlashGetSectorBaseAddr(blt_int8u sector)
static blt_int32u FlashGetSectorSize(blt_int8u sector) static blt_int32u FlashGetSectorSize(blt_int8u sector)
{ {
blt_int8u sectorIdx; blt_int8u sectorIdx;
/* search through the sectors to find the right one */ /* search through the sectors to find the right one */
for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++) for (sectorIdx = 0; sectorIdx < FLASH_TOTAL_SECTORS; sectorIdx++)
{ {
@ -739,7 +739,7 @@ static blt_bool FlashTricoreProgramPage(blt_addr start_addr, blt_int8u *data)
blt_int8u *readPtr; blt_int8u *readPtr;
blt_int32u idx; blt_int32u idx;
FLASHn_FSR_t *pflashFSR; FLASHn_FSR_t *pflashFSR;
/* check address alignment to a page in PFLASH */ /* check address alignment to a page in PFLASH */
if ((start_addr % FLASH_WRITE_BLOCK_SIZE) != 0) if ((start_addr % FLASH_WRITE_BLOCK_SIZE) != 0)
{ {
@ -756,23 +756,23 @@ static blt_bool FlashTricoreProgramPage(blt_addr start_addr, blt_int8u *data)
/* perform DSYNC */ /* perform DSYNC */
CpuSetDSYNC(); CpuSetDSYNC();
/* wait until FSR.xFPAGE = '1' */ /* wait until FSR.xFPAGE = '1' */
while(pflashFSR->bits.PFPAGE != 1) while (pflashFSR->bits.PFPAGE != 1)
{ {
/* fail if FSR.SQER = '1' */ /* fail if FSR.SQER = '1' */
if (pflashFSR->bits.SQER == 1) if (pflashFSR->bits.SQER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* fail if FSR.PROER = '1' */ /* fail if FSR.PROER = '1' */
if (pflashFSR->bits.PROER == 1) if (pflashFSR->bits.PROER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }
/* load FLASH_WRITE_BLOCK_SIZE bytes of program data into the assembly buffer */ /* load FLASH_WRITE_BLOCK_SIZE bytes of program data into the assembly buffer */
dataPtr = (blt_int32u *)data; dataPtr = (blt_int32u *)data;
for (idx = 0; idx <(FLASH_WRITE_BLOCK_SIZE/8u); idx++) for (idx = 0; idx <(FLASH_WRITE_BLOCK_SIZE/8u); idx++)
{ {
/* write first 32-bit value */ /* write first 32-bit value */
@ -790,55 +790,55 @@ static blt_bool FlashTricoreProgramPage(blt_addr start_addr, blt_int8u *data)
/* perform DSYNC */ /* perform DSYNC */
CpuSetDSYNC(); CpuSetDSYNC();
/* wait until FSR.PROG = '1' */ /* wait until FSR.PROG = '1' */
while(pflashFSR->bits.PROG != 1) while (pflashFSR->bits.PROG != 1)
{ {
/* fail if FSR.SQER = '1' */ /* fail if FSR.SQER = '1' */
if (pflashFSR->bits.SQER == 1) if (pflashFSR->bits.SQER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* fail if FSR.PROER = '1' */ /* fail if FSR.PROER = '1' */
if (pflashFSR->bits.PROER == 1) if (pflashFSR->bits.PROER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }
/* wait until FSR.xBUSY = '0' */ /* wait until FSR.xBUSY = '0' */
while(pflashFSR->bits.PBUSY == 1) while (pflashFSR->bits.PBUSY == 1)
{ {
/* check flag FSR.xFOPER for ‘1’ as abort criterion to protect against hardware /* check flag FSR.xFOPER for ‘1’ as abort criterion to protect against hardware
* failures causing BUSY to stay '1' * failures causing BUSY to stay '1'
*/ */
if (pflashFSR->bits.PFOPER == 1) if (pflashFSR->bits.PFOPER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }
/* check FSR.VER flag */ /* check FSR.VER flag */
if (pflashFSR->bits.VER != 0) if (pflashFSR->bits.VER != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* fail if FSR.xFOPER = '1' */ /* fail if FSR.xFOPER = '1' */
if (pflashFSR->bits.PFOPER != 0) if (pflashFSR->bits.PFOPER != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* evaluate FSR.xDBER */ /* evaluate FSR.xDBER */
if(pflashFSR->bits.PFDBER != 0) if (pflashFSR->bits.PFDBER != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* use "clear status" command to clear flags */ /* use "clear status" command to clear flags */
FLASH_WRITE_TO_U32_PTR_BY_ADDR(baseAddr + 0x5554u, 0x000000F5u); FLASH_WRITE_TO_U32_PTR_BY_ADDR(baseAddr + 0x5554u, 0x000000F5u);
/* perform verification by checking the written values. do this on a byte-per-byte /* perform verification by checking the written values. do this on a byte-per-byte
* basis to also check the code for byte swapping mistakes. * basis to also check the code for byte swapping mistakes.
*/ */
readPtr = (blt_int8u *)start_addr; readPtr = (blt_int8u *)start_addr;
for (idx = 0; idx <FLASH_WRITE_BLOCK_SIZE; idx++) for (idx = 0; idx <FLASH_WRITE_BLOCK_SIZE; idx++)
{ {
/* verify 32-bits at a time */ /* verify 32-bits at a time */
@ -869,7 +869,7 @@ static blt_bool FlashTricoreEraseSector(blt_addr start_addr)
blt_int8u sectorNum; blt_int8u sectorNum;
blt_int32u *readPtr; blt_int32u *readPtr;
blt_int32u idx; blt_int32u idx;
/* determine base address of the PFLASH module */ /* determine base address of the PFLASH module */
baseAddr = FLASH_GET_PFLASH_BASE(start_addr); baseAddr = FLASH_GET_PFLASH_BASE(start_addr);
/* set pointer for the PFLASH module's FSR register */ /* set pointer for the PFLASH module's FSR register */
@ -885,49 +885,49 @@ static blt_bool FlashTricoreEraseSector(blt_addr start_addr)
FLASH_WRITE_TO_U32_PTR_BY_ADDR(start_addr, 0x00000030u); FLASH_WRITE_TO_U32_PTR_BY_ADDR(start_addr, 0x00000030u);
/* perform DSYNC */ /* perform DSYNC */
CpuSetDSYNC(); CpuSetDSYNC();
/* wait until FSR.ERASE = '1' */ /* wait until FSR.ERASE = '1' */
while(pflashFSR->bits.ERASE != 1) while (pflashFSR->bits.ERASE != 1)
{ {
/* fail if FSR.SQER = '1' */ /* fail if FSR.SQER = '1' */
if (pflashFSR->bits.SQER == 1) if (pflashFSR->bits.SQER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* fail if FSR.PROER = '1' */ /* fail if FSR.PROER = '1' */
if (pflashFSR->bits.PROER == 1) if (pflashFSR->bits.PROER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }
/* wait until FSR.xBUSY = '0' */ /* wait until FSR.xBUSY = '0' */
while(pflashFSR->bits.PBUSY == 1) while (pflashFSR->bits.PBUSY == 1)
{ {
/* check flag FSR.xFOPER for ‘1’ as abort criterion to protect against hardware /* check flag FSR.xFOPER for ‘1’ as abort criterion to protect against hardware
* failures causing BUSY to stay '1' * failures causing BUSY to stay '1'
*/ */
if (pflashFSR->bits.PFOPER == 1) if (pflashFSR->bits.PFOPER == 1)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* keep the watchdog happy */ /* keep the watchdog happy */
CopService(); CopService();
} }
/* check FSR.VER flag */ /* check FSR.VER flag */
if (pflashFSR->bits.VER != 0) if (pflashFSR->bits.VER != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* fail if FSR.xFOPER = '1' */ /* fail if FSR.xFOPER = '1' */
if (pflashFSR->bits.PFOPER != 0) if (pflashFSR->bits.PFOPER != 0)
{ {
return BLT_FALSE; return BLT_FALSE;
} }
/* use "clear status" command to clear flags */ /* use "clear status" command to clear flags */
FLASH_WRITE_TO_U32_PTR_BY_ADDR(baseAddr + 0x5554u, 0x000000F5u); FLASH_WRITE_TO_U32_PTR_BY_ADDR(baseAddr + 0x5554u, 0x000000F5u);
/* perform erase verification */ /* perform erase verification */
sectorNum = FlashGetSector(start_addr); sectorNum = FlashGetSector(start_addr);
if (sectorNum == FLASH_INVALID_SECTOR) if (sectorNum == FLASH_INVALID_SECTOR)
{ {

6
Target/Source/TRICORE_TC1798/flash.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef FLASH_H #ifndef FLASH_H

22
Target/Source/TRICORE_TC1798/nvm.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -93,12 +93,12 @@ blt_bool NvmWrite(blt_addr addr, blt_int32u len, blt_int8u *data)
* by this driver. * by this driver.
*/ */
result = NvmWriteHook(addr, len, data); result = NvmWriteHook(addr, len, data);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* data was within range of the additionally supported memory and succesfully /* data was within range of the additionally supported memory and succesfully
* programmed, so we are all done. * programmed, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -134,12 +134,12 @@ blt_bool NvmErase(blt_addr addr, blt_int32u len)
* by this driver. * by this driver.
*/ */
result = NvmEraseHook(addr, len); result = NvmEraseHook(addr, len);
/* process the return code */ /* process the return code */
if (result == BLT_NVM_OKAY) if (result == BLT_NVM_OKAY)
{ {
/* address was within range of the additionally supported memory and succesfully /* address was within range of the additionally supported memory and succesfully
* erased, so we are all done. * erased, so we are all done.
*/ */
return BLT_TRUE; return BLT_TRUE;
} }
@ -176,7 +176,7 @@ blt_bool NvmVerifyChecksum(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the base address of the non-volatile memory available to the user ** \brief Obtains the base address of the non-volatile memory available to the user
** program. This is typically that start of the vector table. ** program. This is typically that start of the vector table.
** \return Base address. ** \return Base address.
** **
@ -188,11 +188,11 @@ blt_addr NvmGetUserProgBaseAddress(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Once all erase and programming operations are completed, this ** \brief Once all erase and programming operations are completed, this
** function is called, so at the end of the programming session and ** function is called, so at the end of the programming session and
** right before a software reset is performed. It is used to calculate ** right before a software reset is performed. It is used to calculate
** a checksum and program this into flash. This checksum is later used ** a checksum and program this into flash. This checksum is later used
** to determine if a valid user program is present in flash. ** to determine if a valid user program is present in flash.
** \return BLT_TRUE if successful, BLT_FALSE otherwise. ** \return BLT_TRUE if successful, BLT_FALSE otherwise.
** **
****************************************************************************************/ ****************************************************************************************/

18
Target/Source/TRICORE_TC1798/timer.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -46,7 +46,7 @@
*/ */
static blt_int32u millisecond_counter; static blt_int32u millisecond_counter;
/** \brief Holds the timer tick count for 1 millisecond. */ /** \brief Holds the timer tick count for 1 millisecond. */
static blt_int16u millisecond_ticks; static blt_int16u millisecond_ticks;
@ -58,13 +58,13 @@ static blt_int16u millisecond_ticks;
void TimerInit(void) void TimerInit(void)
{ {
blt_int32u dummy; blt_int32u dummy;
/* reset the timer configuration */ /* reset the timer configuration */
TimerReset(); TimerReset();
/* obtain "E" access rights */ /* obtain "E" access rights */
CpuEnterInitMode(); CpuEnterInitMode();
/* enable the GPT12 timer module */ /* enable the GPT12 timer module */
GPT120_CLC.reg = 0x00000000; GPT120_CLC.reg = 0x00000000;
/* dummy read to avoid pipeline effects */ /* dummy read to avoid pipeline effects */
dummy = GPT120_CLC.reg; dummy = GPT120_CLC.reg;
/* release "E" access rights */ /* release "E" access rights */
@ -80,7 +80,7 @@ void TimerInit(void)
*/ */
GPT120_T3CON.reg = 0x00000845; GPT120_T3CON.reg = 0x00000845;
/* reset the timer 3 register so that counter starts at 0 */ /* reset the timer 3 register so that counter starts at 0 */
GPT120_T3.reg = 0x00000000; GPT120_T3.reg = 0x00000000;
/* calculate the number of timer ticks in 1 millisecond */ /* calculate the number of timer ticks in 1 millisecond */
millisecond_ticks = ((blt_int32u)BOOT_CPU_SYSTEM_SPEED_KHZ / 128); millisecond_ticks = ((blt_int32u)BOOT_CPU_SYSTEM_SPEED_KHZ / 128);
/* reset the millisecond counter value */ /* reset the millisecond counter value */
@ -100,11 +100,11 @@ void TimerReset(void)
/* revert back to timer 3 configuration reset value */ /* revert back to timer 3 configuration reset value */
GPT120_T3CON.reg = 0x00000000; GPT120_T3CON.reg = 0x00000000;
/* revert back to timer 3 reset value */ /* revert back to timer 3 reset value */
GPT120_T3.reg = 0x00000000; GPT120_T3.reg = 0x00000000;
/* obtain "E" access rights */ /* obtain "E" access rights */
CpuEnterInitMode(); CpuEnterInitMode();
/* disable the GPT12 timer module */ /* disable the GPT12 timer module */
GPT120_CLC.reg = 0x00000003; GPT120_CLC.reg = 0x00000003;
/* dummy read to avoid pipeline effects */ /* dummy read to avoid pipeline effects */
dummy = GPT120_CLC.reg; dummy = GPT120_CLC.reg;
/* release "E" access rights */ /* release "E" access rights */

6
Target/Source/TRICORE_TC1798/types.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef TYPES_H #ifndef TYPES_H

94
Target/Source/TRICORE_TC1798/uart.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -44,23 +44,23 @@
****************************************************************************************/ ****************************************************************************************/
typedef struct typedef struct
{ {
blt_int32u reserved0[0x1]; /* 0x0 */ blt_int32u reserved0[0x1]; /* 0x0 */
ASCn_PISEL_t PISEL; /* 0x4 */ ASCn_PISEL_t PISEL; /* 0x4 */
ASCn_ID_t ID; /* 0x8 */ ASCn_ID_t ID; /* 0x8 */
blt_int32u reserved3[0x1]; /* 0xc */ blt_int32u reserved3[0x1]; /* 0xc */
ASCn_CON_t CON; /* 0x10 */ ASCn_CON_t CON; /* 0x10 */
ASCn_BG_t BG; /* 0x14 */ ASCn_BG_t BG; /* 0x14 */
ASCn_FDV_t FDV; /* 0x18 */ ASCn_FDV_t FDV; /* 0x18 */
blt_int32u reserved7[0x1]; /* 0x1c */ blt_int32u reserved7[0x1]; /* 0x1c */
ASCn_TBUF_t TBUF; /* 0x20 */ ASCn_TBUF_t TBUF; /* 0x20 */
ASCn_RBUF_t RBUF; /* 0x24 */ ASCn_RBUF_t RBUF; /* 0x24 */
blt_int32u reserved10[0xa]; /* 0x28 */ blt_int32u reserved10[0xa]; /* 0x28 */
ASCn_WHBCON_t WHBCON; /* 0x50 */ ASCn_WHBCON_t WHBCON; /* 0x50 */
blt_int32u reserved12[0x27]; /* 0x54 */ blt_int32u reserved12[0x27]; /* 0x54 */
ASCn_TSRC_t TSRC; /* 0xf0 */ ASCn_TSRC_t TSRC; /* 0xf0 */
ASCn_RSRC_t RSRC; /* 0xf4 */ ASCn_RSRC_t RSRC; /* 0xf4 */
ASCn_ESRC_t ESRC; /* 0xf8 */ ASCn_ESRC_t ESRC; /* 0xf8 */
ASCn_TBSRC_t TBSRC; /* 0xfc */ ASCn_TBSRC_t TBSRC; /* 0xfc */
} tUartRegs; } tUartRegs;
@ -104,33 +104,33 @@ void UartInit(void)
{ {
blt_int32u frequency, reload_value, fdv, dfreq; blt_int32u frequency, reload_value, fdv, dfreq;
/* Compute system frequency and reload value for ASC */ /* Compute system frequency and reload value for ASC */
frequency = BOOT_CPU_SYSTEM_SPEED_KHZ * 1000; frequency = BOOT_CPU_SYSTEM_SPEED_KHZ * 1000;
/* reload_value = fdv/512 * freq/16/baudrate -1 ==> /* reload_value = fdv/512 * freq/16/baudrate -1 ==>
* reload_value = (512*freq)/(baudrate * 512*16) - 1 * reload_value = (512*freq)/(baudrate * 512*16) - 1
* fdv = (reload_value + 1) * (baudrate*512*16/freq) * fdv = (reload_value + 1) * (baudrate*512*16/freq)
* reload_value = (frequency / 32) / baudrate - 1; * reload_value = (frequency / 32) / baudrate - 1;
*/ */
reload_value = (frequency / ((blt_int32u)BOOT_COM_UART_BAUDRATE * 16)) - 1; reload_value = (frequency / ((blt_int32u)BOOT_COM_UART_BAUDRATE * 16)) - 1;
dfreq = frequency / (16*512); dfreq = frequency / (16*512);
fdv = (reload_value + 1) * (blt_int32u)BOOT_COM_UART_BAUDRATE / dfreq; fdv = (reload_value + 1) * (blt_int32u)BOOT_COM_UART_BAUDRATE / dfreq;
/* enable ASC module */ /* enable ASC module */
CpuEnterInitMode(); CpuEnterInitMode();
ASC0_CLC.bits.RMC = 1; ASC0_CLC.bits.RMC = 1;
ASC0_CLC.bits.DISR = 0; ASC0_CLC.bits.DISR = 0;
CpuLeaveInitMode(); CpuLeaveInitMode();
/* configure the ASC module for 8,n,1 */ /* configure the ASC module for 8,n,1 */
UARTx->CON.reg = 0; UARTx->CON.reg = 0;
UARTx->BG.reg = reload_value; UARTx->BG.reg = reload_value;
UARTx->FDV.reg = fdv; UARTx->FDV.reg = fdv;
UARTx->CON.bits.M = 0x01; UARTx->CON.bits.M = 0x01;
UARTx->CON.bits.R = 1; UARTx->CON.bits.R = 1;
UARTx->CON.bits.REN = 1; UARTx->CON.bits.REN = 1;
UARTx->CON.bits.FDE = 1; UARTx->CON.bits.FDE = 1;
} /*** end of UartInit ***/ } /*** end of UartInit ***/
@ -147,12 +147,12 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
blt_bool result; blt_bool result;
/* verify validity of the len-paramenter */ /* verify validity of the len-paramenter */
ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA); ASSERT_RT(len <= BOOT_COM_UART_TX_MAX_DATA);
/* first transmit the length of the packet */ /* first transmit the length of the packet */
result = UartTransmitByte(len); result = UartTransmitByte(len);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
/* transmit all the packet bytes one-by-one */ /* transmit all the packet bytes one-by-one */
for (data_index = 0; data_index < len; data_index++) for (data_index = 0; data_index < len; data_index++)
{ {
@ -160,7 +160,7 @@ void UartTransmitPacket(blt_int8u *data, blt_int8u len)
CopService(); CopService();
/* write byte */ /* write byte */
result = UartTransmitByte(data[data_index]); result = UartTransmitByte(data[data_index]);
ASSERT_RT(result == BLT_TRUE); ASSERT_RT(result == BLT_TRUE);
} }
} /*** end of UartTransmitPacket ***/ } /*** end of UartTransmitPacket ***/
@ -207,7 +207,7 @@ blt_bool UartReceivePacket(blt_int8u *data)
if (xcpCtoRxLength == xcpCtoReqPacket[0]) if (xcpCtoRxLength == xcpCtoReqPacket[0])
{ {
/* copy the packet data */ /* copy the packet data */
CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength); CpuMemCopy((blt_int32u)data, (blt_int32u)&xcpCtoReqPacket[1], xcpCtoRxLength);
/* done with cto packet reception */ /* done with cto packet reception */
xcpCtoRxInProgress = BLT_FALSE; xcpCtoRxInProgress = BLT_FALSE;
/* packet reception complete */ /* packet reception complete */
@ -249,7 +249,7 @@ static blt_bool UartReceiveByte(blt_int8u *data)
/* reset the reception event flag */ /* reset the reception event flag */
UARTx->RSRC.bits.CLRR = 1; UARTx->RSRC.bits.CLRR = 1;
/* set result to indicate that a new byte was received */ /* set result to indicate that a new byte was received */
result = BLT_TRUE; result = BLT_TRUE;
} }
/* inform caller about the result */ /* inform caller about the result */
@ -270,10 +270,10 @@ static blt_bool UartTransmitByte(blt_int8u data)
/* write byte to transmit buffer register */ /* write byte to transmit buffer register */
UARTx->TBUF.reg = data; UARTx->TBUF.reg = data;
/* wait for transmit buffer register to be empty */ /* wait for transmit buffer register to be empty */
while(UARTx->TBSRC.bits.SRR == 0) while (UARTx->TBSRC.bits.SRR == 0)
{ {
CopService(); CopService();
} }
/* byte transmitted */ /* byte transmitted */
return BLT_TRUE; return BLT_TRUE;
} /*** end of UartTransmitByte ***/ } /*** end of UartTransmitByte ***/

14
Target/Source/assert.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -48,7 +48,7 @@ static volatile blt_int32u assert_failure_line;
/************************************************************************************//** /************************************************************************************//**
** \brief Called when a runtime assertion failed. It stores information about where ** \brief Called when a runtime assertion failed. It stores information about where
** the assertion occurred and halts the software program. ** the assertion occurred and halts the software program.
** \param file Name of the source file where the assertion occurred. ** \param file Name of the source file where the assertion occurred.
** \param line Linenumber in the source file where the assertion occurred. ** \param line Linenumber in the source file where the assertion occurred.
@ -61,10 +61,10 @@ void AssertFailure(blt_char *file, blt_int32u line)
assert_failure_file = file; assert_failure_file = file;
assert_failure_line = line; assert_failure_line = line;
/* hang the software so that it requires a hard reset */ /* hang the software so that it requires a hard reset */
for(;;) for (;;)
{ {
/* keep servicing the watchdog so that this one does not cause a reset */ /* keep servicing the watchdog so that this one does not cause a reset */
CopService(); CopService();
} }
} /*** end of AssertFailure ***/ } /*** end of AssertFailure ***/
#endif /* !NDEBUG */ #endif /* !NDEBUG */

24
Target/Source/assert.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef ASSERT_H #ifndef ASSERT_H
@ -40,15 +40,15 @@
* for runtime assertions. * for runtime assertions.
*/ */
#ifdef NDEBUG #ifdef NDEBUG
#define ASSERT_CT(cond) ((void)0) #define ASSERT_CT(cond) ((void)0)
#define ASSERT_RT(cond) ((void)0) #define ASSERT_RT(cond) ((void)0)
#else #else
#define ASSERT_CONCAT_(a, b) a##b #define ASSERT_CONCAT_(a, b) a##b
#define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b) #define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
/** \brief Macro for assertions that can be performed at compile time. */ /** \brief Macro for assertions that can be performed at compile time. */
#define ASSERT_CT(cond) enum { ASSERT_CONCAT(assert_error_on_line_, __LINE__) = 1/(!!(cond)) } #define ASSERT_CT(cond) enum { ASSERT_CONCAT(assert_error_on_line_, __LINE__) = 1/(!!(cond)) }
/** \brief Macro for assertions that can only be performed at run time. */ /** \brief Macro for assertions that can only be performed at run time. */
#define ASSERT_RT(cond) \ #define ASSERT_RT(cond) \
if (cond) \ if (cond) \
{ ; } \ { ; } \
else \ else \

72
Target/Source/backdoor.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -41,25 +41,25 @@
* Macro definitions * Macro definitions
****************************************************************************************/ ****************************************************************************************/
#if (BOOT_BACKDOOR_HOOKS_ENABLE == 0) #if (BOOT_BACKDOOR_HOOKS_ENABLE == 0)
#ifndef BACKDOOR_ENTRY_TIMEOUT_MS #ifndef BACKDOOR_ENTRY_TIMEOUT_MS
/** \brief Sets the time in milliseconds that the backdoor is open, but allow an /** \brief Sets the time in milliseconds that the backdoor is open, but allow an
* override for this time. note that this time should be at least 2.5 times * override for this time. note that this time should be at least 2.5 times
* as long as the time that is configured in Microboot's XCP settings for the * as long as the time that is configured in Microboot's XCP settings for the
* connect command response. This is the last entry on XCP Timeouts tab. By * connect command response. This is the last entry on XCP Timeouts tab. By
* default the connect command response is configured as 20ms by Microboot, * default the connect command response is configured as 20ms by Microboot,
* except for TCP/IP where it is 300ms due to accomodate for worldwide * except for TCP/IP where it is 300ms due to accomodate for worldwide
* network latency. The default value was chosen safely for compatibility * network latency. The default value was chosen safely for compatibility
* reasons with all supported communication interfaces. It could be made * reasons with all supported communication interfaces. It could be made
* shorter your bootloader. To change this value, simply add the macro * shorter your bootloader. To change this value, simply add the macro
* BACKDOOR_ENTRY_TIMEOUT_MS to blt_conf.h with your desired backdoor open time * BACKDOOR_ENTRY_TIMEOUT_MS to blt_conf.h with your desired backdoor open time
* in milliseconds. * in milliseconds.
*/ */
#if (BOOT_COM_NET_ENABLE == 1) #if (BOOT_COM_NET_ENABLE == 1)
#define BACKDOOR_ENTRY_TIMEOUT_MS (750) #define BACKDOOR_ENTRY_TIMEOUT_MS (750)
#else #else
#define BACKDOOR_ENTRY_TIMEOUT_MS (500) #define BACKDOOR_ENTRY_TIMEOUT_MS (500)
#endif #endif
#endif #endif
#endif #endif
/**************************************************************************************** /****************************************************************************************
@ -92,22 +92,22 @@ void BackDoorInit(void)
#if (BOOT_BACKDOOR_HOOKS_ENABLE > 0) #if (BOOT_BACKDOOR_HOOKS_ENABLE > 0)
/* initialize application's backdoor functionality */ /* initialize application's backdoor functionality */
BackDoorInitHook(); BackDoorInitHook();
/* attempt to start the user program when no backdoor entry is requested */ /* attempt to start the user program when no backdoor entry is requested */
if (BackDoorEntryHook() == BLT_FALSE) if (BackDoorEntryHook() == BLT_FALSE)
{ {
/* this function does not return if a valid user program is present */ /* this function does not return if a valid user program is present */
CpuStartUserProgram(); CpuStartUserProgram();
} }
#if (BOOT_FILE_SYS_ENABLE > 0) #if (BOOT_FILE_SYS_ENABLE > 0)
else else
{ {
/* the backdoor is open so we should check if a update from locally attached storage /* the backdoor is open so we should check if a update from locally attached storage
* is requested and, if so, start it. * is requested and, if so, start it.
*/ */
FileHandleFirmwareUpdateRequest(); FileHandleFirmwareUpdateRequest();
} }
#endif #endif
#else #else
/* open the backdoor after a reset */ /* open the backdoor after a reset */
backdoorOpen = BLT_TRUE; backdoorOpen = BLT_TRUE;
@ -129,26 +129,26 @@ void BackDoorInit(void)
void BackDoorCheck(void) void BackDoorCheck(void)
{ {
#if (BOOT_BACKDOOR_HOOKS_ENABLE == 0) #if (BOOT_BACKDOOR_HOOKS_ENABLE == 0)
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* check if a connection with the host was already established. in this case the /* check if a connection with the host was already established. in this case the
* backdoor stays open anyway, so no need to check if it needs to be closed. * backdoor stays open anyway, so no need to check if it needs to be closed.
*/ */
if (ComIsConnected() == BLT_TRUE) if (ComIsConnected() == BLT_TRUE)
{ {
return; return;
} }
#endif #endif
#if (BOOT_FILE_SYS_ENABLE > 0) #if (BOOT_FILE_SYS_ENABLE > 0)
/* check if the file module is busy, indicating that a firmware update through the /* check if the file module is busy, indicating that a firmware update through the
* locally attached storage is in progress. in this case the backdoor stays open * locally attached storage is in progress. in this case the backdoor stays open
* anyway, so no need to check if it needs to be closed. * anyway, so no need to check if it needs to be closed.
*/ */
if (FileIsIdle() == BLT_FALSE) if (FileIsIdle() == BLT_FALSE)
{ {
return; return;
} }
#endif #endif
/* when the backdoor is still open, check if it's time to close it */ /* when the backdoor is still open, check if it's time to close it */
if (backdoorOpen == BLT_TRUE) if (backdoorOpen == BLT_TRUE)
{ {
@ -157,13 +157,13 @@ void BackDoorCheck(void)
{ {
/* close the backdoor */ /* close the backdoor */
backdoorOpen = BLT_FALSE; backdoorOpen = BLT_FALSE;
#if (BOOT_FILE_SYS_ENABLE > 0) #if (BOOT_FILE_SYS_ENABLE > 0)
/* during the timed backdoor no remote update request was detected. now do one /* during the timed backdoor no remote update request was detected. now do one
* last check to see if a firmware update from locally attached storage is * last check to see if a firmware update from locally attached storage is
* pending. * pending.
*/ */
if (FileHandleFirmwareUpdateRequest() == BLT_FALSE) if (FileHandleFirmwareUpdateRequest() == BLT_FALSE)
#endif #endif
{ {
/* no firmware update requests detected, so attempt to start the user program. /* no firmware update requests detected, so attempt to start the user program.
* this function does not return if a valid user program is present. * this function does not return if a valid user program is present.

6
Target/Source/backdoor.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef BACKDOOR_H #ifndef BACKDOOR_H

26
Target/Source/boot.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -38,7 +38,7 @@
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the bootloader core. ** \brief Initializes the bootloader core.
** \return none ** \return none
** **
****************************************************************************************/ ****************************************************************************************/
@ -50,21 +50,21 @@ void BootInit(void)
TimerInit(); TimerInit();
/* initialize the non-volatile memory driver */ /* initialize the non-volatile memory driver */
NvmInit(); NvmInit();
#if (BOOT_FILE_SYS_ENABLE > 0) #if (BOOT_FILE_SYS_ENABLE > 0)
/* initialize the file system module */ /* initialize the file system module */
FileInit(); FileInit();
#endif #endif
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* initialize the communication module */ /* initialize the communication module */
ComInit(); ComInit();
#endif #endif
/* initialize the backdoor entry */ /* initialize the backdoor entry */
BackDoorInit(); BackDoorInit();
} /*** end of BootInit ***/ } /*** end of BootInit ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Task function of the bootloader core that drives the program. ** \brief Task function of the bootloader core that drives the program.
** \return none ** \return none
** **
****************************************************************************************/ ****************************************************************************************/
@ -74,14 +74,14 @@ void BootTask(void)
CopService(); CopService();
/* update the millisecond timer */ /* update the millisecond timer */
TimerUpdate(); TimerUpdate();
#if (BOOT_FILE_SYS_ENABLE > 0) #if (BOOT_FILE_SYS_ENABLE > 0)
/* call worker task for updating firmware from locally attached file storage */ /* call worker task for updating firmware from locally attached file storage */
FileTask(); FileTask();
#endif /* BOOT_FILE_SYS_ENABLE > 0 */ #endif /* BOOT_FILE_SYS_ENABLE > 0 */
#if (BOOT_COM_ENABLE > 0) #if (BOOT_COM_ENABLE > 0)
/* process possibly pending communication data */ /* process possibly pending communication data */
ComTask(); ComTask();
#endif #endif
/* control the backdoor */ /* control the backdoor */
BackDoorCheck(); BackDoorCheck();
} /*** end of BootTask ***/ } /*** end of BootTask ***/

8
Target/Source/boot.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef BOOT_H #ifndef BOOT_H
@ -48,7 +48,7 @@
* Include files * Include files
****************************************************************************************/ ****************************************************************************************/
/* Note that it is possible to override the standard blt_conf.h configuration header /* Note that it is possible to override the standard blt_conf.h configuration header
* file with a project specific one that is defined in the IDE/makefile. For example, * file with a project specific one that is defined in the IDE/makefile. For example,
* the following define could be configured: PROJ_BLT_CONF_H="my_boot_config.h". This can * the following define could be configured: PROJ_BLT_CONF_H="my_boot_config.h". This can
* be handy if you use the bootloader in several projects with a different configuration, * be handy if you use the bootloader in several projects with a different configuration,
* and enables you to have just one bootloader source base. * and enables you to have just one bootloader source base.

6
Target/Source/can.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef CAN_H #ifndef CAN_H

34
Target/Source/com.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
@ -36,16 +36,16 @@
****************************************************************************************/ ****************************************************************************************/
#include "boot.h" /* bootloader generic header */ #include "boot.h" /* bootloader generic header */
#if (BOOT_COM_CAN_ENABLE > 0) #if (BOOT_COM_CAN_ENABLE > 0)
#include "can.h" /* can driver module */ #include "can.h" /* can driver module */
#endif #endif
#if (BOOT_COM_UART_ENABLE > 0) #if (BOOT_COM_UART_ENABLE > 0)
#include "uart.h" /* uart driver module */ #include "uart.h" /* uart driver module */
#endif #endif
#if (BOOT_COM_USB_ENABLE > 0) #if (BOOT_COM_USB_ENABLE > 0)
#include "usb.h" /* usb driver module */ #include "usb.h" /* usb driver module */
#endif #endif
#if (BOOT_COM_NET_ENABLE > 0) #if (BOOT_COM_NET_ENABLE > 0)
#include "net.h" /* tcp/ip driver module */ #include "net.h" /* tcp/ip driver module */
#endif #endif
@ -58,7 +58,7 @@ static tComInterfaceId comActiveInterface = COM_IF_OTHER;
/************************************************************************************//** /************************************************************************************//**
** \brief Initializes the communication module including the hardware needed for ** \brief Initializes the communication module including the hardware needed for
** the communication. ** the communication.
** \return none ** \return none
** **
@ -95,7 +95,7 @@ void ComInit(void)
/************************************************************************************//** /************************************************************************************//**
** \brief Updates the communication module by checking if new data was received ** \brief Updates the communication module by checking if new data was received
** and submitting the request to process newly received data. ** and submitting the request to process newly received data.
** \return none ** \return none
** **
@ -104,7 +104,7 @@ void ComTask(void)
{ {
/* make xcpCtoReqPacket static for runtime efficiency */ /* make xcpCtoReqPacket static for runtime efficiency */
static blt_int8u xcpCtoReqPacket[BOOT_COM_RX_MAX_DATA]; static blt_int8u xcpCtoReqPacket[BOOT_COM_RX_MAX_DATA];
#if (BOOT_COM_CAN_ENABLE > 0) #if (BOOT_COM_CAN_ENABLE > 0)
if (CanReceivePacket(&xcpCtoReqPacket[0]) == BLT_TRUE) if (CanReceivePacket(&xcpCtoReqPacket[0]) == BLT_TRUE)
{ {
@ -214,7 +214,7 @@ void ComTransmitPacket(blt_int8u *data, blt_int16u len)
blt_int16u ComGetActiveInterfaceMaxRxLen(void) blt_int16u ComGetActiveInterfaceMaxRxLen(void)
{ {
blt_int16u result; blt_int16u result;
/* filter on communication interface identifier */ /* filter on communication interface identifier */
switch (comActiveInterface) switch (comActiveInterface)
{ {
@ -233,18 +233,18 @@ blt_int16u ComGetActiveInterfaceMaxRxLen(void)
case COM_IF_NET: case COM_IF_NET:
result = BOOT_COM_NET_RX_MAX_DATA; result = BOOT_COM_NET_RX_MAX_DATA;
break; break;
default: default:
result = BOOT_COM_RX_MAX_DATA; result = BOOT_COM_RX_MAX_DATA;
break; break;
} }
return result; return result;
} /*** end of ComGetActiveInterfaceMaxRxLen ***/ } /*** end of ComGetActiveInterfaceMaxRxLen ***/
/************************************************************************************//** /************************************************************************************//**
** \brief Obtains the maximum number of bytes that can be transmitted on the ** \brief Obtains the maximum number of bytes that can be transmitted on the
** specified communication interface. ** specified communication interface.
** \return Maximum number of bytes that can be received. ** \return Maximum number of bytes that can be received.
** **
@ -252,7 +252,7 @@ blt_int16u ComGetActiveInterfaceMaxRxLen(void)
blt_int16u ComGetActiveInterfaceMaxTxLen(void) blt_int16u ComGetActiveInterfaceMaxTxLen(void)
{ {
blt_int16u result; blt_int16u result;
/* filter on communication interface identifier */ /* filter on communication interface identifier */
switch (comActiveInterface) switch (comActiveInterface)
{ {
@ -271,12 +271,12 @@ blt_int16u ComGetActiveInterfaceMaxTxLen(void)
case COM_IF_NET: case COM_IF_NET:
result = BOOT_COM_NET_TX_MAX_DATA; result = BOOT_COM_NET_TX_MAX_DATA;
break; break;
default: default:
result = BOOT_COM_TX_MAX_DATA; result = BOOT_COM_TX_MAX_DATA;
break; break;
} }
return result; return result;
} /*** end of ComGetActiveInterfaceMaxTxLen ***/ } /*** end of ComGetActiveInterfaceMaxTxLen ***/

6
Target/Source/com.h
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/
#ifndef COM_H #ifndef COM_H

6
Target/Source/cop.c
View File

@ -23,11 +23,11 @@
* You should have received a copy of the GNU General Public License along with OpenBLT. * You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
* *
* A special exception to the GPL is included to allow you to distribute a combined work * A special exception to the GPL is included to allow you to distribute a combined work
* that includes OpenBLT without being obliged to provide the source code for any * that includes OpenBLT without being obliged to provide the source code for any
* proprietary components. The exception text is included at the bottom of the license * proprietary components. The exception text is included at the bottom of the license
* file <license.html>. * file <license.html>.
* *
* \endinternal * \endinternal
****************************************************************************************/ ****************************************************************************************/

Some files were not shown because too many files have changed in this diff Show More