From c3e4c9a25c2910d2d66d52215b3406b13d5b23d5 Mon Sep 17 00:00:00 2001 From: Yuval Adam Date: Sun, 29 Jun 2014 12:34:32 +0300 Subject: Add more board models --- boards/dk-tm4c129x/usb_stick_update/Makefile | 87 ++ .../usb_stick_update/ccs/.ccsimportspec | 10 + .../dk-tm4c129x/usb_stick_update/ccs/.ccsproject | 10 + boards/dk-tm4c129x/usb_stick_update/ccs/.cproject | 182 ++++ boards/dk-tm4c129x/usb_stick_update/ccs/.project | 55 ++ .../ccs/.settings/org.eclipse.cdt.codan.core.prefs | 3 + .../ccs/Debug/usb_stick_update.bin | Bin 0 -> 17008 bytes .../ccs/Debug/usb_stick_update.out | Bin 0 -> 420525 bytes .../usb_stick_update/ccs/macros.ini_initial | 1 + .../usb_stick_update/ccs/target_config.ccxml | 13 + .../ewarm/Exe/usb_stick_update.bin | Bin 0 -> 15476 bytes .../ewarm/Exe/usb_stick_update.out | Bin 0 -> 322876 bytes .../usb_stick_update/gcc/usb_stick_update.axf | Bin 0 -> 79550 bytes .../usb_stick_update/gcc/usb_stick_update.bin | Bin 0 -> 16974 bytes boards/dk-tm4c129x/usb_stick_update/readme.txt | 49 ++ .../usb_stick_update/rvmdk/usb_stick_update.axf | Bin 0 -> 228224 bytes .../usb_stick_update/rvmdk/usb_stick_update.bin | Bin 0 -> 17976 bytes boards/dk-tm4c129x/usb_stick_update/simple_fs.c | 865 +++++++++++++++++++ boards/dk-tm4c129x/usb_stick_update/simple_fs.h | 105 +++ boards/dk-tm4c129x/usb_stick_update/startup_ccs.c | 276 ++++++ .../dk-tm4c129x/usb_stick_update/startup_ewarm.c | 307 +++++++ boards/dk-tm4c129x/usb_stick_update/startup_gcc.c | 323 +++++++ .../dk-tm4c129x/usb_stick_update/startup_rvmdk.S | 332 ++++++++ .../usb_stick_update/usb_stick_update.c | 942 +++++++++++++++++++++ .../usb_stick_update/usb_stick_update.ewd | 614 ++++++++++++++ .../usb_stick_update/usb_stick_update.ewp | 792 +++++++++++++++++ .../usb_stick_update/usb_stick_update.icf | 78 ++ .../usb_stick_update/usb_stick_update.ld | 57 ++ .../usb_stick_update/usb_stick_update.sct | 47 + .../usb_stick_update/usb_stick_update.uvopt | 317 +++++++ .../usb_stick_update/usb_stick_update.uvproj | 434 ++++++++++ .../usb_stick_update/usb_stick_update_ccs.cmd | 70 ++ 32 files changed, 5969 insertions(+) create mode 100644 boards/dk-tm4c129x/usb_stick_update/Makefile create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/.ccsimportspec create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/.ccsproject create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/.cproject create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/.project create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/.settings/org.eclipse.cdt.codan.core.prefs create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.bin create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.out create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/macros.ini_initial create mode 100644 boards/dk-tm4c129x/usb_stick_update/ccs/target_config.ccxml create mode 100644 boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.bin create mode 100644 boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.out create mode 100644 boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.axf create mode 100644 boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.bin create mode 100644 boards/dk-tm4c129x/usb_stick_update/readme.txt create mode 100644 boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.axf create mode 100644 boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.bin create mode 100644 boards/dk-tm4c129x/usb_stick_update/simple_fs.c create mode 100644 boards/dk-tm4c129x/usb_stick_update/simple_fs.h create mode 100644 boards/dk-tm4c129x/usb_stick_update/startup_ccs.c create mode 100644 boards/dk-tm4c129x/usb_stick_update/startup_ewarm.c create mode 100644 boards/dk-tm4c129x/usb_stick_update/startup_gcc.c create mode 100644 boards/dk-tm4c129x/usb_stick_update/startup_rvmdk.S create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.c create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewd create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewp create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.icf create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ld create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.sct create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvopt create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvproj create mode 100644 boards/dk-tm4c129x/usb_stick_update/usb_stick_update_ccs.cmd (limited to 'boards/dk-tm4c129x/usb_stick_update') diff --git a/boards/dk-tm4c129x/usb_stick_update/Makefile b/boards/dk-tm4c129x/usb_stick_update/Makefile new file mode 100644 index 0000000..b1aed62 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/Makefile @@ -0,0 +1,87 @@ +#****************************************************************************** +# +# Makefile - Rules for building the USB memory stick updater example. +# +# Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +# Software License Agreement +# +# Texas Instruments (TI) is supplying this software for use solely and +# exclusively on TI's microcontroller products. The software is owned by +# TI and/or its suppliers, and is protected under applicable copyright +# laws. You may not combine this software with "viral" open-source +# software in order to form a larger program. +# +# THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +# NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +# NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +# CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +# DAMAGES, FOR ANY REASON WHATSOEVER. +# +# This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +# +#****************************************************************************** + +# +# Defines the part type that this project uses. +# +PART=TM4C129XNCZAD + +# +# The base directory for TivaWare. +# +ROOT=../../../.. + +# +# Include the common make definitions. +# +include ${ROOT}/makedefs + +# +# Where to find source files that do not live in this directory. +# +VPATH=../../../../utils + +# +# Where to find header files that do not live in the source directory. +# +IPATH=.. +IPATH+=../../../.. + +# +# The default rule, which causes the USB memory stick updater example to be built. +# +all: ${COMPILER} +all: ${COMPILER}/usb_stick_update.axf + +# +# The rule to clean out all the build products. +# +clean: + @rm -rf ${COMPILER} ${wildcard *~} + +# +# The rule to create the target directory. +# +${COMPILER}: + @mkdir -p ${COMPILER} + +# +# Rules for building the USB memory stick updater example. +# +${COMPILER}/usb_stick_update.axf: ${COMPILER}/simple_fs.o +${COMPILER}/usb_stick_update.axf: ${COMPILER}/startup_${COMPILER}.o +${COMPILER}/usb_stick_update.axf: ${COMPILER}/usb_stick_update.o +${COMPILER}/usb_stick_update.axf: ${ROOT}/usblib/${COMPILER}/libusb.a +${COMPILER}/usb_stick_update.axf: ${ROOT}/driverlib/${COMPILER}/libdriver.a +${COMPILER}/usb_stick_update.axf: usb_stick_update.ld +SCATTERgcc_usb_stick_update=usb_stick_update.ld +ENTRY_usb_stick_update=ResetISR +CFLAGSgcc=-DTARGET_IS_TM4C129_RA0 + +# +# Include the automatically generated dependency files. +# +ifneq (${MAKECMDGOALS},clean) +-include ${wildcard ${COMPILER}/*.d} __dummy__ +endif diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsimportspec b/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsimportspec new file mode 100644 index 0000000..d225a1d --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsimportspec @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsproject b/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsproject new file mode 100644 index 0000000..59a3400 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/.ccsproject @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/.cproject b/boards/dk-tm4c129x/usb_stick_update/ccs/.cproject new file mode 100644 index 0000000..ebaa41e --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/.cproject @@ -0,0 +1,182 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/.project b/boards/dk-tm4c129x/usb_stick_update/ccs/.project new file mode 100644 index 0000000..0fe4424 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/.project @@ -0,0 +1,55 @@ + + + usb_stick_update + + + + + + org.eclipse.cdt.managedbuilder.core.genmakebuilder + + + + + org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder + full,incremental, + + + + + + com.ti.ccstudio.core.ccsNature + org.eclipse.cdt.core.cnature + org.eclipse.cdt.managedbuilder.core.managedBuildNature + org.eclipse.cdt.core.ccnature + org.eclipse.cdt.managedbuilder.core.ScannerConfigNature + + + + simple_fs.c + 1 + SW_ROOT/examples/boards/dk-tm4c129x/usb_stick_update/simple_fs.c + + + startup_ccs.c + 1 + SW_ROOT/examples/boards/dk-tm4c129x/usb_stick_update/startup_ccs.c + + + usb_stick_update.c + 1 + SW_ROOT/examples/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.c + + + usb_stick_update_ccs.cmd + 1 + SW_ROOT/examples/boards/dk-tm4c129x/usb_stick_update/usb_stick_update_ccs.cmd + + + + + SW_ROOT + $%7BPARENT-5-PROJECT_LOC%7D + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/.settings/org.eclipse.cdt.codan.core.prefs b/boards/dk-tm4c129x/usb_stick_update/ccs/.settings/org.eclipse.cdt.codan.core.prefs new file mode 100644 index 0000000..98b6350 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/.settings/org.eclipse.cdt.codan.core.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +inEditor=false +onBuild=false diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.bin b/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.bin new file mode 100644 index 0000000..c173ab1 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.bin differ diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.out b/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.out new file mode 100644 index 0000000..8ab0bc2 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/ccs/Debug/usb_stick_update.out differ diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/macros.ini_initial b/boards/dk-tm4c129x/usb_stick_update/ccs/macros.ini_initial new file mode 100644 index 0000000..31214b5 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/macros.ini_initial @@ -0,0 +1 @@ +SW_ROOT = ../../../../.. diff --git a/boards/dk-tm4c129x/usb_stick_update/ccs/target_config.ccxml b/boards/dk-tm4c129x/usb_stick_update/ccs/target_config.ccxml new file mode 100644 index 0000000..6e5ef45 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/ccs/target_config.ccxml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.bin b/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.bin new file mode 100644 index 0000000..dfb1e56 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.bin differ diff --git a/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.out b/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.out new file mode 100644 index 0000000..0e91253 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/ewarm/Exe/usb_stick_update.out differ diff --git a/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.axf b/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.axf new file mode 100644 index 0000000..99cb6a0 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.axf differ diff --git a/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.bin b/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.bin new file mode 100644 index 0000000..0c58747 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/gcc/usb_stick_update.bin differ diff --git a/boards/dk-tm4c129x/usb_stick_update/readme.txt b/boards/dk-tm4c129x/usb_stick_update/readme.txt new file mode 100644 index 0000000..8f0167b --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/readme.txt @@ -0,0 +1,49 @@ +USB Memory Stick Updater + +This example application behaves the same way as a boot loader. It resides +at the beginning of flash, and will read a binary file from a USB memory +stick and program it into another location in flash. Once the user +application has been programmed into flash, this program will always start +the user application until requested to load a new application. + +When this application starts, if there is a user application already in +flash (at \b APP_START_ADDRESS), then it will just run the user application. +It will attempt to load a new application from a USB memory stick under +the following conditions: + +- no user application is present at \b APP_START_ADDRESS +- the user application has requested an update by transferring control +to the updater +- the user holds down the eval board push button when the board is reset + +When this application is attempting to perform an update, it will wait +forever for a USB memory stick to be plugged in. Once a USB memory stick +is found, it will search the root directory for a specific file name, which +is \e FIRMWARE.BIN by default. This file must be a binary image of the +program you want to load (the .bin file), linked to run from the correct +address, at \b APP_START_ADDRESS. + +The USB memory stick must be formatted as a FAT16 or FAT32 file system +(the normal case), and the binary file must be located in the root +directory. Other files can exist on the memory stick but they will be +ignored. + +------------------------------------------------------------------------------- + +Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +Software License Agreement + +Texas Instruments (TI) is supplying this software for use solely and +exclusively on TI's microcontroller products. The software is owned by +TI and/or its suppliers, and is protected under applicable copyright +laws. You may not combine this software with "viral" open-source +software in order to form a larger program. + +THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, FOR ANY REASON WHATSOEVER. + +This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. diff --git a/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.axf b/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.axf new file mode 100644 index 0000000..6d3534c Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.axf differ diff --git a/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.bin b/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.bin new file mode 100644 index 0000000..5ad8a57 Binary files /dev/null and b/boards/dk-tm4c129x/usb_stick_update/rvmdk/usb_stick_update.bin differ diff --git a/boards/dk-tm4c129x/usb_stick_update/simple_fs.c b/boards/dk-tm4c129x/usb_stick_update/simple_fs.c new file mode 100644 index 0000000..2fdc17f --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/simple_fs.c @@ -0,0 +1,865 @@ +//***************************************************************************** +// +// simple_fs.c - Functions for simple FAT file system support +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#include +#include +#include +#include "simple_fs.h" + +//***************************************************************************** +// +// \addtogroup simple_fs_api +// @{ +// +// This file system API should be used as follows: +// - Initialize it by calling SimpleFsInit(). You must supply a pointer to a +// 512 byte buffer that will be used for storing device sector data. +// - "Open" a file by calling SimpleFsOpen() and passing the 8.3-style filename +// as an 11-character string. +// - Read successive sectors from the file by using the convenience macro +// SimpleFsReadFileSector(). +// +// This API does not use any file handles so there is no way to open more than +// one file at a time. There is also no random access into the file, each +// sector must be read in sequence. +// +// The client of this API supplies a 512-byte buffer for storage of data read +// from the device. But this file also maintains an additional, internal +// 512-byte buffer used for caching FAT sectors. This minimizes the amount +// of device reads required to fetch cluster chain entries from the FAT. +// +// The application code (the client) must also provide a function used for +// reading sectors from the storage device, whatever it may be. This allows +// the code in this file to be independent of the type of device used for +// storing the file system. The name of the function is +// SimpleFsReadMediaSector(). +// +//***************************************************************************** + +//***************************************************************************** +// +// Setup a macro for handling packed data structures. +// +//***************************************************************************** +#if defined(ccs) || \ + defined(codered) || \ + defined(gcc) || \ + defined(rvmdk) || \ + defined(__ARMCC_VERSION) || \ + defined(sourcerygxx) +#define PACKED __attribute__((packed)) +#elif defined(ewarm) +#define PACKED +#else +#error "Unrecognized COMPILER!" +#endif + +//***************************************************************************** +// +// Instruct the IAR compiler to pack the following structures. +// +//***************************************************************************** +#ifdef ewarm +#pragma pack(1) +#endif + +//***************************************************************************** +// +// Structures for mapping FAT file system +// +//***************************************************************************** + +//***************************************************************************** +// +// The FAT16 boot sector extension +// +//***************************************************************************** +typedef struct +{ + uint8_t ui8DriveNumber; + uint8_t ui8Reserved; + uint8_t ui8ExtSig; + uint32_t ui32Serial; + char pcVolumeLabel[11]; + char pcFsType[8]; + uint8_t ui8BootCode[448]; + uint16_t ui16Sig; +} +PACKED tBootExt16; + +//***************************************************************************** +// +// The FAT32 boot sector extension +// +//***************************************************************************** +typedef struct +{ + uint32_t ui32SectorsPerFAT; + uint16_t ui16Flags; + uint16_t ui16Version; + uint32_t ui32RootCluster; + uint16_t ui16InfoSector; + uint16_t ui16BootCopy; + uint8_t ui8Reserved[12]; + uint8_t ui8DriveNumber; + uint8_t ui8Reserved1; + uint8_t ui8ExtSig; + uint32_t ui32Serial; + char pcVolumeLabel[11]; + char pcFsType[8]; + uint8_t ui8BootCode[420]; + uint16_t ui16Sig; +} +PACKED tBootExt32; + +//***************************************************************************** +// +// The FAT16/32 boot sector main section +// +//***************************************************************************** +typedef struct +{ + uint8_t ui8Jump[3]; + uint8_t i8OEMName[8]; + uint16_t ui16BytesPerSector; + uint8_t ui8SectorsPerCluster; + uint16_t ui16ReservedSectors; + uint8_t ui8NumFATs; + uint16_t ui16NumRootEntries; + uint16_t ui16TotalSectorsSmall; + uint8_t ui8MediaDescriptor; + uint16_t ui16SectorsPerFAT; + uint16_t ui16SectorsPerTrack; + uint16_t ui16NumberHeads; + uint32_t ui32HiddenSectors; + uint32_t ui32TotalSectorsBig; + union + { + tBootExt16 sExt16; + tBootExt32 sExt32; + } + PACKED ext; +} +PACKED tBootSector; + +//***************************************************************************** +// +// The partition table +// +//***************************************************************************** +typedef struct +{ + uint8_t ui8Status; + uint8_t ui8CHSFirst[3]; + uint8_t ui8Type; + uint8_t ui8CHSLast[3]; + uint32_t ui32FirstSector; + uint32_t ui32NumBlocks; +} +PACKED tPartitionTable; + +//***************************************************************************** +// +// The master boot record (MBR) +// +//***************************************************************************** +typedef struct +{ + uint8_t ui8CodeArea[440]; + uint8_t ui8DiskSignature[4]; + uint8_t ui8Nulls[2]; + tPartitionTable sPartTable[4]; + uint16_t ui16Sig; +} +PACKED tMasterBootRecord; + +//***************************************************************************** +// +// The structure for a single directory entry +// +//***************************************************************************** +typedef struct +{ + char pcFileName[11]; + uint8_t ui8Attr; + uint8_t ui8Reserved; + uint8_t ui8CreateTime[5]; + uint8_t ui8LastDate[2]; + uint16_t ui16ClusterHi; + uint8_t ui8LastModified[4]; + uint16_t ui16Cluster; + uint32_t ui32FileSize; +} +PACKED tDirEntry; + +//***************************************************************************** +// +// Tell the IAR compiler that the remaining structures do not need to be +// packed. +// +//***************************************************************************** +#ifdef ewarm +#pragma pack() +#endif + +//***************************************************************************** +// +// This structure holds information about the layout of the file system +// +//***************************************************************************** +typedef struct +{ + uint32_t ui32FirstSector; + uint32_t ui32NumBlocks; + uint16_t ui16SectorsPerCluster; + uint16_t ui16MaxRootEntries; + uint32_t ui32SectorsPerFAT; + uint32_t ui32FirstFATSector; + uint32_t ui32LastFATSector; + uint32_t ui32FirstDataSector; + uint32_t ui32Type; + uint32_t ui32StartRootDir; +} +tPartitionInfo; + +static tPartitionInfo sPartInfo; + +//***************************************************************************** +// +// A pointer to the client provided sector buffer. +// +//***************************************************************************** +static uint8_t *g_pui8SectorBuf; + +//***************************************************************************** +// +// Initializes the simple file system +// +// \param pui8SectorBuf is a pointer to a caller supplied 512-byte buffer +// that will be used for holding sectors that are loaded from the media +// storage device. +// +// Reads the MBR, partition table, and boot record to find the logical +// structure of the file system. This function stores the file system +// structural data internally so that the remaining functions of the API +// can read the file system. +// +// To read data from the storage device, the function SimpleFsReadMediaSector() +// will be called. This function is not implemented here but must be +// implemented by the user of this simple file system. +// +// This file system support is extremely simple-minded. It will only +// find the first partition of a FAT16 or FAT32 formatted mass storage +// device. Only very minimal error checking is performed in order to save +// code space. +// +// \return Zero if successful, non-zero if there was an error. +// +//***************************************************************************** +uint32_t +SimpleFsInit(uint8_t *pui8SectorBuf) +{ + tMasterBootRecord *pMBR; + tPartitionTable *pPart; + tBootSector *pBoot; + + // + // Save the sector buffer pointer. The input parameter is assumed + // to be good. + // + g_pui8SectorBuf = pui8SectorBuf; + + // + // Get the MBR + // + if(SimpleFsReadMediaSector(0, pui8SectorBuf)) + { + return(1); + } + + // + // Verify MBR signature - bare minimum validation of MBR. + // + pMBR = (tMasterBootRecord *)pui8SectorBuf; + if(pMBR->ui16Sig != 0xAA55) + { + return(1); + } + + // + // See if this is a MBR or a boot sector. + // + pBoot = (tBootSector *)pui8SectorBuf; + if((strncmp(pBoot->ext.sExt16.pcFsType, "FAT", 3) != 0) && + (strncmp(pBoot->ext.sExt32.pcFsType, "FAT32", 5) != 0)) + { + // + // Get the first partition table + // + pPart = &(pMBR->sPartTable[0]); + + // + // Could optionally check partition type here ... + // + + // + // Get the partition location and size + // + sPartInfo.ui32FirstSector = pPart->ui32FirstSector; + sPartInfo.ui32NumBlocks = pPart->ui32NumBlocks; + + // + // Read the boot sector from the partition + // + if(SimpleFsReadMediaSector(sPartInfo.ui32FirstSector, pui8SectorBuf)) + { + return(1); + } + } + else + { + // + // Extract the number of sectors from the boot sector. + // + sPartInfo.ui32FirstSector = 0; + if(pBoot->ui16TotalSectorsSmall == 0) + { + sPartInfo.ui32NumBlocks = pBoot->ui32TotalSectorsBig; + } + else + { + sPartInfo.ui32NumBlocks = pBoot->ui16TotalSectorsSmall; + } + } + + // + // Get pointer to the boot sector + // + if(pBoot->ext.sExt16.ui16Sig != 0xAA55) + { + return(1); + } + + // + // Verify the sector size is 512. We can't deal with anything else + // + if(pBoot->ui16BytesPerSector != 512) + { + return(1); + } + + // + // Extract some info from the boot record + // + sPartInfo.ui16SectorsPerCluster = pBoot->ui8SectorsPerCluster; + sPartInfo.ui16MaxRootEntries = pBoot->ui16NumRootEntries; + + // + // Decide if we are dealing with FAT16 or FAT32. + // If number of root entries is 0, that suggests FAT32 + // + if(sPartInfo.ui16MaxRootEntries == 0) + { + // + // Confirm FAT 32 signature in the expected place + // + if(!strncmp(pBoot->ext.sExt32.pcFsType, "FAT32 ", 8)) + { + sPartInfo.ui32Type = 32; + } + else + { + return(1); + } + } + // + // Root entries is non-zero, suggests FAT16 + // + else + { + // + // Confirm FAT16 signature + // + if(!strncmp(pBoot->ext.sExt16.pcFsType, "FAT16 ", 8)) + { + sPartInfo.ui32Type = 16; + } + else + { + return(1); + } + } + + // + // Find the beginning of the FAT, in absolute sectors + // + sPartInfo.ui32FirstFATSector = sPartInfo.ui32FirstSector + + pBoot->ui16ReservedSectors; + + // + // Find the end of the FAT in absolute sectors. FAT16 and 32 + // are handled differently. + // + sPartInfo.ui32SectorsPerFAT = (sPartInfo.ui32Type == 16) ? + pBoot->ui16SectorsPerFAT : + pBoot->ext.sExt32.ui32SectorsPerFAT; + sPartInfo.ui32LastFATSector = sPartInfo.ui32FirstFATSector + + sPartInfo.ui32SectorsPerFAT - 1; + + // + // Find the start of the root directory and the data area. + // For FAT16, the root will be stored as an absolute sector number + // For FAT32, the root will be stored as the starting cluster of the root + // The data area start is the absolute first sector of the data area. + // + if(sPartInfo.ui32Type == 16) + { + sPartInfo.ui32StartRootDir = sPartInfo.ui32FirstFATSector + + (sPartInfo.ui32SectorsPerFAT * + pBoot->ui8NumFATs); + sPartInfo.ui32FirstDataSector = sPartInfo.ui32StartRootDir + + (sPartInfo.ui16MaxRootEntries / 16); + } + else + { + sPartInfo.ui32StartRootDir = pBoot->ext.sExt32.ui32RootCluster; + sPartInfo.ui32FirstDataSector = sPartInfo.ui32FirstFATSector + + (sPartInfo.ui32SectorsPerFAT * pBoot->ui8NumFATs); + } + + // + // At this point the file system has been initialized, so return + // success to the caller. + // + return(0); +} + +//***************************************************************************** +// +// Find the next cluster in a FAT chain +// +// \param ui32ThisCluster is the current cluster in the chain +// +// Reads the File Allocation Table (FAT) of the file system to find the +// next cluster in a chain of clusters. The current cluster is passed in +// and the next cluster in the chain will be returned. +// +// This function reads sectors from the storage device as needed in order +// to parse the FAT tables. Error handling is minimal since there is not +// much that can be done if an error is encountered. If any error is +// encountered, or if this is the last cluster in the chain, then 0 is +// returned. This signals the caller to stop traversing the chain (either +// due to error or end of chain). +// +// The function maintains a cache of a single sector from the FAT. It only +// reads in a new FAT sector if the requested cluster is not in the +// currently cached sector. +// +// \return Next cluster number if successful, 0 if this is the last cluster +// or any error is found. +// +//***************************************************************************** +static uint32_t +SimpleFsGetNextCluster(uint_fast32_t ui32ThisCluster) +{ + static uint8_t ui8FATCache[512]; + static uint_fast32_t ui32CachedFATSector = (uint32_t)-1; + uint_fast32_t ui32ClustersPerFATSector; + uint_fast32_t ui32ClusterIdx; + uint_fast32_t ui32FATSector; + uint_fast32_t ui32NextCluster; + uint_fast32_t ui32MaxCluster; + + // + // Compute the maximum possible reasonable cluster number + // + ui32MaxCluster = sPartInfo.ui32NumBlocks / sPartInfo.ui16SectorsPerCluster; + + // + // Make sure cluster input number is reasonable. If not then return + // 0 indicating error. + // + if((ui32ThisCluster < 2) || (ui32ThisCluster > ui32MaxCluster)) + { + return(0); + } + + // + // Compute the index of the requested cluster within the sector. + // Also compute the sector number within the FAT that contains the + // entry for the requested cluster. + // + ui32ClustersPerFATSector = (sPartInfo.ui32Type == 16) ? 256 : 128; + ui32ClusterIdx = ui32ThisCluster % ui32ClustersPerFATSector; + ui32FATSector = ui32ThisCluster / ui32ClustersPerFATSector; + + // + // Check to see if the FAT sector we need is already cached + // + if(ui32FATSector != ui32CachedFATSector) + { + // + // FAT sector we need is not cached, so read it in + // + if(SimpleFsReadMediaSector(sPartInfo.ui32FirstFATSector + ui32FATSector, + ui8FATCache) != 0) + { + // + // There was an error so mark cache as unavailable and return + // an error. + // + ui32CachedFATSector = (uint32_t)-1; + return(0); + } + + // + // Remember which FAT sector was just loaded into the cache. + // + ui32CachedFATSector = ui32FATSector; + } + + // + // Now look up the next cluster value from the cached sector, using this + // requested cluster as an index. It needs to be indexed as 16 or 32 + // bit values depending on whether it is FAT16 or 32 + // If the cluster value means last cluster, then return 0 + // + if(sPartInfo.ui32Type == 16) + { + ui32NextCluster = ((uint16_t *)ui8FATCache)[ui32ClusterIdx]; + if(ui32NextCluster >= 0xFFF8) + { + return(0); + } + } + else + { + ui32NextCluster = ((uint32_t *)ui8FATCache)[ui32ClusterIdx]; + if(ui32NextCluster >= 0x0FFFFFF8) + { + return(0); + } + } + + // + // Check new cluster value to make sure it is reasonable. If not then + // return 0 to indicate an error. + // + if((ui32NextCluster >= 2) && (ui32NextCluster <= ui32MaxCluster)) + { + return(ui32NextCluster); + } + else + { + return(0); + } +} + +//***************************************************************************** +// +// Read a single sector from a file into the sector buffer +// +// \param ui32StartCluster is the first cluster of the file, used to +// initialize the file read. Use 0 for successive sectors. +// +// Reads sectors in sequence from a file and stores the data in the sector +// buffer that was passed in the initial call to SimpleFsInit(). The function +// is initialized with the file to read by passing the starting cluster of +// the file. The function will initialize some static data and return. It +// does not read any file data when passed a starting cluster (and +// returns 0 - this is normal). +// +// Once the function has been initialized with the file's starting cluster, +// then successive calls should be made, passing a value of 0 for the +// cluster number. This tells the function to read the next sector from the +// file and store it in the sector buffer. The function remembers the last +// sector that was read, and each time it is called with a cluster value of +// 0, it will read the next sector. The function will traverse the FAT +// chain as needed to read all the sectors. When a sector has been +// successfully read from a file, the function will return non-zero. When +// there are no more sectors to read, or any error is encountered, the +// function will return 0. +// +// Note that the function always reads a whole sector, even if the end of +// a file does not fill the last sector. It is the responsibility of the +// caller to track the file size and to deal with a partially full last +// sector. +// +// \return Non-zero if a sector was read into the sector buffer, or +// 0 if there are no more sectors or if any error occurred. +// +//***************************************************************************** +uint32_t +SimpleFsGetNextFileSector(uint_fast32_t ui32StartCluster) +{ + static uint_fast32_t ui32WorkingCluster = 0; + static uint_fast32_t ui32WorkingSector; + uint_fast32_t ui32ReadSector; + + // + // If user specified starting cluster, then init the working cluster + // and sector values + // + if(ui32StartCluster) + { + ui32WorkingCluster = ui32StartCluster; + ui32WorkingSector = 0; + return(0); + } + + // + // Otherwise, make sure there is a valid working cluster already + // + else if(ui32WorkingCluster == 0) + { + return(0); + } + + // + // If the current working sector is the same as sectors per cluster, + // then that means that the next cluster needs to be loaded. + // + if(ui32WorkingSector == sPartInfo.ui16SectorsPerCluster) + { + // + // Get the next cluster in the chain for this file. + // + ui32WorkingCluster = SimpleFsGetNextCluster(ui32WorkingCluster); + + // + // If the next cluster is valid, then reset the working sector + // + if(ui32WorkingCluster) + { + ui32WorkingSector = 0; + } + + // + // Next cluster is not valid, or this was the end of the chain. + // Clear the working cluster and return an indication that no new + // sector data was loaded. + // + else + { + ui32WorkingCluster = 0; + return(0); + } + } + + // + // Calculate the sector to read from. It is the sector of the start + // of the working cluster, plus the working sector (the sector within + // the cluster), plus the offset to the start of the data area. + // Note that the cluster needs to be reduced by 2 in order to index + // properly into the data area. That is a feature of FAT file system. + // + ui32ReadSector = (ui32WorkingCluster - 2) * sPartInfo.ui16SectorsPerCluster; + ui32ReadSector += ui32WorkingSector; + ui32ReadSector += sPartInfo.ui32FirstDataSector; + + // + // Attempt to read the next sector from the cluster. If not successful, + // then clear the working cluster and return a non-success indication. + // + if(SimpleFsReadMediaSector(ui32ReadSector, g_pui8SectorBuf) != 0) + { + ui32WorkingCluster = 0; + return(0); + } + else + { + // + // Read was successful. Increment to the next sector of the cluster + // and return a success indication. + // + ui32WorkingSector++; + return(1); + } +} + +//***************************************************************************** +// +// Find a file in the root directory of the file system and open it for +// reading. +// +// \param pcName83 is an 11-character string that represents the 8.3 file +// name of the file to open. +// +// This function traverses the root directory of the file system to find +// the file name specified by the caller. Note that the file name must be +// an 8.3 file name that is 11 characters int32_t. The first 8 characters are +// the base name and the last 3 characters are the extension. If there are +// fewer characters in the base name or extension, the name should be padded +// with spaces. For example "myfile.bn" has fewer than 11 characters, and +// should be passed with padding like this: "myfile bn ". Note the extra +// spaces, and that the dot ('.') is not part of the string that is passed +// to this function. +// +// If the file is found, then it initializes the file for reading, and returns +// the file length. The file can be read by making successive calls to +// SimpleFsReadFileSector(). +// +// The function only searches the root directory and ignores any +// subdirectories. It also ignores any int32_t file name entries, looking only +// at the 8.3 file name for a match. +// +// \return The size of the file if it is found, or 0 if the file could not +// be found. +// +//***************************************************************************** +uint32_t +SimpleFsOpen(char *pcName83) +{ + tDirEntry *pDirEntry; + uint_fast32_t ui32DirSector; + uint_fast32_t ui32FirstCluster; + + // + // Find starting root dir sector, only used for FAT16 + // If FAT32 then this is the first cluster of root dir + // + ui32DirSector = sPartInfo.ui32StartRootDir; + + // + // For FAT32, root dir is like a file, so init a file read of the root dir + // + if(sPartInfo.ui32Type == 32) + { + SimpleFsGetNextFileSector(ui32DirSector); + } + + // + // Search the root directory entry for the firmware file + // + while(1) + { + // + // Read in a directory block. + // + if(sPartInfo.ui32Type == 16) + { + // + // For FAT16, read in a sector of the root directory + // + if(SimpleFsReadMediaSector(ui32DirSector, g_pui8SectorBuf)) + { + return(0); + } + } + else + { + // + // For FAT32, the root directory is treated like a file. + // The root directory sector will be loaded into the sector buf + // + if(SimpleFsGetNextFileSector(0) == 0) + { + return(0); + } + } + + // + // Initialize the directory entry pointer to the first entry of + // this sector. + // + pDirEntry = (tDirEntry *)g_pui8SectorBuf; + + // + // Iterate through all the directory entries in this sector + // + while((uint8_t *)pDirEntry < &g_pui8SectorBuf[512]) + { + // + // If the 8.3 filename of this entry matches the firmware + // file name, then we have a match, so return a pointer to + // this entry. + // + if(!strncmp(pDirEntry->pcFileName, pcName83, 11)) + { + // + // Compute the starting cluster of the file + // + ui32FirstCluster = pDirEntry->ui16Cluster; + if(sPartInfo.ui32Type == 32) + { + // + // For FAT32, add in the upper word of the + // starting cluster number + // + ui32FirstCluster += pDirEntry->ui16ClusterHi << 16; + } + + // + // Initialize the start of the file + // + SimpleFsGetNextFileSector(ui32FirstCluster); + return(pDirEntry->ui32FileSize); + } + + // + // Advance to the next entry in this sector. + // + pDirEntry++; + } + + // + // Need to get the next sector in the directory. Handled + // differently depending on if this is FAT16 or 32 + // + if(sPartInfo.ui32Type == 16) + { + // + // FAT16: advance sectors as int32_t as there are more possible + // entries. + // + sPartInfo.ui16MaxRootEntries -= 512 / 32; + if(sPartInfo.ui16MaxRootEntries) + { + ui32DirSector++; + } + else + { + // + // Ran out of directory entries and didn't find the file, + // so return a null. + // + return(0); + } + } + else + { + // + // FAT32: there is nothing to compute here. The next root + // dir sector will be fetched at the top of the loop + // + } + } +} + +//***************************************************************************** +// +// Close the Doxygen group. +// @} +// +//***************************************************************************** diff --git a/boards/dk-tm4c129x/usb_stick_update/simple_fs.h b/boards/dk-tm4c129x/usb_stick_update/simple_fs.h new file mode 100644 index 0000000..86fff46 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/simple_fs.h @@ -0,0 +1,105 @@ +//***************************************************************************** +// +// simple_fs.h - Header for simple FAT file system support +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#ifndef __SIMPLE_FS_H__ +#define __SIMPLE_FS_H__ + +//***************************************************************************** +// +// \addtogroup simple_fs_api +// @{ +// +//***************************************************************************** + +//***************************************************************************** +// +// Macro to read a single sector from a file that was opened with +// SimpleFsOpen() +// +// This convenience macro maps to the function SimpleFsGetNextFileSector() +// called with a parameter of 0. It should be used to read successive +// sectors from a file after the file has been opened with SimpleFsOpen(). +// +// When a sector is read, it is loaded into the sector buffer that was passed +// when SimpleFsInit() was called. +// +// A non-zero value will be returned to the caller as int32_t as successive +// sectors are successfully read into the sector buffer. At the end of the +// file, or if there is any error, then a value of 0 is returned. +// +// Note that the a whole sector is always loaded, even if the end of +// a file does not fill the last sector. It is the responsibility of the +// caller to track the file size and to deal with a partially full last +// sector. +// +// \return Non-zero if a sector was read into the sector buffer, or +// 0 if there are no more sectors or if any error occurred. +// +//***************************************************************************** +#define SimpleFsReadFileSector() SimpleFsGetNextFileSector(0) + +//***************************************************************************** +// +// Read a single sector from the application-specific storage device into +// the sector buffer. +// +// \param ui32Sector is the absolute sector number to read from the storage +// device +// \param pui8SectorBuf is a pointer to a 512 byte buffer where the sector +// data should be written +// +// This function is used by the simple file system functions to read a sector +// of data from a storage device. It must be implemented as part of the +// application specific code. For example, it could be used to read sectors +// from a USB mass storage device, or from an SD card, or any device that can +// be used to store a FAT file system. Note that the sector size is always +// assumed to be 512 bytes. +// +// \return Zero value if a sector of data was successfully read from the +// device and stored in the sector buffer, non-zero if not successful. +// +//***************************************************************************** +// +// This function to be supplied by the client +// +extern uint32_t SimpleFsReadMediaSector(uint_fast32_t ui32Sector, + uint8_t *pui8SectorBuf); + +//***************************************************************************** +// +// Close the Doxygen group. +// @} +// +//***************************************************************************** + +//***************************************************************************** +// +// Functions to help with accessing the FAT file system on a storage device +// +//**************************************************************************** +extern uint32_t SimpleFsInit(uint8_t *pui8SectorBuf); +extern uint32_t SimpleFsOpen(char *pcName83); +extern uint32_t SimpleFsGetNextFileSector(uint_fast32_t ui32StartCluster); + +#endif // __SIMPLE_FS_H__ diff --git a/boards/dk-tm4c129x/usb_stick_update/startup_ccs.c b/boards/dk-tm4c129x/usb_stick_update/startup_ccs.c new file mode 100644 index 0000000..2ac9b8b --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/startup_ccs.c @@ -0,0 +1,276 @@ +//***************************************************************************** +// +// startup_ccs.c - Startup code for use with TI's Code Composer Studio. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#include +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" + +//***************************************************************************** +// +// Forward declaration of the default fault handlers. +// +//***************************************************************************** +void ResetISR(void); +static void NmiSR(void); +static void FaultISR(void); +static void IntDefaultHandler(void); + +//***************************************************************************** +// +// External declaration for the reset handler that is to be called when the +// processor is started +// +//***************************************************************************** +extern void _c_int00(void); + +//***************************************************************************** +// +// Linker variable that marks the top of the stack. +// +//***************************************************************************** +extern uint32_t __STACK_TOP; + +//***************************************************************************** +// +// External declarations for the interrupt handlers used by the application. +// +//***************************************************************************** +extern void AppForceUpdate(void); +extern void USB0HostIntHandler(void); + +//***************************************************************************** +// +// The vector table. Note that the proper constructs must be placed on this to +// ensure that it ends up at physical address 0x0000.0000 or at the start of +// the program if located at a start address other than 0. +// +//***************************************************************************** +#pragma DATA_SECTION(g_pfnVectors, ".intvecs") +void (* const g_pfnVectors[])(void) = +{ + (void (*)(void))((uint32_t)&__STACK_TOP), + // The initial stack pointer + ResetISR, // The reset handler + NmiSR, // The NMI handler + FaultISR, // The hard fault handler + IntDefaultHandler, // The MPU fault handler + IntDefaultHandler, // The bus fault handler + IntDefaultHandler, // The usage fault handler + 0, // Reserved + 0, // Reserved + 0, // Reserved + 0, // Reserved + AppForceUpdate, // SVCall handler + IntDefaultHandler, // Debug monitor handler + 0, // Reserved + IntDefaultHandler, // The PendSV handler + IntDefaultHandler, // The SysTick handler + IntDefaultHandler, // GPIO Port A + IntDefaultHandler, // GPIO Port B + IntDefaultHandler, // GPIO Port C + IntDefaultHandler, // GPIO Port D + IntDefaultHandler, // GPIO Port E + IntDefaultHandler, // UART0 Rx and Tx + IntDefaultHandler, // UART1 Rx and Tx + IntDefaultHandler, // SSI0 Rx and Tx + IntDefaultHandler, // I2C0 Master and Slave + IntDefaultHandler, // PWM Fault + IntDefaultHandler, // PWM Generator 0 + IntDefaultHandler, // PWM Generator 1 + IntDefaultHandler, // PWM Generator 2 + IntDefaultHandler, // Quadrature Encoder 0 + IntDefaultHandler, // ADC Sequence 0 + IntDefaultHandler, // ADC Sequence 1 + IntDefaultHandler, // ADC Sequence 2 + IntDefaultHandler, // ADC Sequence 3 + IntDefaultHandler, // Watchdog timer + IntDefaultHandler, // Timer 0 subtimer A + IntDefaultHandler, // Timer 0 subtimer B + IntDefaultHandler, // Timer 1 subtimer A + IntDefaultHandler, // Timer 1 subtimer B + IntDefaultHandler, // Timer 2 subtimer A + IntDefaultHandler, // Timer 2 subtimer B + IntDefaultHandler, // Analog Comparator 0 + IntDefaultHandler, // Analog Comparator 1 + IntDefaultHandler, // Analog Comparator 2 + IntDefaultHandler, // System Control (PLL, OSC, BO) + IntDefaultHandler, // FLASH Control + IntDefaultHandler, // GPIO Port F + IntDefaultHandler, // GPIO Port G + IntDefaultHandler, // GPIO Port H + IntDefaultHandler, // UART2 Rx and Tx + IntDefaultHandler, // SSI1 Rx and Tx + IntDefaultHandler, // Timer 3 subtimer A + IntDefaultHandler, // Timer 3 subtimer B + IntDefaultHandler, // I2C1 Master and Slave + IntDefaultHandler, // CAN0 + IntDefaultHandler, // CAN1 + IntDefaultHandler, // Ethernet + IntDefaultHandler, // Hibernate + USB0HostIntHandler, // USB0 + IntDefaultHandler, // PWM Generator 3 + IntDefaultHandler, // uDMA Software Transfer + IntDefaultHandler, // uDMA Error + IntDefaultHandler, // ADC1 Sequence 0 + IntDefaultHandler, // ADC1 Sequence 1 + IntDefaultHandler, // ADC1 Sequence 2 + IntDefaultHandler, // ADC1 Sequence 3 + IntDefaultHandler, // External Bus Interface 0 + IntDefaultHandler, // GPIO Port J + IntDefaultHandler, // GPIO Port K + IntDefaultHandler, // GPIO Port L + IntDefaultHandler, // SSI2 Rx and Tx + IntDefaultHandler, // SSI3 Rx and Tx + IntDefaultHandler, // UART3 Rx and Tx + IntDefaultHandler, // UART4 Rx and Tx + IntDefaultHandler, // UART5 Rx and Tx + IntDefaultHandler, // UART6 Rx and Tx + IntDefaultHandler, // UART7 Rx and Tx + IntDefaultHandler, // I2C2 Master and Slave + IntDefaultHandler, // I2C3 Master and Slave + IntDefaultHandler, // Timer 4 subtimer A + IntDefaultHandler, // Timer 4 subtimer B + IntDefaultHandler, // Timer 5 subtimer A + IntDefaultHandler, // Timer 5 subtimer B + IntDefaultHandler, // FPU + 0, // Reserved + 0, // Reserved + IntDefaultHandler, // I2C4 Master and Slave + IntDefaultHandler, // I2C5 Master and Slave + IntDefaultHandler, // GPIO Port M + IntDefaultHandler, // GPIO Port N + 0, // Reserved + IntDefaultHandler, // Tamper + IntDefaultHandler, // GPIO Port P (Summary or P0) + IntDefaultHandler, // GPIO Port P1 + IntDefaultHandler, // GPIO Port P2 + IntDefaultHandler, // GPIO Port P3 + IntDefaultHandler, // GPIO Port P4 + IntDefaultHandler, // GPIO Port P5 + IntDefaultHandler, // GPIO Port P6 + IntDefaultHandler, // GPIO Port P7 + IntDefaultHandler, // GPIO Port Q (Summary or Q0) + IntDefaultHandler, // GPIO Port Q1 + IntDefaultHandler, // GPIO Port Q2 + IntDefaultHandler, // GPIO Port Q3 + IntDefaultHandler, // GPIO Port Q4 + IntDefaultHandler, // GPIO Port Q5 + IntDefaultHandler, // GPIO Port Q6 + IntDefaultHandler, // GPIO Port Q7 + IntDefaultHandler, // GPIO Port R + IntDefaultHandler, // GPIO Port S + IntDefaultHandler, // SHA/MD5 0 + IntDefaultHandler, // AES 0 + IntDefaultHandler, // DES3DES 0 + IntDefaultHandler, // LCD Controller 0 + IntDefaultHandler, // Timer 6 subtimer A + IntDefaultHandler, // Timer 6 subtimer B + IntDefaultHandler, // Timer 7 subtimer A + IntDefaultHandler, // Timer 7 subtimer B + IntDefaultHandler, // I2C6 Master and Slave + IntDefaultHandler, // I2C7 Master and Slave + IntDefaultHandler, // HIM Scan Matrix Keyboard 0 + IntDefaultHandler, // One Wire 0 + IntDefaultHandler, // HIM PS/2 0 + IntDefaultHandler, // HIM LED Sequencer 0 + IntDefaultHandler, // HIM Consumer IR 0 + IntDefaultHandler, // I2C8 Master and Slave + IntDefaultHandler, // I2C9 Master and Slave + IntDefaultHandler // GPIO Port T +}; + +//***************************************************************************** +// +// This is the code that gets called when the processor first starts execution +// following a reset event. Only the absolutely necessary set is performed, +// after which the application supplied entry() routine is called. Any fancy +// actions (such as making decisions based on the reset cause register, and +// resetting the bits in that register) are left solely in the hands of the +// application. +// +//***************************************************************************** +void +ResetISR(void) +{ + // + // Jump to the CCS C initialization routine. This will enable the + // floating-point unit as well, so that does not need to be done here. + // + __asm(" .global _c_int00\n" + " b.w _c_int00"); +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a NMI. This +// simply enters an infinite loop, preserving the system state for examination +// by a debugger. +// +//***************************************************************************** +static void +NmiSR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a fault +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +FaultISR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives an unexpected +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +IntDefaultHandler(void) +{ + // + // Go into an infinite loop. + // + while(1) + { + } +} diff --git a/boards/dk-tm4c129x/usb_stick_update/startup_ewarm.c b/boards/dk-tm4c129x/usb_stick_update/startup_ewarm.c new file mode 100644 index 0000000..55e3cf3 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/startup_ewarm.c @@ -0,0 +1,307 @@ +//***************************************************************************** +// +// startup_ewarm.c - Startup code for use with IAR's Embedded Workbench, +// version 5. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#include +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" + +//***************************************************************************** +// +// Enable the IAR extensions for this source file. +// +//***************************************************************************** +#pragma language=extended + +//***************************************************************************** +// +// Forward declaration of the default fault handlers. +// +//***************************************************************************** +void ResetISR(void); +static void NmiSR(void); +static void FaultISR(void); +static void IntDefaultHandler(void); + +//***************************************************************************** +// +// External declarations for the interrupt handlers used by the application. +// +//***************************************************************************** +extern void AppForceUpdate(void); +extern void USB0HostIntHandler(void); + +//***************************************************************************** +// +// The entry point for the application startup code. +// +//***************************************************************************** +extern void __iar_program_start(void); + +//***************************************************************************** +// +// Reserve space for the system stack. +// +//***************************************************************************** +static uint32_t pui32Stack[256] @ ".noinit"; + +//***************************************************************************** +// +// A union that describes the entries of the vector table. The union is needed +// since the first entry is the stack pointer and the remainder are function +// pointers. +// +//***************************************************************************** +typedef union +{ + void (*pfnHandler)(void); + uint32_t ui32Ptr; +} +uVectorEntry; + +//***************************************************************************** +// +// The vector table. Note that the proper constructs must be placed on this to +// ensure that it ends up at physical address 0x0000.0000. +// +//***************************************************************************** +__root const uVectorEntry __vector_table[] @ ".intvec" = +{ + { .ui32Ptr = (uint32_t)pui32Stack + sizeof(pui32Stack) }, + // The initial stack pointer + ResetISR, // The reset handler + NmiSR, // The NMI handler + FaultISR, // The hard fault handler + IntDefaultHandler, // The MPU fault handler + IntDefaultHandler, // The bus fault handler + IntDefaultHandler, // The usage fault handler + 0, // Reserved + 0, // Reserved + 0, // Reserved + 0, // Reserved + AppForceUpdate, // SVCall handler + IntDefaultHandler, // Debug monitor handler + 0, // Reserved + IntDefaultHandler, // The PendSV handler + IntDefaultHandler, // The SysTick handler + IntDefaultHandler, // GPIO Port A + IntDefaultHandler, // GPIO Port B + IntDefaultHandler, // GPIO Port C + IntDefaultHandler, // GPIO Port D + IntDefaultHandler, // GPIO Port E + IntDefaultHandler, // UART0 Rx and Tx + IntDefaultHandler, // UART1 Rx and Tx + IntDefaultHandler, // SSI0 Rx and Tx + IntDefaultHandler, // I2C0 Master and Slave + IntDefaultHandler, // PWM Fault + IntDefaultHandler, // PWM Generator 0 + IntDefaultHandler, // PWM Generator 1 + IntDefaultHandler, // PWM Generator 2 + IntDefaultHandler, // Quadrature Encoder 0 + IntDefaultHandler, // ADC Sequence 0 + IntDefaultHandler, // ADC Sequence 1 + IntDefaultHandler, // ADC Sequence 2 + IntDefaultHandler, // ADC Sequence 3 + IntDefaultHandler, // Watchdog timer + IntDefaultHandler, // Timer 0 subtimer A + IntDefaultHandler, // Timer 0 subtimer B + IntDefaultHandler, // Timer 1 subtimer A + IntDefaultHandler, // Timer 1 subtimer B + IntDefaultHandler, // Timer 2 subtimer A + IntDefaultHandler, // Timer 2 subtimer B + IntDefaultHandler, // Analog Comparator 0 + IntDefaultHandler, // Analog Comparator 1 + IntDefaultHandler, // Analog Comparator 2 + IntDefaultHandler, // System Control (PLL, OSC, BO) + IntDefaultHandler, // FLASH Control + IntDefaultHandler, // GPIO Port F + IntDefaultHandler, // GPIO Port G + IntDefaultHandler, // GPIO Port H + IntDefaultHandler, // UART2 Rx and Tx + IntDefaultHandler, // SSI1 Rx and Tx + IntDefaultHandler, // Timer 3 subtimer A + IntDefaultHandler, // Timer 3 subtimer B + IntDefaultHandler, // I2C1 Master and Slave + IntDefaultHandler, // CAN0 + IntDefaultHandler, // CAN1 + IntDefaultHandler, // Ethernet + IntDefaultHandler, // Hibernate + USB0HostIntHandler, // USB0 + IntDefaultHandler, // PWM Generator 3 + IntDefaultHandler, // uDMA Software Transfer + IntDefaultHandler, // uDMA Error + IntDefaultHandler, // ADC1 Sequence 0 + IntDefaultHandler, // ADC1 Sequence 1 + IntDefaultHandler, // ADC1 Sequence 2 + IntDefaultHandler, // ADC1 Sequence 3 + IntDefaultHandler, // External Bus Interface 0 + IntDefaultHandler, // GPIO Port J + IntDefaultHandler, // GPIO Port K + IntDefaultHandler, // GPIO Port L + IntDefaultHandler, // SSI2 Rx and Tx + IntDefaultHandler, // SSI3 Rx and Tx + IntDefaultHandler, // UART3 Rx and Tx + IntDefaultHandler, // UART4 Rx and Tx + IntDefaultHandler, // UART5 Rx and Tx + IntDefaultHandler, // UART6 Rx and Tx + IntDefaultHandler, // UART7 Rx and Tx + IntDefaultHandler, // I2C2 Master and Slave + IntDefaultHandler, // I2C3 Master and Slave + IntDefaultHandler, // Timer 4 subtimer A + IntDefaultHandler, // Timer 4 subtimer B + IntDefaultHandler, // Timer 5 subtimer A + IntDefaultHandler, // Timer 5 subtimer B + IntDefaultHandler, // FPU + 0, // Reserved + 0, // Reserved + IntDefaultHandler, // I2C4 Master and Slave + IntDefaultHandler, // I2C5 Master and Slave + IntDefaultHandler, // GPIO Port M + IntDefaultHandler, // GPIO Port N + 0, // Reserved + IntDefaultHandler, // Tamper + IntDefaultHandler, // GPIO Port P (Summary or P0) + IntDefaultHandler, // GPIO Port P1 + IntDefaultHandler, // GPIO Port P2 + IntDefaultHandler, // GPIO Port P3 + IntDefaultHandler, // GPIO Port P4 + IntDefaultHandler, // GPIO Port P5 + IntDefaultHandler, // GPIO Port P6 + IntDefaultHandler, // GPIO Port P7 + IntDefaultHandler, // GPIO Port Q (Summary or Q0) + IntDefaultHandler, // GPIO Port Q1 + IntDefaultHandler, // GPIO Port Q2 + IntDefaultHandler, // GPIO Port Q3 + IntDefaultHandler, // GPIO Port Q4 + IntDefaultHandler, // GPIO Port Q5 + IntDefaultHandler, // GPIO Port Q6 + IntDefaultHandler, // GPIO Port Q7 + IntDefaultHandler, // GPIO Port R + IntDefaultHandler, // GPIO Port S + IntDefaultHandler, // SHA/MD5 0 + IntDefaultHandler, // AES 0 + IntDefaultHandler, // DES3DES 0 + IntDefaultHandler, // LCD Controller 0 + IntDefaultHandler, // Timer 6 subtimer A + IntDefaultHandler, // Timer 6 subtimer B + IntDefaultHandler, // Timer 7 subtimer A + IntDefaultHandler, // Timer 7 subtimer B + IntDefaultHandler, // I2C6 Master and Slave + IntDefaultHandler, // I2C7 Master and Slave + IntDefaultHandler, // HIM Scan Matrix Keyboard 0 + IntDefaultHandler, // One Wire 0 + IntDefaultHandler, // HIM PS/2 0 + IntDefaultHandler, // HIM LED Sequencer 0 + IntDefaultHandler, // HIM Consumer IR 0 + IntDefaultHandler, // I2C8 Master and Slave + IntDefaultHandler, // I2C9 Master and Slave + IntDefaultHandler // GPIO Port T +}; + +//***************************************************************************** +// +// This is the code that gets called when the processor first starts execution +// following a reset event. Only the absolutely necessary set is performed, +// after which the application supplied entry() routine is called. Any fancy +// actions (such as making decisions based on the reset cause register, and +// resetting the bits in that register) are left solely in the hands of the +// application. +// +//***************************************************************************** +void +ResetISR(void) +{ + // + // Enable the floating-point unit. This must be done here to handle the + // case where main() uses floating-point and the function prologue saves + // floating-point registers (which will fault if floating-point is not + // enabled). Any configuration of the floating-point unit using DriverLib + // APIs must be done here prior to the floating-point unit being enabled. + // + // Note that this does not use DriverLib since it might not be included in + // this project. + // + HWREG(NVIC_CPAC) = ((HWREG(NVIC_CPAC) & + ~(NVIC_CPAC_CP10_M | NVIC_CPAC_CP11_M)) | + NVIC_CPAC_CP10_FULL | NVIC_CPAC_CP11_FULL); + + // + // Call the application's entry point. + // + __iar_program_start(); +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a NMI. This +// simply enters an infinite loop, preserving the system state for examination +// by a debugger. +// +//***************************************************************************** +static void +NmiSR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a fault +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +FaultISR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives an unexpected +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +IntDefaultHandler(void) +{ + // + // Go into an infinite loop. + // + while(1) + { + } +} diff --git a/boards/dk-tm4c129x/usb_stick_update/startup_gcc.c b/boards/dk-tm4c129x/usb_stick_update/startup_gcc.c new file mode 100644 index 0000000..6e9a465 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/startup_gcc.c @@ -0,0 +1,323 @@ +//***************************************************************************** +// +// startup_gcc.c - Startup code for use with GNU tools. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#include +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" + +//***************************************************************************** +// +// Forward declaration of the default fault handlers. +// +//***************************************************************************** +void ResetISR(void); +static void NmiSR(void); +static void FaultISR(void); +static void IntDefaultHandler(void); + +//***************************************************************************** +// +// External declarations for the interrupt handlers used by the application. +// +//***************************************************************************** +extern void AppForceUpdate(void); +extern void USB0HostIntHandler(void); + +//***************************************************************************** +// +// The entry point for the application. +// +//***************************************************************************** +extern int main(void); + +//***************************************************************************** +// +// Reserve space for the system stack. +// +//***************************************************************************** +static uint32_t pui32Stack[256]; + +//***************************************************************************** +// +// The vector table. Note that the proper constructs must be placed on this to +// ensure that it ends up at physical address 0x0000.0000. +// +//***************************************************************************** +__attribute__ ((section(".isr_vector"))) +void (* const g_pfnVectors[])(void) = +{ + (void (*)(void))((uint32_t)pui32Stack + sizeof(pui32Stack)), + // The initial stack pointer + ResetISR, // The reset handler + NmiSR, // The NMI handler + FaultISR, // The hard fault handler + IntDefaultHandler, // The MPU fault handler + IntDefaultHandler, // The bus fault handler + IntDefaultHandler, // The usage fault handler + 0, // Reserved + 0, // Reserved + 0, // Reserved + 0, // Reserved + AppForceUpdate, // SVCall handler + IntDefaultHandler, // Debug monitor handler + 0, // Reserved + IntDefaultHandler, // The PendSV handler + IntDefaultHandler, // The SysTick handler + IntDefaultHandler, // GPIO Port A + IntDefaultHandler, // GPIO Port B + IntDefaultHandler, // GPIO Port C + IntDefaultHandler, // GPIO Port D + IntDefaultHandler, // GPIO Port E + IntDefaultHandler, // UART0 Rx and Tx + IntDefaultHandler, // UART1 Rx and Tx + IntDefaultHandler, // SSI0 Rx and Tx + IntDefaultHandler, // I2C0 Master and Slave + IntDefaultHandler, // PWM Fault + IntDefaultHandler, // PWM Generator 0 + IntDefaultHandler, // PWM Generator 1 + IntDefaultHandler, // PWM Generator 2 + IntDefaultHandler, // Quadrature Encoder 0 + IntDefaultHandler, // ADC Sequence 0 + IntDefaultHandler, // ADC Sequence 1 + IntDefaultHandler, // ADC Sequence 2 + IntDefaultHandler, // ADC Sequence 3 + IntDefaultHandler, // Watchdog timer + IntDefaultHandler, // Timer 0 subtimer A + IntDefaultHandler, // Timer 0 subtimer B + IntDefaultHandler, // Timer 1 subtimer A + IntDefaultHandler, // Timer 1 subtimer B + IntDefaultHandler, // Timer 2 subtimer A + IntDefaultHandler, // Timer 2 subtimer B + IntDefaultHandler, // Analog Comparator 0 + IntDefaultHandler, // Analog Comparator 1 + IntDefaultHandler, // Analog Comparator 2 + IntDefaultHandler, // System Control (PLL, OSC, BO) + IntDefaultHandler, // FLASH Control + IntDefaultHandler, // GPIO Port F + IntDefaultHandler, // GPIO Port G + IntDefaultHandler, // GPIO Port H + IntDefaultHandler, // UART2 Rx and Tx + IntDefaultHandler, // SSI1 Rx and Tx + IntDefaultHandler, // Timer 3 subtimer A + IntDefaultHandler, // Timer 3 subtimer B + IntDefaultHandler, // I2C1 Master and Slave + IntDefaultHandler, // CAN0 + IntDefaultHandler, // CAN1 + IntDefaultHandler, // Ethernet + IntDefaultHandler, // Hibernate + USB0HostIntHandler, // USB0 + IntDefaultHandler, // PWM Generator 3 + IntDefaultHandler, // uDMA Software Transfer + IntDefaultHandler, // uDMA Error + IntDefaultHandler, // ADC1 Sequence 0 + IntDefaultHandler, // ADC1 Sequence 1 + IntDefaultHandler, // ADC1 Sequence 2 + IntDefaultHandler, // ADC1 Sequence 3 + IntDefaultHandler, // External Bus Interface 0 + IntDefaultHandler, // GPIO Port J + IntDefaultHandler, // GPIO Port K + IntDefaultHandler, // GPIO Port L + IntDefaultHandler, // SSI2 Rx and Tx + IntDefaultHandler, // SSI3 Rx and Tx + IntDefaultHandler, // UART3 Rx and Tx + IntDefaultHandler, // UART4 Rx and Tx + IntDefaultHandler, // UART5 Rx and Tx + IntDefaultHandler, // UART6 Rx and Tx + IntDefaultHandler, // UART7 Rx and Tx + IntDefaultHandler, // I2C2 Master and Slave + IntDefaultHandler, // I2C3 Master and Slave + IntDefaultHandler, // Timer 4 subtimer A + IntDefaultHandler, // Timer 4 subtimer B + IntDefaultHandler, // Timer 5 subtimer A + IntDefaultHandler, // Timer 5 subtimer B + IntDefaultHandler, // FPU + 0, // Reserved + 0, // Reserved + IntDefaultHandler, // I2C4 Master and Slave + IntDefaultHandler, // I2C5 Master and Slave + IntDefaultHandler, // GPIO Port M + IntDefaultHandler, // GPIO Port N + 0, // Reserved + IntDefaultHandler, // Tamper + IntDefaultHandler, // GPIO Port P (Summary or P0) + IntDefaultHandler, // GPIO Port P1 + IntDefaultHandler, // GPIO Port P2 + IntDefaultHandler, // GPIO Port P3 + IntDefaultHandler, // GPIO Port P4 + IntDefaultHandler, // GPIO Port P5 + IntDefaultHandler, // GPIO Port P6 + IntDefaultHandler, // GPIO Port P7 + IntDefaultHandler, // GPIO Port Q (Summary or Q0) + IntDefaultHandler, // GPIO Port Q1 + IntDefaultHandler, // GPIO Port Q2 + IntDefaultHandler, // GPIO Port Q3 + IntDefaultHandler, // GPIO Port Q4 + IntDefaultHandler, // GPIO Port Q5 + IntDefaultHandler, // GPIO Port Q6 + IntDefaultHandler, // GPIO Port Q7 + IntDefaultHandler, // GPIO Port R + IntDefaultHandler, // GPIO Port S + IntDefaultHandler, // SHA/MD5 0 + IntDefaultHandler, // AES 0 + IntDefaultHandler, // DES3DES 0 + IntDefaultHandler, // LCD Controller 0 + IntDefaultHandler, // Timer 6 subtimer A + IntDefaultHandler, // Timer 6 subtimer B + IntDefaultHandler, // Timer 7 subtimer A + IntDefaultHandler, // Timer 7 subtimer B + IntDefaultHandler, // I2C6 Master and Slave + IntDefaultHandler, // I2C7 Master and Slave + IntDefaultHandler, // HIM Scan Matrix Keyboard 0 + IntDefaultHandler, // One Wire 0 + IntDefaultHandler, // HIM PS/2 0 + IntDefaultHandler, // HIM LED Sequencer 0 + IntDefaultHandler, // HIM Consumer IR 0 + IntDefaultHandler, // I2C8 Master and Slave + IntDefaultHandler, // I2C9 Master and Slave + IntDefaultHandler // GPIO Port T +}; + +//***************************************************************************** +// +// The following are constructs created by the linker, indicating where the +// the "data" and "bss" segments reside in memory. The initializers for the +// for the "data" segment resides immediately following the "text" segment. +// +//***************************************************************************** +extern uint32_t _etext; +extern uint32_t _data; +extern uint32_t _edata; +extern uint32_t _bss; +extern uint32_t _ebss; + +//***************************************************************************** +// +// This is the code that gets called when the processor first starts execution +// following a reset event. Only the absolutely necessary set is performed, +// after which the application supplied entry() routine is called. Any fancy +// actions (such as making decisions based on the reset cause register, and +// resetting the bits in that register) are left solely in the hands of the +// application. +// +//***************************************************************************** +void +ResetISR(void) +{ + uint32_t *pui32Src, *pui32Dest; + + // + // Copy the data segment initializers from flash to SRAM. + // + pui32Src = &_etext; + for(pui32Dest = &_data; pui32Dest < &_edata; ) + { + *pui32Dest++ = *pui32Src++; + } + + // + // Zero fill the bss segment. + // + __asm(" ldr r0, =_bss\n" + " ldr r1, =_ebss\n" + " mov r2, #0\n" + " .thumb_func\n" + "zero_loop:\n" + " cmp r0, r1\n" + " it lt\n" + " strlt r2, [r0], #4\n" + " blt zero_loop"); + + // + // Enable the floating-point unit. This must be done here to handle the + // case where main() uses floating-point and the function prologue saves + // floating-point registers (which will fault if floating-point is not + // enabled). Any configuration of the floating-point unit using DriverLib + // APIs must be done here prior to the floating-point unit being enabled. + // + // Note that this does not use DriverLib since it might not be included in + // this project. + // + HWREG(NVIC_CPAC) = ((HWREG(NVIC_CPAC) & + ~(NVIC_CPAC_CP10_M | NVIC_CPAC_CP11_M)) | + NVIC_CPAC_CP10_FULL | NVIC_CPAC_CP11_FULL); + + // + // Call the application's entry point. + // + main(); +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a NMI. This +// simply enters an infinite loop, preserving the system state for examination +// by a debugger. +// +//***************************************************************************** +static void +NmiSR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives a fault +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +FaultISR(void) +{ + // + // Enter an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// This is the code that gets called when the processor receives an unexpected +// interrupt. This simply enters an infinite loop, preserving the system state +// for examination by a debugger. +// +//***************************************************************************** +static void +IntDefaultHandler(void) +{ + // + // Go into an infinite loop. + // + while(1) + { + } +} diff --git a/boards/dk-tm4c129x/usb_stick_update/startup_rvmdk.S b/boards/dk-tm4c129x/usb_stick_update/startup_rvmdk.S new file mode 100644 index 0000000..7d18e70 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/startup_rvmdk.S @@ -0,0 +1,332 @@ +; <<< Use Configuration Wizard in Context Menu >>> +;****************************************************************************** +; +; startup_rvmdk.S - Startup code for use with Keil's uVision. +; +; Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +; Software License Agreement +; +; Texas Instruments (TI) is supplying this software for use solely and +; exclusively on TI's microcontroller products. The software is owned by +; TI and/or its suppliers, and is protected under applicable copyright +; laws. You may not combine this software with "viral" open-source +; software in order to form a larger program. +; +; THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +; NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +; NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +; A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +; CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +; DAMAGES, FOR ANY REASON WHATSOEVER. +; +; This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +; +;****************************************************************************** + +;****************************************************************************** +; +; Stack Size (in Bytes) <0x0-0xFFFFFFFF:8> +; +;****************************************************************************** +Stack EQU 0x00000400 + +;****************************************************************************** +; +; Heap Size (in Bytes) <0x0-0xFFFFFFFF:8> +; +;****************************************************************************** +Heap EQU 0x00000000 + +;****************************************************************************** +; +; Allocate space for the stack. +; +;****************************************************************************** + AREA STACK, NOINIT, READWRITE, ALIGN=3 +StackMem + SPACE Stack +__initial_sp + +;****************************************************************************** +; +; Allocate space for the heap. +; +;****************************************************************************** + AREA HEAP, NOINIT, READWRITE, ALIGN=3 +__heap_base +HeapMem + SPACE Heap +__heap_limit + +;****************************************************************************** +; +; Indicate that the code in this file preserves 8-byte alignment of the stack. +; +;****************************************************************************** + PRESERVE8 + +;****************************************************************************** +; +; Place code into the reset code section. +; +;****************************************************************************** + AREA RESET, CODE, READONLY + THUMB + +;****************************************************************************** +; +; External declarations for the interrupt handlers used by the application. +; +;****************************************************************************** + EXTERN AppForceUpdate + EXTERN USB0HostIntHandler + +;****************************************************************************** +; +; The vector table. +; +;****************************************************************************** + EXPORT __Vectors +__Vectors + DCD StackMem + Stack ; Top of Stack + DCD Reset_Handler ; Reset Handler + DCD NmiSR ; NMI Handler + DCD FaultISR ; Hard Fault Handler + DCD IntDefaultHandler ; The MPU fault handler + DCD IntDefaultHandler ; The bus fault handler + DCD IntDefaultHandler ; The usage fault handler + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD AppForceUpdate ; SVCall handler + DCD IntDefaultHandler ; Debug monitor handler + DCD 0 ; Reserved + DCD IntDefaultHandler ; The PendSV handler + DCD IntDefaultHandler ; The SysTick handler + DCD IntDefaultHandler ; GPIO Port A + DCD IntDefaultHandler ; GPIO Port B + DCD IntDefaultHandler ; GPIO Port C + DCD IntDefaultHandler ; GPIO Port D + DCD IntDefaultHandler ; GPIO Port E + DCD IntDefaultHandler ; UART0 Rx and Tx + DCD IntDefaultHandler ; UART1 Rx and Tx + DCD IntDefaultHandler ; SSI0 Rx and Tx + DCD IntDefaultHandler ; I2C0 Master and Slave + DCD IntDefaultHandler ; PWM Fault + DCD IntDefaultHandler ; PWM Generator 0 + DCD IntDefaultHandler ; PWM Generator 1 + DCD IntDefaultHandler ; PWM Generator 2 + DCD IntDefaultHandler ; Quadrature Encoder 0 + DCD IntDefaultHandler ; ADC Sequence 0 + DCD IntDefaultHandler ; ADC Sequence 1 + DCD IntDefaultHandler ; ADC Sequence 2 + DCD IntDefaultHandler ; ADC Sequence 3 + DCD IntDefaultHandler ; Watchdog timer + DCD IntDefaultHandler ; Timer 0 subtimer A + DCD IntDefaultHandler ; Timer 0 subtimer B + DCD IntDefaultHandler ; Timer 1 subtimer A + DCD IntDefaultHandler ; Timer 1 subtimer B + DCD IntDefaultHandler ; Timer 2 subtimer A + DCD IntDefaultHandler ; Timer 2 subtimer B + DCD IntDefaultHandler ; Analog Comparator 0 + DCD IntDefaultHandler ; Analog Comparator 1 + DCD IntDefaultHandler ; Analog Comparator 2 + DCD IntDefaultHandler ; System Control (PLL, OSC, BO) + DCD IntDefaultHandler ; FLASH Control + DCD IntDefaultHandler ; GPIO Port F + DCD IntDefaultHandler ; GPIO Port G + DCD IntDefaultHandler ; GPIO Port H + DCD IntDefaultHandler ; UART2 Rx and Tx + DCD IntDefaultHandler ; SSI1 Rx and Tx + DCD IntDefaultHandler ; Timer 3 subtimer A + DCD IntDefaultHandler ; Timer 3 subtimer B + DCD IntDefaultHandler ; I2C1 Master and Slave + DCD IntDefaultHandler ; CAN0 + DCD IntDefaultHandler ; CAN1 + DCD IntDefaultHandler ; Ethernet + DCD IntDefaultHandler ; Hibernate + DCD USB0HostIntHandler ; USB0 + DCD IntDefaultHandler ; PWM Generator 3 + DCD IntDefaultHandler ; uDMA Software Transfer + DCD IntDefaultHandler ; uDMA Error + DCD IntDefaultHandler ; ADC1 Sequence 0 + DCD IntDefaultHandler ; ADC1 Sequence 1 + DCD IntDefaultHandler ; ADC1 Sequence 2 + DCD IntDefaultHandler ; ADC1 Sequence 3 + DCD IntDefaultHandler ; External Bus Interface 0 + DCD IntDefaultHandler ; GPIO Port J + DCD IntDefaultHandler ; GPIO Port K + DCD IntDefaultHandler ; GPIO Port L + DCD IntDefaultHandler ; SSI2 Rx and Tx + DCD IntDefaultHandler ; SSI3 Rx and Tx + DCD IntDefaultHandler ; UART3 Rx and Tx + DCD IntDefaultHandler ; UART4 Rx and Tx + DCD IntDefaultHandler ; UART5 Rx and Tx + DCD IntDefaultHandler ; UART6 Rx and Tx + DCD IntDefaultHandler ; UART7 Rx and Tx + DCD IntDefaultHandler ; I2C2 Master and Slave + DCD IntDefaultHandler ; I2C3 Master and Slave + DCD IntDefaultHandler ; Timer 4 subtimer A + DCD IntDefaultHandler ; Timer 4 subtimer B + DCD IntDefaultHandler ; Timer 5 subtimer A + DCD IntDefaultHandler ; Timer 5 subtimer B + DCD IntDefaultHandler ; FPU + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD IntDefaultHandler ; I2C4 Master and Slave + DCD IntDefaultHandler ; I2C5 Master and Slave + DCD IntDefaultHandler ; GPIO Port M + DCD IntDefaultHandler ; GPIO Port N + DCD 0 ; Reserved + DCD IntDefaultHandler ; Tamper + DCD IntDefaultHandler ; GPIO Port P (Summary or P0) + DCD IntDefaultHandler ; GPIO Port P1 + DCD IntDefaultHandler ; GPIO Port P2 + DCD IntDefaultHandler ; GPIO Port P3 + DCD IntDefaultHandler ; GPIO Port P4 + DCD IntDefaultHandler ; GPIO Port P5 + DCD IntDefaultHandler ; GPIO Port P6 + DCD IntDefaultHandler ; GPIO Port P7 + DCD IntDefaultHandler ; GPIO Port Q (Summary or Q0) + DCD IntDefaultHandler ; GPIO Port Q1 + DCD IntDefaultHandler ; GPIO Port Q2 + DCD IntDefaultHandler ; GPIO Port Q3 + DCD IntDefaultHandler ; GPIO Port Q4 + DCD IntDefaultHandler ; GPIO Port Q5 + DCD IntDefaultHandler ; GPIO Port Q6 + DCD IntDefaultHandler ; GPIO Port Q7 + DCD IntDefaultHandler ; GPIO Port R + DCD IntDefaultHandler ; GPIO Port S + DCD IntDefaultHandler ; SHA/MD5 0 + DCD IntDefaultHandler ; AES 0 + DCD IntDefaultHandler ; DES3DES 0 + DCD IntDefaultHandler ; LCD Controller 0 + DCD IntDefaultHandler ; Timer 6 subtimer A + DCD IntDefaultHandler ; Timer 6 subtimer B + DCD IntDefaultHandler ; Timer 7 subtimer A + DCD IntDefaultHandler ; Timer 7 subtimer B + DCD IntDefaultHandler ; I2C6 Master and Slave + DCD IntDefaultHandler ; I2C7 Master and Slave + DCD IntDefaultHandler ; HIM Scan Matrix Keyboard 0 + DCD IntDefaultHandler ; One Wire 0 + DCD IntDefaultHandler ; HIM PS/2 0 + DCD IntDefaultHandler ; HIM LED Sequencer 0 + DCD IntDefaultHandler ; HIM Consumer IR 0 + DCD IntDefaultHandler ; I2C8 Master and Slave + DCD IntDefaultHandler ; I2C9 Master and Slave + DCD IntDefaultHandler ; GPIO Port T + +;****************************************************************************** +; +; This is the code that gets called when the processor first starts execution +; following a reset event. +; +;****************************************************************************** + EXPORT Reset_Handler +Reset_Handler + ; + ; Enable the floating-point unit. This must be done here to handle the + ; case where main() uses floating-point and the function prologue saves + ; floating-point registers (which will fault if floating-point is not + ; enabled). Any configuration of the floating-point unit using + ; DriverLib APIs must be done here prior to the floating-point unit + ; being enabled. + ; + ; Note that this does not use DriverLib since it might not be included + ; in this project. + ; + MOVW R0, #0xED88 + MOVT R0, #0xE000 + LDR R1, [R0] + ORR R1, #0x00F00000 + STR R1, [R0] + + ; + ; Call the C library enty point that handles startup. This will copy + ; the .data section initializers from flash to SRAM and zero fill the + ; .bss section. + ; + IMPORT __main + B __main + +;****************************************************************************** +; +; This is the code that gets called when the processor receives a NMI. This +; simply enters an infinite loop, preserving the system state for examination +; by a debugger. +; +;****************************************************************************** +NmiSR + B NmiSR + +;****************************************************************************** +; +; This is the code that gets called when the processor receives a fault +; interrupt. This simply enters an infinite loop, preserving the system state +; for examination by a debugger. +; +;****************************************************************************** +FaultISR + B FaultISR + +;****************************************************************************** +; +; This is the code that gets called when the processor receives an unexpected +; interrupt. This simply enters an infinite loop, preserving the system state +; for examination by a debugger. +; +;****************************************************************************** +IntDefaultHandler + B IntDefaultHandler + +;****************************************************************************** +; +; Make sure the end of this section is aligned. +; +;****************************************************************************** + ALIGN + +;****************************************************************************** +; +; Some code in the normal code section for initializing the heap and stack. +; +;****************************************************************************** + AREA |.text|, CODE, READONLY + +;****************************************************************************** +; +; The function expected of the C library startup code for defining the stack +; and heap memory locations. For the C library version of the startup code, +; provide this function so that the C library initialization code can find out +; the location of the stack and heap. +; +;****************************************************************************** + IF :DEF: __MICROLIB + EXPORT __initial_sp + EXPORT __heap_base + EXPORT __heap_limit + ELSE + IMPORT __use_two_region_memory + EXPORT __user_initial_stackheap +__user_initial_stackheap + LDR R0, =HeapMem + LDR R1, =(StackMem + Stack) + LDR R2, =(HeapMem + Heap) + LDR R3, =StackMem + BX LR + ENDIF + +;****************************************************************************** +; +; Make sure the end of this section is aligned. +; +;****************************************************************************** + ALIGN + +;****************************************************************************** +; +; Tell the assembler that we're done. +; +;****************************************************************************** + END diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.c b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.c new file mode 100644 index 0000000..8281c2c --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.c @@ -0,0 +1,942 @@ +//***************************************************************************** +// +// usb_stick_update.c - Example to update flash from a USB memory stick. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +#include +#include +#include +#include "inc/hw_flash.h" +#include "inc/hw_gpio.h" +#include "inc/hw_memmap.h" +#include "inc/hw_nvic.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/gpio.h" +#include "driverlib/pin_map.h" +#include "driverlib/rom.h" +#include "driverlib/rom_map.h" +#include "driverlib/sysctl.h" +#include "driverlib/udma.h" +#include "usblib/usblib.h" +#include "usblib/usbmsc.h" +#include "usblib/host/usbhost.h" +#include "usblib/host/usbhmsc.h" +#include "simple_fs.h" + +//***************************************************************************** +// +//! \addtogroup example_list +//!

USB Memory Stick Updater (usb_stick_update)

+//! +//! This example application behaves the same way as a boot loader. It resides +//! at the beginning of flash, and will read a binary file from a USB memory +//! stick and program it into another location in flash. Once the user +//! application has been programmed into flash, this program will always start +//! the user application until requested to load a new application. +//! +//! When this application starts, if there is a user application already in +//! flash (at \b APP_START_ADDRESS), then it will just run the user application. +//! It will attempt to load a new application from a USB memory stick under +//! the following conditions: +//! +//! - no user application is present at \b APP_START_ADDRESS +//! - the user application has requested an update by transferring control +//! to the updater +//! - the user holds down the eval board push button when the board is reset +//! +//! When this application is attempting to perform an update, it will wait +//! forever for a USB memory stick to be plugged in. Once a USB memory stick +//! is found, it will search the root directory for a specific file name, which +//! is \e FIRMWARE.BIN by default. This file must be a binary image of the +//! program you want to load (the .bin file), linked to run from the correct +//! address, at \b APP_START_ADDRESS. +//! +//! The USB memory stick must be formatted as a FAT16 or FAT32 file system +//! (the normal case), and the binary file must be located in the root +//! directory. Other files can exist on the memory stick but they will be +//! ignored. +// +//***************************************************************************** + +//***************************************************************************** +// +// Defines the number of times to call to check if the attached device is +// ready. +// +//***************************************************************************** +#define USBMSC_DRIVE_RETRY 4 + +//***************************************************************************** +// +// The name of the binary firmware file on the USB stick. This is the user +// application that will be searched for and loaded into flash if it is found. +// Note that the name of the file must be 11 characters total, 8 for the base +// name and 3 for the extension. If the actual file name has fewer characters +// then it must be padded with spaces. This macro should not contain the dot +// "." for the extension. +// +// Examples: firmware.bin --> "FIRMWAREBIN" +// myfile.bn --> "MYFILE BN " +// +//***************************************************************************** +#define USB_UPDATE_FILENAME "FIRMWAREBIN" + +//***************************************************************************** +// +// The size of the flash for this microcontroller. +// +//***************************************************************************** +#define FLASH_SIZE (1 * 1024 * 1024) + +//***************************************************************************** +// +// The starting address for the application that will be loaded into flash +// memory from the USB stick. This address must be high enough to be above +// the USB stick updater, and must be on a 1K boundary. +// Note that the application that will be loaded must also be linked to run +// from this address. +// +//***************************************************************************** +#define APP_START_ADDRESS 0x8000 + +//***************************************************************************** +// +// A memory location and value that is used to indicate that the application +// wants to force an update. +// +//***************************************************************************** +#define FORCE_UPDATE_ADDR 0x20004000 +#define FORCE_UPDATE_VALUE 0x1234cdef + +//***************************************************************************** +// +// The prototype for the function that is used to call the user application. +// +//***************************************************************************** +void CallApplication(uint_fast32_t ui32StartAddr); + +//***************************************************************************** +// +// The control table used by the uDMA controller. This table must be aligned +// to a 1024 byte boundary. In this application uDMA is only used for USB, +// so only the first 6 channels are needed. +// +//***************************************************************************** +#if defined(ewarm) +#pragma data_alignment=1024 +tDMAControlTable g_sDMAControlTable[6]; +#elif defined(ccs) +#pragma DATA_ALIGN(g_sDMAControlTable, 1024) +tDMAControlTable g_sDMAControlTable[6]; +#else +tDMAControlTable g_sDMAControlTable[6] __attribute__ ((aligned(1024))); +#endif + +//***************************************************************************** +// +// The global that holds all of the host drivers in use in the application. +// In this case, only the MSC class is loaded. +// +//***************************************************************************** +static tUSBHostClassDriver const * const g_ppHostClassDrivers[] = +{ + &g_sUSBHostMSCClassDriver +}; + +//***************************************************************************** +// +// This global holds the number of class drivers in the g_ppHostClassDrivers +// list. +// +//***************************************************************************** +#define NUM_CLASS_DRIVERS (sizeof(g_ppHostClassDrivers) / \ + sizeof(g_ppHostClassDrivers[0])) + +//***************************************************************************** +// +// Hold the current state for the application. +// +//***************************************************************************** +volatile enum +{ + // + // No device is present. + // + STATE_NO_DEVICE, + + // + // Mass storage device is being enumerated. + // + STATE_DEVICE_ENUM, +} +g_eState; + +//***************************************************************************** +// +// The instance data for the MSC driver. +// +//***************************************************************************** +tUSBHMSCInstance *g_psMSCInstance = 0; + +//***************************************************************************** +// +// The size of the host controller's memory pool in bytes. +// +//***************************************************************************** +#define HCD_MEMORY_SIZE 128 + +//***************************************************************************** +// +// The memory pool to provide to the Host controller driver. +// +//***************************************************************************** +uint8_t g_pHCDPool[HCD_MEMORY_SIZE]; + +//***************************************************************************** +// +// A buffer for holding sectors read from the storage device +// +//***************************************************************************** +static uint8_t g_ui8SectorBuf[512]; + +//***************************************************************************** +// +// Global to hold the clock rate. Set once read many. +// +//***************************************************************************** +uint32_t g_ui32SysClock; + +//***************************************************************************** +// +// The error routine that is called if the driver library encounters an error. +// +//***************************************************************************** +#ifdef DEBUG +void +__error__(char *pcFilename, uint32_t ui32Line) +{ +} +#endif + +//***************************************************************************** +// +// Read a sector from the USB mass storage device. +// +// \param ui32Sector is the sector to read from the connected USB mass storage +// device (memory stick) +// \param pui8Buf is a pointer to the buffer where the sector data should be +// stored +// +// This is the application-specific implementation of a function to read +// sectors from a storage device, in this case a USB mass storage device. +// This function is called from the \e simple_fs.c file when it needs to read +// data from the storage device. +// +// \return Non-zero if data was read from the device, 0 if no data was read. +// +//***************************************************************************** +uint32_t +SimpleFsReadMediaSector(uint_fast32_t ui32Sector, uint8_t *pui8Buf) +{ + // + // Return the requested sector from the connected USB mass storage + // device. + // + return(USBHMSCBlockRead(g_psMSCInstance, ui32Sector, pui8Buf, 1)); +} + +//***************************************************************************** +// +// This is the callback from the MSC driver. +// +// \param ui32Instance is the driver instance which is needed when communicating +// with the driver. +// \param ui32Event is one of the events defined by the driver. +// \param pvData is a pointer to data passed into the initial call to register +// the callback. +// +// This function handles callback events from the MSC driver. The only events +// currently handled are the \b MSC_EVENT_OPEN and \b MSC_EVENT_CLOSE. This +// allows the main routine to know when an MSC device has been detected and +// enumerated and when an MSC device has been removed from the system. +// +// \return Returns \e true on success or \e false on failure. +// +//***************************************************************************** +static void +MSCCallback(tUSBHMSCInstance *psMSCInstance, uint32_t ui32Event, void *pvData) +{ + // + // Determine the event. + // + switch(ui32Event) + { + // + // Called when the device driver has successfully enumerated an MSC + // device. + // + case MSC_EVENT_OPEN: + { + // + // Proceed to the enumeration state. + // + g_eState = STATE_DEVICE_ENUM; + break; + } + + // + // Called when the device driver has been unloaded due to error or + // the device is no longer present. + // + case MSC_EVENT_CLOSE: + { + // + // Go back to the "no device" state and wait for a new connection. + // + g_eState = STATE_NO_DEVICE; + break; + } + + default: + { + break; + } + } +} + +//***************************************************************************** +// +// Read the application image from the file system and program it into flash. +// +// This function will attempt to open and read the firmware image file from +// the mass storage device. If the file is found it will be programmed into +// flash. The name of the file to be read is configured by the macro +// \b USB_UPDATE_FILENAME. It will be programmed into flash starting at the +// address specified by APP_START_ADDRESS. +// +// \return Zero if successful or non-zero if the file cannot be read or +// programmed. +// +//***************************************************************************** +uint32_t +ReadAppAndProgram(void) +{ + uint_fast32_t ui32FlashEnd; + uint_fast32_t ui32FileSize; + uint_fast32_t ui32DataSize; + uint_fast32_t ui32Remaining; + uint_fast32_t ui32ProgAddr; + uint_fast32_t ui32SavedRegs[2]; + volatile uint_fast32_t ui32Idx; + uint_fast32_t ui32DriveTimeout; + + // + // Initialize the drive timeout. + // + ui32DriveTimeout = USBMSC_DRIVE_RETRY; + + // + // Check to see if the mass storage device is ready. Some large drives + // take a while to be ready, so retry until they are ready. + // + while(USBHMSCDriveReady(g_psMSCInstance)) + { + // + // Wait about 500ms before attempting to check if the + // device is ready again. + // + SysCtlDelay(g_ui32SysClock/(3*2)); + + // + // Decrement the retry count. + // + ui32DriveTimeout--; + + // + // If the timeout is hit then return with a failure. + // + if(ui32DriveTimeout == 0) + { + return(1); + } + } + + // + // Initialize the file system and return if error. + // + if(SimpleFsInit(g_ui8SectorBuf)) + { + return(1); + } + + // + // Attempt to open the firmware file, retrieving the file/image size. + // A file size of error means the file was not there, or there was an + // error. + // + ui32FileSize = SimpleFsOpen(USB_UPDATE_FILENAME); + if(ui32FileSize == 0) + { + return(1); + } + + // + // Get the size of flash. This is the ending address of the flash. + // If reserved space is configured, then the ending address is reduced + // by the amount of the reserved block. + // + ui32FlashEnd = FLASH_SIZE; +#ifdef FLASH_RSVD_SPACE + ui32FlashEnd -= FLASH_RSVD_SPACE; +#endif + + // + // If flash code protection is not used, then change the ending address + // to be the ending of the application image. This will be the highest + // flash page that will be erased and so only the necessary pages will + // be erased. If flash code protection is enabled, then all of the + // application area pages will be erased. + // +#ifndef FLASH_CODE_PROTECTION + ui32FlashEnd = ui32FileSize + APP_START_ADDRESS; +#endif + + // + // Check to make sure the file size is not too large to fit in the flash. + // If it is too large, then return an error. + // + if((ui32FileSize + APP_START_ADDRESS) > ui32FlashEnd) + { + return(1); + } + + // + // Enter a loop to erase all the requested flash pages beginning at the + // application start address (above the USB stick updater). + // + for(ui32Idx = APP_START_ADDRESS; ui32Idx < ui32FlashEnd; ui32Idx += 1024) + { + ROM_FlashErase(ui32Idx); + } + + // + // Enter a loop to read sectors from the application image file and + // program into flash. Start at the user app start address (above the USB + // stick updater). + // + ui32ProgAddr = APP_START_ADDRESS; + ui32Remaining = ui32FileSize; + while(SimpleFsReadFileSector()) + { + // + // Compute how much data was read from this sector and adjust the + // remaining amount. + // + ui32DataSize = ui32Remaining >= 512 ? 512 : ui32Remaining; + ui32Remaining -= ui32DataSize; + + // + // Special handling for the first block of the application. + // This block contains as the first two location the application's + // initial stack pointer and instruction pointer. The USB updater + // relied on the values in these locations to determine if a valid + // application is present. When there is a valid application the + // updater runs the user application. Otherwise the updater attempts + // to load a new application. + // In order to prevent a partially programmed imaged (due to some + // error occurring while programming), the first two locations are + // not programmed until all of the rest of the image has been + // successfully loaded into the flash. This way if there is some error, + // the updater will detect that a user application is not present and + // will not attempt to run it. + // + // For the first block, do not program the first two word locations + // (8 bytes). These two words will be programmed later, after + // everything else. + // + if(ui32ProgAddr == APP_START_ADDRESS) + { + uint32_t *pui32Temp; + + pui32Temp = (uint32_t *)g_ui8SectorBuf; + ui32SavedRegs[0] = pui32Temp[0]; + ui32SavedRegs[1] = pui32Temp[1]; + + // + // Call the function to program a block of flash. Skip the first + // two words (8 bytes) since these contain the initial SP and PC. + // + ROM_FlashProgram((uint32_t *)&g_ui8SectorBuf[8], + ui32ProgAddr + 8, + ((ui32DataSize - 8) + 3) & ~3); + } + + // + // All other blocks except the first block + // + else + { + // + // Call the function to program a block of flash. The length of the + // block passed to the flash function must be divisible by 4. + // + ROM_FlashProgram((uint32_t *)g_ui8SectorBuf, ui32ProgAddr, + (ui32DataSize + 3) & ~3); + } + + // + // If there is more image to program, then update the programming + // address. Progress will continue to the next iteration of + // the while loop. + // + if(ui32Remaining) + { + ui32ProgAddr += ui32DataSize; + } + + // + // Otherwise we are done programming so perform final steps. + // Program the first two words of the image that were saved earlier, + // and return a success indication. + // + else + { + ROM_FlashProgram((uint32_t *)ui32SavedRegs, APP_START_ADDRESS, + 8); + + return(0); + } + } + + // + // If we make it here, that means that an attempt to read a sector of + // data from the device was not successful. That means that the complete + // user app has not been programmed into flash, so just return an error + // indication. + // + return(1); +} + +//***************************************************************************** +// +// This is the main routine for performing an update from a mass storage +// device. +// +// This function forms the main loop of the USB stick updater. It polls for +// a USB mass storage device to be connected, Once a device is connected +// it will attempt to read a firmware image from the device and load it into +// flash. +// +// \return None. +// +//***************************************************************************** +void +UpdaterUSB(void) +{ + // + // Loop forever, running the USB host driver. + // + while(1) + { + USBHCDMain(); + + // + // Check for a state change from the USB driver. + // + switch(g_eState) + { + // + // This state means that a mass storage device has been + // plugged in and enumerated. + // + case STATE_DEVICE_ENUM: + { + // + // Attempt to read the application image from the storage + // device and load it into flash memory. + // + if(ReadAppAndProgram()) + { + // + // There was some error reading or programming the app, + // so reset the state to no device which will cause a + // wait for a new device to be plugged in. + // + g_eState = STATE_NO_DEVICE; + } + else + { + // + // User app load and programming was successful, so reboot + // the micro. Perform a software reset request. This + // will cause the microcontroller to reset; no further + // code will be executed. + // + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | + NVIC_APINT_SYSRESETREQ; + + // + // The microcontroller should have reset, so this should + // never be reached. Just in case, loop forever. + // + while(1) + { + } + } + break; + } + + // + // This state means that there is no device present, so just + // do nothing until something is plugged in. + // + case STATE_NO_DEVICE: + { + break; + } + } + } +} + +//***************************************************************************** +// +// Configure the USB controller and power the bus. +// +// This function configures the USB controller for host operation. +// It is assumed that the main system clock has been configured at this point. +// +// \return None. +// +//***************************************************************************** +void +ConfigureUSBInterface(void) +{ + // + // Enable the uDMA controller and set up the control table base. + // This is required by usblib. + // + SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); + SysCtlDelay(80); + uDMAEnable(); + uDMAControlBaseSet(g_sDMAControlTable); + + // + // Enable the USB controller. + // + ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); + + // + // Set the USB pins to be controlled by the USB controller. + // + ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); + ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); + ROM_GPIOPinConfigure(GPIO_PD6_USB0EPEN); + ROM_GPIOPinTypeUSBDigital(GPIO_PORTD_BASE, GPIO_PIN_6); + ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); + ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); + ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); + + // + // Register the host class driver + // + USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS); + + // + // Open an instance of the mass storage class driver. + // + g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback); + + // + // Initialize the power configuration. This sets the power enable signal + // to be active high and does not enable the power fault. + // + USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); + + // + // Force the USB mode to host with no callback on mode changes since + // there should not be any. + // + USBStackModeSet(0, eUSBModeForceHost, 0); + + // + // Wait 10ms for the pin to go low. + // + SysCtlDelay(g_ui32SysClock/100); + + // + // Initialize the host controller. + // + USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); +} + +//***************************************************************************** +// +// Generic configuration is handled in this function. +// +// This function is called by the start up code to perform any configuration +// necessary before calling the update routine. It is responsible for setting +// the system clock to the expected rate and setting flash programming +// parameters prior to calling ConfigureUSBInterface() to set up the USB +// hardware. +// +// \return None. +// +//***************************************************************************** +void +UpdaterMain(void) +{ + // + // Make sure NVIC points at the correct vector table. + // + HWREG(NVIC_VTABLE) = 0; + + // + // Run from the PLL at 120 MHz. + // + g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | + SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | + SYSCTL_CFG_VCO_480), 120000000); + + // + // Enable lazy stacking for interrupt handlers. This allows floating-point + // instructions to be used within interrupt handlers, but at the expense of + // extra stack usage. + // + ROM_FPULazyStackingEnable(); + + // + // Configure the USB interface and power the bus. + // + ConfigureUSBInterface(); + + // + // Call the updater function. This will attempt to load a new image + // into flash from a USB memory stick. + // + UpdaterUSB(); +} + +//***************************************************************************** +// +// Main entry point for the USB stick update example. +// +// This function will check to see if a flash update should be performed from +// the USB memory stick, or if the user application should just be run without +// any update. +// +// The following checks are made, any of which mean that an update should be +// performed: +// - the PC and SP for the user app do not appear to be valid +// - a memory location contains a certain value, meaning the user app wants +// to force an update +// - the user button on the eval board is being pressed, meaning the user wants +// to force an update even if there is a valid user app in memory +// +// If any of the above checks are true, then that means that an update should +// be attempted. The USB stick updater will then wait for a USB stick to be +// plugged in, and once it is look for a firmware update file. +// +// If none of the above checks are true, then the user application that is +// already in flash is run and no update is performed. +// +// \return None. +// +//***************************************************************************** +int +main(void) +{ + uint32_t *pui32App; + + // + // See if the first location is 0xfffffffff or something that does not + // look like a stack pointer, or if the second location is 0xffffffff or + // something that does not look like a reset vector. + // + pui32App = (uint32_t *)APP_START_ADDRESS; + if((pui32App[0] == 0xffffffff) || + ((pui32App[0] & 0xfff00000) != 0x20000000) || + (pui32App[1] == 0xffffffff) || + ((pui32App[1] & 0xfff00001) != 0x00000001)) + { + // + // App starting stack pointer or PC is not valid, so force an update. + // + UpdaterMain(); + } + + // + // Check to see if the application has requested an update + // + if(HWREG(FORCE_UPDATE_ADDR) == FORCE_UPDATE_VALUE) + { + HWREG(FORCE_UPDATE_ADDR) = 0; + UpdaterMain(); + } + + // + // Enable the GPIO input for the SEL button. + // + ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP); + ROM_GPIODirModeSet(GPIO_PORTP_BASE, GPIO_PIN_1, GPIO_DIR_MODE_IN); + MAP_GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, + GPIO_PIN_TYPE_STD_WPU); + + // + // Check if the button is pressed, if so then force an update. + // + if(ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_1) == 0) + { + UpdaterMain(); + } + + // + // If we get to here that means that none of the conditions that should + // cause an update are true. Therefore, call the application. + // + CallApplication(APP_START_ADDRESS); +} + +//***************************************************************************** +// +// This function is called from the application to request an update. The +// address of this function is stored in the SVC vector at offset 0x2C, so +// the user application can call it by using a statement like this: +// +// (*((void (*)(void))(*(uint32_t *)0x2c)))(); +// +//***************************************************************************** +void +AppForceUpdate(void) +{ + // + // Set a value in a memory location to indicate that the app requests + // an update. Then cause the processor to reset. + // + HWREG(FORCE_UPDATE_ADDR) = FORCE_UPDATE_VALUE; + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | NVIC_APINT_SYSRESETREQ; +} + +//***************************************************************************** +// +// This function is used to call the user application. It will set the NVIC +// to point at the user app's vector table, load up the user app's stack +// pointer, and then jump to the application. +// +// This function must be programmed in assembly since it needs to directly +// manipulate the value in the stack pointer, and because it needs to perform +// a direct branch to the user app and not a function call (bl). +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +CallApplication(uint_fast32_t ui32StartAddr) +{ + // + // Set the vector table to the beginning of the app in flash. + // + HWREG(NVIC_VTABLE) = ui32StartAddr; + + // + // Load the stack pointer from the application's vector table. + // + __asm(" ldr r1, [r0]\n" + " mov sp, r1"); + + // + // Load the initial PC from the application's vector table and branch to + // the application's entry point. + // + __asm(" ldr r0, [r0, #4]\n" + " bx r0\n"); +} +#elif defined(ewarm) +void +CallApplication(uint_fast32_t ui32StartAddr) +{ + // + // Set the vector table to the beginning of the app in flash. + // + HWREG(NVIC_VTABLE) = ui32StartAddr; + + // + // Load the stack pointer from the application's vector table. + // + __asm(" ldr r1, [r0]\n" + " mov sp, r1"); + + // + // Load the initial PC from the application's vector table and branch to + // the application's entry point. + // + __asm(" ldr r0, [r0, #4]\n" + " bx r0\n"); +} +#elif defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +CallApplication(uint_fast32_t ui32StartAddr) +{ + // + // Set the vector table address to the beginning of the application. + // + ldr r1, =0xe000ed08 + str r0, [r1] + + // + // Load the stack pointer from the application's vector table. + // + ldr r1, [r0] + mov sp, r1 + + // + // Load the initial PC from the application's vector table and branch to + // the application's entry point. + // + ldr r0, [r0, #4] + bx r0 +} +#elif defined(ccs) +void +CallApplication(uint_fast32_t ui32StartAddr) +{ + // + // Set the vector table to the beginning of the app in flash. + // + HWREG(NVIC_VTABLE) = ui32StartAddr; + + // + // Load the stack pointer from the application's vector table. + // + __asm(" ldr r1, [r0]\n" + " mov sp, r1\n"); + + // + // Load the initial PC from the application's vector table and branch to + // the application's entry point. + // + __asm(" ldr r0, [r0, #4]\n" + " bx r0\n"); +} +#else +#error Undefined compiler! +#endif + diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewd b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewd new file mode 100644 index 0000000..484e41a --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewd @@ -0,0 +1,614 @@ + + + + 1 + + Debug + + ARM + + 1 + + C-SPY + 2 + + 15 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + ARMSIM_ID + 2 + + 1 + 1 + 1 + + + + + + + + ANGEL_ID + 2 + + 0 + 1 + 1 + + + + + + + + + + + + GDBSERVER_ID + 2 + + 0 + 1 + 1 + + + + + + + + + + + IARROM_ID + 2 + + 0 + 1 + 1 + + + + + + + + + + JLINK_ID + 2 + + 9 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + LMIFTDI_ID + 2 + + 1 + 1 + 1 + + + + + + + + MACRAIGOR_ID + 2 + + 2 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + RDI_ID + 2 + + 1 + 1 + 1 + + + + + + + + + + + + + + + + + THIRDPARTY_ID + 2 + + 0 + 1 + 1 + + + + + + + + + $TOOLKIT_DIR$\plugins\rtos\CMX\CmxArmPlugin.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\CMX\CmxTinyArmPlugin.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\embOS\embOSPlugin.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\OSE\OseEpsilonPlugin.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\PowerPac\PowerPacRTOS.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\ThreadX\ThreadXArmPlugin.ewplugin + 0 + + + $TOOLKIT_DIR$\plugins\rtos\uCOS-II\uCOS-II-KA-CSpy.ewplugin + 0 + + + $EW_DIR$\common\plugins\CodeCoverage\CodeCoverage.ENU.ewplugin + 1 + + + $EW_DIR$\common\plugins\Orti\Orti.ENU.ewplugin + 0 + + + $EW_DIR$\common\plugins\Profiling\Profiling.ENU.ewplugin + 1 + + + $EW_DIR$\common\plugins\Stack\Stack.ENU.ewplugin + 1 + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewp b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewp new file mode 100644 index 0000000..b835ac4 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ewp @@ -0,0 +1,792 @@ + + + + 1 + + Debug + + ARM + + 1 + + General + 3 + + 14 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ICCARM + 2 + + 19 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AARM + 2 + + 7 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + OBJCOPY + 0 + + 1 + 1 + 1 + + + + + + + + + CUSTOM + 3 + + + + + + + BICOMP + 0 + + + + BUILDACTION + 1 + + + + + + + ILINK + 0 + + 5 + 1 + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IARCHIVE + 0 + + 0 + 1 + 1 + + + + + + + BILINK + 0 + + + + + Libraries + + $PROJ_DIR$\..\..\..\..\driverlib\ewarm\Exe\driverlib.a + + + $PROJ_DIR$\..\..\..\..\usblib\ewarm\Exe\usblib.a + + + + Source + + $PROJ_DIR$\simple_fs.c + + + $PROJ_DIR$\startup_ewarm.c + + + $PROJ_DIR$\usb_stick_update.c + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.icf b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.icf new file mode 100644 index 0000000..c269e21 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.icf @@ -0,0 +1,78 @@ +//***************************************************************************** +// +// usb_stick_update.icf - Linker configuration file for usb_stick_update. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +// +//***************************************************************************** + +// +// Define a memory region that covers the entire 4 GB addressible space of the +// processor. +// +define memory mem with size = 4G; + +// +// Define a region for the on-chip flash. +// +define region FLASH = mem:[from 0x00000000 to 0x000fffff]; + +// +// Define a region for the on-chip SRAM. +// +define region SRAM = mem:[from 0x20000000 to 0x2003ffff]; + +// +// Define a block for the heap. The size should be set to something other +// than zero if things in the C library that require the heap are used. +// +define block HEAP with alignment = 8, size = 0x00000000 { }; + +// +// Indicate that the read/write values should be initialized by copying from +// flash. +// +initialize by copy { readwrite }; + +// +// Indicate that the noinit values should be left alone. This includes the +// stack, which if initialized will destroy the return address from the +// initialization code, causing the processor to branch to zero and fault. +// +do not initialize { section .noinit }; + +// +// Place the interrupt vectors at the start of flash. +// +place at start of FLASH { readonly section .intvec }; + +// +// Place the remainder of the read-only items into flash. +// +place in FLASH { readonly }; + +// +// Place the RAM vector table at the start of SRAM. +// +place at start of SRAM { section VTABLE }; + +// +// Place all read/write items into SRAM. +// +place in SRAM { readwrite, block HEAP }; diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ld b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ld new file mode 100644 index 0000000..1d0be8a --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.ld @@ -0,0 +1,57 @@ +/****************************************************************************** + * + * usb_stick_update.ld - Linker configuration file for usb_stick_update. + * + * Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. + * Software License Agreement + * + * Texas Instruments (TI) is supplying this software for use solely and + * exclusively on TI's microcontroller products. The software is owned by + * TI and/or its suppliers, and is protected under applicable copyright + * laws. You may not combine this software with "viral" open-source + * software in order to form a larger program. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. + * NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT + * NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY + * CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL + * DAMAGES, FOR ANY REASON WHATSOEVER. + * + * This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. + * + *****************************************************************************/ + +MEMORY +{ + FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 0x00100000 + SRAM (rwx) : ORIGIN = 0x20000000, LENGTH = 0x00040000 +} + +SECTIONS +{ + .text : + { + _text = .; + KEEP(*(.isr_vector)) + *(.text*) + *(.rodata*) + _etext = .; + } > FLASH + + .data : AT(ADDR(.text) + SIZEOF(.text)) + { + _data = .; + *(vtable) + *(.data*) + _edata = .; + } > SRAM + + .bss : + { + _bss = .; + *(.bss*) + *(COMMON) + _ebss = .; + } > SRAM +} diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.sct b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.sct new file mode 100644 index 0000000..29b9fe6 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.sct @@ -0,0 +1,47 @@ +;****************************************************************************** +; +; usb_stick_update.sct - Linker configuration file for usb_stick_update. +; +; Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +; Software License Agreement +; +; Texas Instruments (TI) is supplying this software for use solely and +; exclusively on TI's microcontroller products. The software is owned by +; TI and/or its suppliers, and is protected under applicable copyright +; laws. You may not combine this software with "viral" open-source +; software in order to form a larger program. +; +; THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +; NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +; NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +; A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +; CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +; DAMAGES, FOR ANY REASON WHATSOEVER. +; +; This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. +; +;****************************************************************************** + +LR_IROM 0x00000000 0x00100000 +{ + ; + ; Specify the Execution Address of the code and the size. + ; + ER_IROM 0x00000000 0x00100000 + { + *.o (RESET, +First) + * (InRoot$$Sections, +RO) + } + + ; + ; Specify the Execution Address of the data area. + ; + RW_IRAM 0x20000000 0x00040000 + { + ; + ; Uncomment the following line in order to use IntRegister(). + ; + ;* (vtable, +First) + * (+RW, +ZI) + } +} diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvopt b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvopt new file mode 100644 index 0000000..6508277 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvopt @@ -0,0 +1,317 @@ + + + + 1.0 + +
### uVision Project, (C) Keil Software
+ + + *.c + *.s*; *.src; *.a* + *.obj + *.lib + *.txt; *.h; *.inc + *.plm + *.cpp + + + + 0 + 0 + + + + usb_stick_update + 0x4 + ARM-ADS + + 25000000 + + 1 + 1 + 1 + 0 + + + 1 + 65535 + 0 + 0 + 0 + + + 79 + 66 + 8 + .\rvmdk\ + + + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 1 + 0 + 0 + 0 + 0 + + + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + + + 1 + 0 + 1 + + 255 + + + 0 + Data Sheet + DATASHTS\Luminary\TM4C129XNCZAD.PDF + + + + SARMCM3.DLL + -MPU + DCM.DLL + -pCM4 + SARMCM3.DLL + -MPU + TCM.DLL + -pCM4 + + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + 0 + 0 + 4 + + + + + + + + + + + BIN\lmidk-agdi.dll + + + + 0 + lmidk-agdi + -O4614 -S1 -FO29 + + + 0 + DLGTARM + + + + 0 + ARMDBGFLAGS + + + + + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + + + Source + 1 + 0 + 0 + + 1 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + .\simple_fs.c + simple_fs.c + + + 1 + 2 + 2 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + .\startup_rvmdk.S + startup_rvmdk.S + + + 1 + 3 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + .\usb_stick_update.c + usb_stick_update.c + + + + + Libraries + 1 + 0 + 0 + + 2 + 4 + 4 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + ..\..\..\..\driverlib\rvmdk\driverlib.lib + driverlib.lib + + + 2 + 5 + 4 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + ..\..\..\..\usblib\rvmdk\usblib.lib + usblib.lib + + + + + Documentation + 1 + 0 + 0 + + 3 + 6 + 5 + 0 + 1 + 0 + 0 + 1 + 1 + 0 + .\readme.txt + readme.txt + + 44 + 0 + 1 + + -1 + -1 + + + -1 + -1 + + + 0 + 0 + 729 + 300 + + + + + + + 1 + 0 + + 100 + 0 + + + .\readme.txt + 0 + 1 + 1 + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvproj b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvproj new file mode 100644 index 0000000..e4ef4a1 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update.uvproj @@ -0,0 +1,434 @@ + + + + 1.1 + +
### uVision Project, (C) Keil Software
+ + + + usb_stick_update + 0x4 + ARM-ADS + + + TM4C129XNCZAD + Texas Instruments + IRAM(0x20000000-0x2003FFFF) IROM(0-0xFFFFF) CLOCK(25000000) CPUTYPE("Cortex-M4") FPU2 + + "STARTUP\Luminary\Startup.s" ("Luminary Startup Code") + UL2CM3(-O207 -S0 -C0 -FO7 -FD20000000 -FC800 -FN1 -FF0LM4F_1024 -FS00 -FL0100000) + 5919 + LM4Fxxxx.H + + + + + + + + + + 0 + + + + Luminary\ + Luminary\ + + 0 + 0 + 0 + 0 + 1 + + .\rvmdk\ + usb_stick_update + 1 + 0 + 0 + 1 + 1 + .\rvmdk\ + 1 + 0 + 0 + + 0 + 0 + + + 0 + 0 + + + 0 + 0 + + + 0 + 0 + + + 1 + 0 + fromelf --bin --output .\rvmdk\usb_stick_update.bin .\rvmdk\usb_stick_update.axf + + 0 + 0 + + 0 + + + + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 3 + + + + + SARMCM3.DLL + -MPU + DCM.DLL + -pCM4 + SARMCM3.DLL + -MPU + TCM.DLL + -pCM4 + + + + 1 + 0 + 0 + 0 + 16 + + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + + + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + + 0 + 4 + + + + + + + + + + + + + + BIN\lmidk-agdi.dll + + + + + 1 + 0 + 0 + 0 + 1 + 4099 + + BIN\lmidk-agdi.dll + + + + + + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 0 + "Cortex-M4" + + 0 + 0 + 0 + 1 + 1 + 0 + 0 + 2 + 0 + 0 + 8 + 1 + 0 + 0 + 3 + 3 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 1 + 0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x40000 + + + 1 + 0x0 + 0x100000 + + + 0 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 1 + 0x0 + 0x100000 + + + 1 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x20000000 + 0x40000 + + + 0 + 0x0 + 0x0 + + + + + + 0 + 3 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 2 + 0 + + --c99 + rvmdk PART_TM4C129XNCZAD TARGET_IS_TM4C129_RA0 + + ..;..\..\..\..; + + + + 1 + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + + + + 0 + 0 + 0 + 0 + 1 + 0 + 0x00000000 + 0x20000000 + usb_stick_update.sct + + + --entry Reset_Handler + + + + + + + + Source + + + simple_fs.c + 1 + .\simple_fs.c + + + startup_rvmdk.S + 2 + .\startup_rvmdk.S + + + usb_stick_update.c + 1 + .\usb_stick_update.c + + + + + Libraries + + + driverlib.lib + 4 + ..\..\..\..\driverlib\rvmdk\driverlib.lib + + + usblib.lib + 4 + ..\..\..\..\usblib\rvmdk\usblib.lib + + + + + Documentation + + + readme.txt + 5 + .\readme.txt + + + + + + + + diff --git a/boards/dk-tm4c129x/usb_stick_update/usb_stick_update_ccs.cmd b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update_ccs.cmd new file mode 100644 index 0000000..3198798 --- /dev/null +++ b/boards/dk-tm4c129x/usb_stick_update/usb_stick_update_ccs.cmd @@ -0,0 +1,70 @@ +/****************************************************************************** + * + * usb_stick_update_ccs.cmd - CCS linker configuration file for usb_stick_update. + * + * Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. + * Software License Agreement + * + * Texas Instruments (TI) is supplying this software for use solely and + * exclusively on TI's microcontroller products. The software is owned by + * TI and/or its suppliers, and is protected under applicable copyright + * laws. You may not combine this software with "viral" open-source + * software in order to form a larger program. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. + * NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT + * NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY + * CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL + * DAMAGES, FOR ANY REASON WHATSOEVER. + * + * This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package. + * + *****************************************************************************/ + +--retain=g_pfnVectors + +/* The following command line options are set as part of the CCS project. */ +/* If you are building using the command line, or for some reason want to */ +/* define them here, you can uncomment and modify these lines as needed. */ +/* If you are using CCS for building, it is probably better to make any such */ +/* modifications in your CCS project and leave this file alone. */ +/* */ +/* --heap_size=0 */ +/* --stack_size=256 */ +/* --library=rtsv7M3_T_le_eabi.lib */ + +/* The starting address of the application. Normally the interrupt vectors */ +/* must be located at the beginning of the application. */ +#define APP_BASE 0x00000000 +#define RAM_BASE 0x20000000 + +/* System memory map */ + +MEMORY +{ + /* Application stored in and executes from internal flash */ + FLASH (RX) : origin = APP_BASE, length = 0x00100000 + /* Application uses internal RAM for data */ + SRAM (RWX) : origin = 0x20000000, length = 0x00040000 +} + +/* Section allocation in memory */ + +SECTIONS +{ + .intvecs: > APP_BASE + .text : > FLASH + .const : > FLASH + .cinit : > FLASH + .pinit : > FLASH + .init_array : > FLASH + + .vtable : > RAM_BASE + .data : > SRAM + .bss : > SRAM + .sysmem : > SRAM + .stack : > SRAM +} + +__STACK_TOP = __stack + 1024; -- cgit v1.3.1