//*****************************************************************************
//
// A simple application demonstrating use of the boot loader,
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
tContext sContext;
tRectangle sRect;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "boot-demo-uart");
//
// Print instructions on the screen.
//
GrStringDrawCentered(&sContext, "Press the screen to start", -1, 160, 108,
false);
GrStringDrawCentered(&sContext, "the update process", -1, 160, 128, false);
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(TSHandler);
//
// Enable the UART that will be used for the firmware update.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure the UART for 115200, 8-N-1.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 115200,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Enable the UART operation.
//
ROM_UARTEnable(UART0_BASE);
//
// Wait until the screen has been pressed, indicating that the firwmare
// update should begin.
//
while(!g_bFirmwareUpdate)
{
}
//
// Clear the screen.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = 319;
sRect.i16YMax = 239;
GrContextForegroundSet(&sContext, ClrBlack);
GrRectFill(&sContext, &sRect);
//
// Indicate that the firmware update is about to start.
//
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDrawCentered(&sContext, "Update process started...", -1, 160, 98,
false);
GrStringDrawCentered(&sContext, "Using UART0 with", -1, 160, 138, false);
GrStringDrawCentered(&sContext, "115,200 baud, 8-N-1.", -1, 160, 158,
false);
//
// Disable all processor interrupts. Instead of disabling them one at a
// time, a direct write to NVIC is done to disable all peripheral
// interrupts.
//
HWREG(NVIC_DIS0) = 0xffffffff;
HWREG(NVIC_DIS1) = 0xffffffff;
HWREG(NVIC_DIS2) = 0xffffffff;
HWREG(NVIC_DIS3) = 0xffffffff;
HWREG(NVIC_DIS4) = 0xffffffff;
//
// Call the ROM UART boot loader.
//
ROM_UpdateUART();
//
// The boot loader should not return. In the off chance that it does,
// enter a dead loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// Demonstrate the use of the boot loader.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// If running on Rev A0 silicon, write the FMPRE[2-3]/FMPPE[2-3] registers
// to zero. This is a workaround to allow the mass erase in the ROM-based
// boot loader to succeed if a locked device recovery has been performed.
//
if(REVISION_IS_A0)
{
HWREG(FLASH_FMPPE2) = 0;
HWREG(FLASH_FMPPE3) = 0;
HWREG(FLASH_FMPRE2) = 0;
HWREG(FLASH_FMPRE3) = 0;
}
//
// Enable the UART and GPIO modules.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Make the UART pins be peripheral controlled.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Initialize the display driver.
//
Formike128x128x16Init();
//
// Turn on the backlight.
//
Formike128x128x16BacklightOn();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sFormike128x128x16);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = 14;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
GrStringDrawCentered(&g_sContext, "boot_demo1", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Indicate what is happening.
//
GrStringDrawCentered(&g_sContext, "The boot loader is", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 24, 0);
GrStringDrawCentered(&g_sContext, "now running and", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 32, 0);
GrStringDrawCentered(&g_sContext, "awaiting an update", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, 0);
GrStringDrawCentered(&g_sContext, "over UART0 at", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 48, 0);
GrStringDrawCentered(&g_sContext, "115200, 8-N-1.", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 56, 0);
//
// Call the boot loader so that it will listen for an update on the UART.
//
ROM_UpdateUART();
//
// The boot loader should take control, so this should never be reached.
// Just in case, loop forever.
//
while(1)
{
}
}
