void composite_device_init()
{
tUSBDMSCDevice *psDevice;
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
g_psCompDevices[0].pvInstance =
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
g_psCompDevices[1].pvInstance =
USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
backUpCompDevices[0].pvInstance = g_psCompDevices[0].pvInstance;
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass the device information to the USB library and place the device
// on the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
g_pucDescriptorData);
psDevice = g_psCompDevices[0].pvInstance;
store = psDevice->psPrivateData->pvMedia; //make a copy of the media to restore later
}
static void initialize(intptr_t unused) {
// Initialize USB OTG
HWREG(CFGCHIP2_USBPHYCTRL) &= ~SYSCFG_CFGCHIP2_USB0OTGMODE;
HWREG(CFGCHIP2_USBPHYCTRL) |= CFGCHIP2_FORCE_DEVICE; // Force USB device operation
HWREG(CFGCHIP2_USBPHYCTRL) |= CFGCHIP2_REFFREQ_24MHZ; // 24 MHz OSCIN
g_sMSCDevice.sMediaFunctions = usbmsc_media_functions_dummy;
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
#if defined(DMA_MODE)
Cppi41DmaInit(USB_INSTANCE, epInfo, NUMBER_OF_ENDPOINTS);
for(;g_bufferIndex < NUM_OF_RX_BDs; g_bufferIndex++)
{
unsigned char *dataBuffer = (unsigned char *)cppiDmaAllocBuffer();
doDmaRxTransfer(USB_INSTANCE, USB_MSC_BUFER_SIZE, dataBuffer,
g_sMSCDevice.psPrivateData->ucOUTEndpoint);
}
#endif
// dump_usbmsc();
#if defined(DEBUG_USBMSC)
syslog(LOG_EMERG, "usbmsc_dri initialized.");
#endif
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
#ifdef DMA_MODE
MMUConfigAndEnable();
/* Enable Data Cache */
CacheEnable(CACHE_DCACHE);
#endif
//
//USB module clock enable
//
USB0ModuleClkConfig();
//
//USB Interrupt enable
//
USBInterruptEnable();
//
//Delay timer setup
//
DelayTimerSetup();
//
// Initialize the idle timeout and reset all flags.
//
//g_ulIdleTimeout = 0;
g_ulFlags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_IDLE;
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
#ifdef DMA_MODE
Cppi41DmaInit(USB_INSTANCE, epInfo, NUMBER_OF_ENDPOINTS);
for(;g_bufferIndex < NUM_OF_RX_BDs; g_bufferIndex++)
{
dataBuffer = (unsigned char *)cppiDmaAllocBuffer();
doDmaRxTransfer(USB_INSTANCE, USB_MSC_BUFER_SIZE, dataBuffer,
g_sMSCDevice.psPrivateData->ucOUTEndpoint);
}
#endif
//
// Drop into the main loop.
//
while(1);
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
unsigned int i;
unsigned char *src, *dest;
/* MMU needs to be turned on to provide HW support unaligned
access to USB structures */
MMUConfigAndEnable();
/* Enable Data Cache */
CacheEnable(CACHE_ALL);
//
//USB module clock enable
//
USB0ModuleClkConfig();
//
//USB Interrupt enable
//
USBInterruptEnable();
//
//Delay timer setup
//
DelayTimerSetup();
CacheDataCleanInvalidateAll();
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
#ifdef DMA_MODE
Cppi41DmaInit(USB_INSTANCE, epInfo, NUMBER_OF_ENDPOINTS);
for(;g_bufferIndex < NUM_OF_RX_BDs; g_bufferIndex++)
{
dataBuffer = (unsigned char *)cppiDmaAllocBuffer();
doDmaRxTransfer(USB_INSTANCE, USB_MSC_BUFER_SIZE, dataBuffer,
g_sMSCDevice.psPrivateData->ucOUTEndpoint);
}
#endif
while(1)
{
}
}
void msc_init()
{
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_5 | GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Initialize the idle timeout and reset all flags.
//
g_ulIdleTimeout = 0;
g_ulFlags = 0;
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
//
// Determine whether or not an SDCard is installed. If not, print a
// warning and have the user install one and restart.
//
disk_initialize(0);
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
uint_fast32_t ui32Retcode;
//
// Set the system clock to run at 50MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 ms
// tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = DISPLAY_BANNER_HEIGHT - 1;
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_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb-dev-msc", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 5, 0);
//
// Initialize the idle timeout and reset all flags.
//
g_ui32IdleTimeout = 0;
g_ui32Flags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Draw the status bar and set it to idle.
//
UpdateStatus("Disconnected", 1);
//
// 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_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
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);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, &g_sMSCDevice);
//
// Determine whether or not an SDCard is installed. If not, print a
// warning and have the user install one and restart.
//
ui32Retcode = disk_initialize(0);
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
if(ui32Retcode != RES_OK) {
GrStringDrawCentered(&g_sContext, "No SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 16, 0);
GrStringDrawCentered(&g_sContext, "Please insert",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 26, 0);
GrStringDrawCentered(&g_sContext, "a card and",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 36, 0);
GrStringDrawCentered(&g_sContext, "reset the board.",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 46, 0);
} else {
GrStringDrawCentered(&g_sContext, "SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 30, 0);
}
//
// Drop into the main loop.
//
while(1) {
switch(g_eMSCState) {
case MSC_DEV_READ: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Reading", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Writing", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_DISCONNECTED: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Disconnected", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
break;
}
case MSC_DEV_IDLE: {
break;
}
default: {
break;
}
}
}
}
/* Main function
*
* - Initialise device and any global variables
* - Enable Interrupts
* - Start endless loop
*/
void main(void) {
unsigned long ulRetcode;
// Initialise the device clock to 80MHz
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN );
// Enable SysTick for FatFS at 10ms intervals
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5);
// Initialize the idle timeout and reset all flags.
//
g_ulIdleTimeout = 0;
g_ulFlags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
//
// Determine whether or not an SDCard is installed. If not, print a
// warning and have the user install one and restart.
//
ulRetcode = disk_initialize(0);
// Enable Global interrupts
ROM_IntMasterEnable();
// Enable floating point arithmetic unit, but disable stacking
ROM_FPUEnable();
ROM_FPUStackingDisable();
// Initialise GPIO - All ports enabled
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
// Unlock NMI pins for GPIO usage (PD7 + PF0)
HWREG(GPIO_PORTD_BASE + 0x520) = 0x4C4F434B;
HWREG(GPIO_PORTF_BASE + 0x520) = 0x4C4F434B;
HWREG(GPIO_PORTD_BASE + 0x524) = 0x000000FF;
HWREG(GPIO_PORTF_BASE + 0x524) = 0x000000FF;
HWREG(GPIO_PORTD_BASE + 0x520) = 0x00000000;
HWREG(GPIO_PORTF_BASE + 0x520) = 0x00000000;
// Initialise GPIO Expander (probably not happening)
// Initialise Buttons
btn_init();
// Initialise FX
fx_init();
// Initialise ADC
adc_init();
// Initialise DAC
dac_init();
// Initialise SD Card and Mass storage
sdcard_init();
// Initialise UART for debugging
uart_init();
// Initialise Timers
timers_init();
for(;;) {
// Endless Loop
ADCProcessorTrigger(ADC0_BASE, 0);
SysCtlDelay(SysCtlClockGet() / 120); // 25ms
}
}
//****************************************************************************
//
// This is the main loop that runs the application.
//
//****************************************************************************
int
main(void)
{
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Initialize the idle timeout and reset all flags.
//
g_ulIdleTimeout = 0;
g_ulFlags = 0;
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
g_psCompDevices[0].pvInstance =
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
g_psCompDevices[1].pvInstance =
USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass the device information to the USB library and place the device
// on the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
g_pucDescriptorData);
SerialInit();
disk_initialize(0);
//
// Drop into the main loop.
//
while(1)
{
//
// Allow the main serial routine to run.
//
SerialMain();
switch(g_eMSCState)
{
case MSC_DEV_READ:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_DISCONNECTED:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
break;
}
case MSC_DEV_IDLE:
{
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Enable the USB mux GPIO.
//
ROM_SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);
//
// The LM3S3748 board uses a USB mux that must be switched to use the
// host connector and not the device connecter.
//
ROM_GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);
ROM_GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_DEVICE);
//
// Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 ms
// tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
uDMAControlBaseSet(&sDMAControlTable[0]);
uDMAEnable();
//
// 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 = DISPLAY_BANNER_HEIGHT;
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_pFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb_dev_msc", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Initialize the idle timeout and reset all flags.
//
g_ulIdleTimeout = 0;
g_ulFlags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_IDLE;
//
// Draw the status bar and set it to idle.
//
UpdateStatus("Idle", 1);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
//
// Drop into the main loop.
//
while(1)
{
switch(g_eMSCState)
{
case MSC_DEV_READ:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
UpdateStatus("Reading", 0);
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
UpdateStatus("Idle ", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
UpdateStatus("Writing", 0);
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
UpdateStatus("Idle ", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_IDLE:
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
static int
main(void)
{
// tRectangle sRect;
unsigned int index, i;
unsigned char *src, *dest;
/* Sets up 'Level 1" page table entries.
* The page table entry consists of the base address of the page
* and the attributes for the page. The following operation is to
* setup one-to-one mapping page table for DDR memeory range and set
* the atributes for the same. The DDR memory range is from 0xC0000000
* to 0xDFFFFFFF. Thus the base of the page table ranges from 0xC00 to
* 0xDFF. Cache(C bit) and Write Buffer(B bit) are enabled only for
* those page table entries which maps to DDR RAM and internal RAM.
* All the pages in the DDR range are provided with R/W permissions
*/
#ifdef DMA_MODE
for(index = 0; index < (4*1024); index++)
{
if((index >= 0xC00 && index < 0xE00)|| (index == 0x800))
{
pageTable[index] = (index << 20) | 0x00000C1E;
}
else
{
pageTable[index] = (index << 20) | 0x00000C12;
}
}
/* Configures translation table base register
* with pagetable base address.
*/
CP15TtbSet((unsigned int )pageTable);
/* Enables MMU */
CP15MMUEnable();
/* Enable Data Cache */
CP15DCacheEnable();
/* Disable Instruction Cache*/
CP15ICacheDisable();
#endif
#if 0 // No LCD -- ertl-liyixiao
//
//configures arm interrupt controller to generate raster interrupt
//
SetupIntc();
//
//Configures raster to display image
//
SetUpLCD();
/* configuring the base ceiling */
RasterDMAFBConfig(SOC_LCDC_0_REGS,
(unsigned int)(g_pucBuffer+PALETTE_OFFSET),
(unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 - PALETTE_OFFSET,
0);
RasterDMAFBConfig(SOC_LCDC_0_REGS,
(unsigned int)(g_pucBuffer+PALETTE_OFFSET),
(unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 - PALETTE_OFFSET,
1);
// Copy palette info into buffer
src = (unsigned char *) palette_32b;
dest = (unsigned char *) (g_pucBuffer+PALETTE_OFFSET);
for( i = 4; i < (PALETTE_SIZE+4); i++)
{
*dest++ = *src++;
}
GrOffScreen16BPPInit(&g_sSHARP480x272x16Display, g_pucBuffer, LCD_WIDTH, LCD_HEIGHT);
// Initialize a drawing context.
GrContextInit(&g_sContext, &g_sSHARP480x272x16Display);
/* enable End of frame interrupt */
RasterEndOfFrameIntEnable(SOC_LCDC_0_REGS);
/* enable raster */
RasterEnable(SOC_LCDC_0_REGS);
ConfigRasterDisplayEnable();
//
// 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 = DISPLAY_BANNER_HEIGHT;
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_sFontCm20);
GrStringDrawCentered(&g_sContext, "usb-dev-msc", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);
//
// Initialize the idle timeout and reset all flags.
//
g_ulIdleTimeout = 0;
g_ulFlags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_IDLE;
//
// Draw the status bar and set it to idle.
//
UpdateStatus("Idle", 1);
#endif
//SetupAINTCInt();
//ConfigureAINTCIntUSB();
//DelayTimerSetup();
#if 0 // No LCD
SystickConfigure(SysTickHandler);
SystickPeriodSet(10);
SystickEnable();
#endif
USBDMSCInit(0, (tUSBDMSCDevice *)&g_sMSCDevice);
#ifdef DMA_MODE
Cppi41DmaInit(USB_INSTANCE, epInfo, NUMBER_OF_ENDPOINTS);
for(;g_bufferIndex < NUM_OF_RX_BDs; g_bufferIndex++)
{
dataBuffer = (unsigned char *)cppiDmaAllocBuffer();
doDmaRxTransfer(USB_INSTANCE, USB_MSC_BUFER_SIZE, dataBuffer,
g_sMSCDevice.psPrivateData->ucOUTEndpoint);
}
#endif
#if 0 // No LCD -- ertl-liyixiao
//
// Drop into the main loop.
//
//
// Drop into the main loop.
//
while(1)
{
switch(g_eMSCState)
{
case MSC_DEV_READ:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
UpdateStatus("Reading", 0);
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
UpdateStatus("Idle ", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE:
{
//
// Update the screen if necessary.
//
if(g_ulFlags & FLAG_UPDATE_STATUS)
{
UpdateStatus("Writing ", 0);
g_ulFlags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ulIdleTimeout == 0)
{
UpdateStatus("Idle ", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_IDLE:
default:
{
break;
}
}
}
#endif
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32Read, ui32Write;
//
// Run from the PLL at 120 MHz.
//
g_ui32SysClock = 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(g_ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "usb-dev-msc");
//
// Place the static status text on the display.
//
GrStringDrawCentered(&g_sContext, "Status", -1, 160, 58, false);
GrStringDrawCentered(&g_sContext, "Bytes Read", -1, 160, 118, false);
GrStringDrawCentered(&g_sContext, "Bytes Written", -1, 160, 178, false);
GrContextForegroundSet(&g_sContext, ClrGray);
UpdateCount(0, 138);
UpdateCount(0, 198);
//
// Configure SysTick for a 100Hz interrupt. This is to detect idle state
// every 10ms after a state change.
//
ROM_SysTickPeriodSet(g_ui32SysClock / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&psDMAControlTable[0]);
ROM_uDMAEnable();
//
// Initialize the idle timeout and reset all flags.
//
g_ui32IdleTimeout = 0;
g_ui32Flags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Draw the status bar and set it to idle.
//
UpdateStatus("Disconnected");
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Enable the SSI3 used by SPI flash.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI3);
ROM_SysCtlPeripheralReset(SYSCTL_PERIPH_SSI3);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, (tUSBDMSCDevice*)&g_sMSCDevice);
//
// Initialize the SD card, if present. This prevents it from interfering
// with accesses to the SPI flash.
//
disk_initialize(0);
//
// Initialize MX66L51235F Flash memory.
//
MX66L51235FInit(g_ui32SysClock);
//
// Drop into the main loop.
//
ui32Read = g_ui32ReadCount;
ui32Write = g_ui32WriteCount;
while(1)
{
switch(g_eMSCState)
{
case MSC_DEV_READ:
{
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS)
{
UpdateStatus(" Reading ");
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0)
{
UpdateStatus(" Idle ");
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE:
{
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS)
{
UpdateStatus(" Writing ");
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0)
{
UpdateStatus(" Idle ");
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_DISCONNECTED:
{
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS)
{
UpdateStatus(" Disconnected ");
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
break;
}
case MSC_DEV_IDLE:
{
break;
}
default:
{
break;
}
}
//
// Update the read count if it has changed.
//
if(g_ui32ReadCount != ui32Read)
{
ui32Read = g_ui32ReadCount;
UpdateCount(ui32Read, 138);
}
//
// Update the write count if it has changed.
//
if(g_ui32WriteCount != ui32Write)
{
ui32Write = g_ui32WriteCount;
UpdateCount(ui32Write, 198);
}
}
}
