void
disk_page_io_save_me_async(disk_page_io *me)
{
if(_DEBUG) hal_printf("disk_page_io alloc... ");
disk_page_io_allocate(me);
if(_DEBUG) hal_printf("disk_page_io wait... ");
disk_page_io_wait(me);
if(_DEBUG) hal_printf("disk_page_io kick pager... ");
pager_enqueue_for_pageout_fast( &me->req );
if(_DEBUG) hal_printf("disk_page_io after kick... ");
}
////////////////////////////////////////////////////////////////////////////////
// The SectorOverlapsBootstrapRegion method enables you to deny access for writing
// certain sectors. Returning true does not guarrantee that Tinybooter will be
// able to write to the sector. It performes other checks (including signature
// validation) to determine if the write operation is valid.
////////////////////////////////////////////////////////////////////////////////
bool CheckFlashSectorPermission( BlockStorageDevice *pDevice, ByteAddress address )
{
bool fAllowWrite = false;
UINT32 BlockType, iRegion, iRange;
if(pDevice->FindRegionFromAddress(address, iRegion, iRange))
{
const BlockRange& range = pDevice->GetDeviceInfo()->Regions[iRegion].BlockRanges[iRange];
if (range.IsBootstrap())
{
#if defined(TARGETLOCATION_RAM) // do not allow overwriting the bootstrap sector unless Tinybooter is RAM build.
fAllowWrite = true;
#else
hal_printf( "Trying to write to bootstrap region\r\n" );
fAllowWrite = false;
#endif
}
else
{
fAllowWrite = true;
}
}
return fAllowWrite;
}
BOOL SimpleHeap_IsAllocated( void *ptr )
{
if(ptr)
{
struct BlockHeader* blk = (struct BlockHeader*)ptr; blk--;
if(blk->signature == c_Busy)
{
return TRUE;
}
else if(blk->signature == c_Free)
{
return FALSE;
}
else
{
// corrupt pointer to memory
hal_printf( "SimpleHeap: Bad Ptr: 0x%08x\r\n", (size_t)ptr );
ASSERT(0);
return FALSE;
}
}
return FALSE;
}
void StartApplication( void (*StartAddress)() )
{
PortBooterLoadProgram((void**)&StartAddress);
hal_printf( "Starting main application at 0x%08x\r\n", (size_t)StartAddress );
LCD_Clear();
USART_Flush( ConvertCOM_ComPort(g_State.UsartPort) );
if(g_State.UsingUsb)
{
USB_Flush( ConvertCOM_UsbStream( g_State.UsbPort ) );
USB_CloseStream( ConvertCOM_UsbStream(g_State.UsbPort) );
USB_Uninitialize( ConvertCOM_UsbController(g_State.UsbPort) ); //disable the USB for the next application
}
DISABLE_INTERRUPTS();
LCD_Uninitialize();
CPU_DisableCaches();
(*StartAddress)();
}
BOOL LPC22XX_SPI_Driver::Xaction_nWrite16_nRead16( SPI_XACTION_16& Transaction )
{
lcd_printf("\fSPI Peripheral does not support 16 bit transfer\r\n");
hal_printf("\fSPI Peripheral does not support 16 bit transfer\r\n");
HARD_BREAKPOINT();
return FALSE;
}
BOOL LPC22XX_SPI_Driver::nWrite16_nRead16( const SPI_CONFIGURATION& Configuration, UINT16* Write16, INT32 WriteCount, UINT16* Read16, INT32 ReadCount, INT32 ReadStartOffset )
{
lcd_printf("\fSPI Peripheral does not support 16 bit transfer\r\n");
hal_printf("\fSPI Peripheral does not support 16 bit transfer\r\n");
HARD_BREAKPOINT();
return FALSE;
}
void ApplicationEntryPoint()
{
while(true)
{
hal_printf("Hello World!\n");
Events_WaitForEvents(0, 3000);
}
}
BOOL AT91_SPI_Driver::nWrite16_nRead16(const SPI_CONFIGURATION &Configuration, UINT16 *Write16, INT32 WriteCount, UINT16 *Read16, INT32 ReadCount, INT32 ReadStartOffset)
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
GLOBAL_LOCK(irq);
SPI_DEBUG_PRINT(" spi write 16 \r\n");
if(g_AT91_SPI_Driver.m_Enabled[Configuration.SPI_mod])
{
lcd_printf("\fSPI Xaction 1\r\n");
hal_printf("\fSPI Xaction 1\r\n");
HARD_BREAKPOINT();
return FALSE;
}
if(Configuration.SPI_mod > AT91_SPI::c_MAX_SPI)
{
lcd_printf("\fSPI wrong mod\r\n");
hal_printf("\fSPI wrong mod\r\n");
HARD_BREAKPOINT();
return FALSE;
}
if(!Xaction_Start(Configuration))
return FALSE;
{
SPI_XACTION_16 Transaction;
Transaction.Read16 = Read16;
Transaction.ReadCount = ReadCount;
Transaction.ReadStartOffset = ReadStartOffset;
Transaction.Write16 = Write16;
Transaction.WriteCount = WriteCount;
Transaction.SPI_mod = Configuration.SPI_mod;
Transaction.BusyPin = Configuration.BusyPin;
if(!Xaction_nWrite16_nRead16(Transaction))
return FALSE;
}
SPI_DEBUG_PRINT(" B4 xs 16 \r\n");
return Xaction_Stop(Configuration);
}
///////////////////////////////////////////////////////////////////////////////
//
// default debug channel LOG support
//
void Log::Output_DefaultDebugChannelStream( char* message, char* format )
{
if(!format)
{
// debug channel specific format is just a simple string with a carriage return
format = "%s\r\n";
}
hal_printf( format, message );
}
void SignalActivity( void )
{
g_State.WaitForActivity = FALSE;
if(g_State.SerialPortActive) return;
g_State.SerialPortActive = TRUE;
hal_printf( "Receiving upload of SREC file...\r\n" );
LCD_Clear();
hal_fprintf( STREAM_LCD, "\fFlashing...\r\n\r\n" );
}
void eth_displayRxDescStatus()
{
if (!s_pRxDesc)
{
return;
}
for (uint32_t i = 0; i < N_RX_DESC; i++)
{
hal_printf("%d: 0x%08x %s\r\n", i, s_rxDescriptor[i].rdes0,
s_pRxDesc == &s_rxDescriptor[i] ? "<===" : "");
}
}
void pagelist_init( pagelist *me, disk_page_no_t root_page, int _init, int magic )
{
if(_DEBUG) hal_printf("pagelist init... ");
me->root_page = root_page;
me->magic = magic;
if(_DEBUG) hal_printf("disk_page_cache_init... ");
disk_page_cache_init(&me->curr_p);
if(_DEBUG) hal_printf("disk_page_cache_init OK... ");
//if( _init ) init();
if(_init)
{
disk_page_io head_p;
if(_DEBUG) hal_printf("pagelist: create empty... ");
disk_page_io_init(&head_p);
struct phantom_disk_blocklist* head = (struct phantom_disk_blocklist *)disk_page_io_data(&head_p);
head->head.magic = me->magic;
head->head.used = 0;
head->head.next = 0;
// to maker sure compiler will barf if field will be renamed
head->head._reserved = 0;
if(_DEBUG) hal_printf("pagelist saving head... ");
disk_page_io_save_sync(&head_p,root_page);
if(_DEBUG) hal_printf("pagelist releasing io... ");
disk_page_io_release(&head_p);
if(_DEBUG) hal_printf("pagelist create done... ");
}
if(_DEBUG) hal_printf("pagelist load head... ");
disk_page_cache_seek_async( &me->curr_p, me->root_page ); //load_head();
me->curr_displ = 0;
me->curr = (struct phantom_disk_blocklist *)disk_page_cache_data(&me->curr_p);
if(_DEBUG) hal_printf("pagelist init DONE\n");
}
/**
* Initialize the RX descriptors as a chain structure.
*/
void eth_initRxDescriptors()
{
uint32_t i;
// Initialize the descriptor pointer to the first RX descriptor
s_pRxDesc = &s_rxDescriptor[0];
// Initialize each descriptor
for (i = 0; i < N_RX_DESC; i++)
{
// Owned by DMA
s_rxDescriptor[i].rdes0 = RDES0_OWNED_BY_DMA;
// Chained structure
s_rxDescriptor[i].rdes1 |= RDES1_RCH;
// Buffer size
s_rxDescriptor[i].rdes1 |= RX_BUFFER_LENGTH;
// Buffer address
s_rxDescriptor[i].rdes2 = (uint32_t)s_rxBuffer[i];
// Assign next descriptor address
if (i < (N_RX_DESC - 1))
{
s_rxDescriptor[i].rdes3 = (uint32_t)&s_rxDescriptor[i + 1];
}
else
{
s_rxDescriptor[i].rdes3 = (uint32_t)&s_rxDescriptor[0];
}
}
#if DEBUG_RX_DESC
hal_printf("----- After init RX desc -----\r\n");
eth_displayRxDescStatus();
#endif
// Initialize receive descriptor list address register
eth_initRxDescList((uint32_t)&s_rxDescriptor[0]);
}
//--//
BOOL __section(SectionForFlashOperations) AM29DL_16_BS_Driver::ChipInitialize( void* context )
{
NATIVE_PROFILE_HAL_DRIVERS_FLASH();
MEMORY_MAPPED_NOR_BLOCK_CONFIG* config = (MEMORY_MAPPED_NOR_BLOCK_CONFIG*)context;
// first setup the memory for wait states, read only, etc.
CPU_EBIU_ConfigMemoryBlock( config->Memory );
ChipReadOnly( config, FALSE, FLASH_PROTECTION_KEY );
// the flash are now not write protected
{
FLASH_WORD ManufacturerCode = 0;
FLASH_WORD DeviceCode = 0;
if(ReadProductID(config, ManufacturerCode, DeviceCode ))
{
hal_printf( "Flash product Manufacturer Code = 0x%08x, Device Code = 0x%08x\r\n", ManufacturerCode, DeviceCode );
if(ManufacturerCode != config->ManufacturerCode)
{
debug_printf( "ERROR: Unsupported Flash Manufacturer code: 0x%08x\r\n", ManufacturerCode );
}
if(DeviceCode != config->DeviceCode)
{
debug_printf( "ERROR: Unsupported Flash Device code: 0x%08x\r\n", DeviceCode );
}
}
else
{
debug_printf( "Flash_ReadProductID() failed.\r\n" );
}
}
ChipReadOnly(config, TRUE, FLASH_PROTECTION_KEY );
// the flash are now write protected
return TRUE;
}
static void findPhyAddr()
{
uint32_t phyAddress = 0;
uint16_t value;
uint32_t rc = 0xFF;
uint32_t cnt = 31; // 5 bit address
uint16_t ret;
do
{
ret = eth_readPhyRegister(phyAddress, PHY_IDENTIFIER_REGISTER_1, &value );
if ((value == PHY_KENDIN_OUI_ID1) || (value == PHY_ST802RT1X_OUI_ID1))
{
rc = phyAddress;
hal_printf( "Valid PHY Found: %x (%x)\r\n", rc, value);
g_foundPhyAddress = TRUE;
g_phyAddress = phyAddress;
break;
}
phyAddress = (phyAddress + 1) & 0x1F;
}while(--cnt);
}
// 81 Interrupt IRQ5
void INT_IRQ5(void){hal_printf( "INT_IRQ5\r\n" );/* sleep(); */}
BOOL MC9328MXL_SPI_Driver::Xaction_Start( const SPI_CONFIGURATION& Configuration )
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
if(!g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod])
{
g_MC9328MXL_SPI_Driver.m_Enabled[Configuration.SPI_mod] = TRUE;
UINT32 index = Configuration.SPI_mod;
MC9328MXL_SPI & SPI = MC9328MXL::SPI(index);
// make sure we didn't start one in the middle of an existing transaction
if( SPI.CONTROLREG & SPI.CONTROLREG_SPIEN )
{
lcd_printf("\fSPI Collision 1\r\n");
hal_printf("\fSPI Collision 1\r\n");
HARD_BREAKPOINT();
return FALSE;
}
// first build the mode register
SPI.CONTROLREG = MC9328MXL_SPI::ConfigurationToMode( Configuration );
// LCD Controller needs to have Pulse mode enabled
#if (HARDWARE_BOARD_TYPE >= HARDWARE_BOARD_i_MXS_DEMO_REV_V1_2)
if(Configuration.DeviceCS == MC9328MXL_SPI::c_SPI1_SS)
{
SPI.PERIODREG = 2;
SPI.CONTROLREG |= MC9328MXL_SPI::CONTROLREG_SSCTL_PULSE; // Pulse SS between bursts
// set the SSPOL to active lo as it is force at the ConfigurationMOde to not trigger SS for other SPI operation
SPI.CONTROLREG &= (~MC9328MXL_SPI::CONTROLREG_SSPOL_HIGH); // Pulse SS between bursts
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SS,RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
}
#endif
SPI.CONTROLREG |= MC9328MXL_SPI::CONTROLREG_SPIEN;
#if (SPI_LOOP_BACK)
// for spi testing
SPI.TESTREG |= SPI.TESTREG_LBC;
#endif
// everything should be clean and idle
ASSERT( SPI.TransmitBufferEmpty());
ASSERT( SPI.ReceiveBufferEmpty());
ASSERT( SPI.ShiftBufferEmpty ());
// make sure not trigger the SS pin for the LCD when doing any SPI activity.
// but we can have LCD SPI activity, if so, we want the SS be able to drive
#if (HARDWARE_BOARD_TYPE >= HARDWARE_BOARD_i_MXS_DEMO_REV_V1_2)
if(Configuration.DeviceCS != MC9328MXL_SPI::c_SPI1_SS)
{
CPU_GPIO_EnableInputPin( MC9328MXL_SPI::c_SPI1_SS, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLUP );
}
#endif
#if defined(PLATFORM_ARM_MC9328MXS)
// make sure that we don't trigger the SS pin for LCD
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SCLK, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MOSI, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
#else // MC9328MXL
if (index == MC9328MXL_SPI::c_SPI1)
{
// allow peripheral control of pins
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_SCLK, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MOSI, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY);
}
else
{
// SPI2 need to set to Alternate function - AIN
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_SCLK, RESISTOR_DISABLED, MC9328MXL_GPIO::DDIR__OUT, GPIO_ALT_MODE_1);
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_MOSI, RESISTOR_DISABLED, MC9328MXL_GPIO::DDIR__OUT, GPIO_ALT_MODE_1);
}
#endif
// first set CS active as soon as clock and data pins are in proper initial state
if((Configuration.DeviceCS != MC9328MXL_GPIO::c_Pin_None) && (Configuration.DeviceCS != MC9328MXL_SPI::c_SPI1_SS))
{
CPU_GPIO_EnableOutputPin( Configuration.DeviceCS, Configuration.CS_Active );
}
#if defined(PLATFORM_ARM_MC9328MXS)
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MISO, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY );
#else
if (index == MC9328MXL_SPI::c_SPI1)
{
CPU_GPIO_DisablePin( MC9328MXL_SPI::c_SPI1_MISO, RESISTOR_DISABLED, 0, GPIO_ALT_PRIMARY );
}
else
{
// set AOUT mode for MISO for SPI 2
CPU_GPIO_DisablePin(MC9328MXL_SPI::c_SPI2_MISO, RESISTOR_DISABLED,MC9328MXL_GPIO::DDIR__IN ,GPIO_ALT_MODE_4);
MC9328MXL::SC().FMCR |= MC9328MXL_SC::FMCR__SPI2_RXD_SEL;
}
#endif
if(Configuration.CS_Setup_uSecs)
{
HAL_Time_Sleep_MicroSeconds_InterruptEnabled( Configuration.CS_Setup_uSecs );
}
}
else
{
lcd_printf( "\fSPI Collision 3\r\n" );
HARD_BREAKPOINT();
return FALSE;
}
return TRUE;
}
void KeyPad_Test()
{
NATIVE_PROFILE_PAL_BUTTONS();
int return_value;
hal_printf("\r\n\nKeyscan Test (press 'Stop' to exit)\r\n");
g_GPIO_KEYPAD_Driver.KeyPad_Initialize();
/* start keyscan */
/* NOTE: enter "Stop" to exit the loop */
while (1)
{
return_value = g_GPIO_KEYPAD_Driver.KeyPad_Search();
if ( return_value != -1 )
{
switch ( return_value )
{
case 1:
hal_printf("UP\r\n");
break;
case 2:
hal_printf("DOWN\r\n");
break;
case 3:
hal_printf("LEFT\r\n");
break;
case 4:
hal_printf("RIGHT\r\n");
break;
case 5:
hal_printf("OK\r\n");
break;
case 6:
hal_printf("Fn\r\n");
break;
case 7:
hal_printf("C\r\n");
break;
case 8:
hal_printf("Dial\r\n");
break;
case 9:
hal_printf("Hang Up\r\n");
break;
case 10:
hal_printf("1\r\n");
break;
case 11:
hal_printf("2\r\n");
break;
case 12:
hal_printf("3\r\n");
break;
case 13:
hal_printf("4\r\n");
break;
case 14:
hal_printf("5\r\n");
break;
case 15:
hal_printf("6\r\n");
break;
case 16:
hal_printf("7\r\n");
break;
case 17:
hal_printf("8\r\n");
break;
case 18:
hal_printf("9\r\n");
break;
case 19:
hal_printf("*\r\n");
break;
case 20:
hal_printf("0\r\n");
break;
case 21:
hal_printf("#\r\n");
break;
case 22:
hal_printf("Prev\r\n");
break;
case 23:
hal_printf("Stop\r\n");
hal_printf("Exit Keypad Test");
return;
break;
case 24:
hal_printf("Play\r\n");
break;
case 25:
hal_printf("Next\r\n");
break;
}
}
else
{
//hal_printf("ERROR!!\r\n");
}
}
}
////////////////////////////////////////////////////////////////////////////////
// The TinyBooter_OnStateChange method is an event handler for state changes in
// the TinyBooter. It is designed to help porting kit users control the tinybooter
// execution and allow them to add diagnostics.
////////////////////////////////////////////////////////////////////////////////
void TinyBooter_OnStateChange( TinyBooterState state, void* data, void ** retData )
{
switch(state)
{
////////////////////////////////////////////////////////////////////////////////////
// State_EnterBooterMode - TinyBooter has entered upload mode
////////////////////////////////////////////////////////////////////////////////////
case State_EnterBooterMode:
CPU_GPIO_EnableOutputPin(LED1, TRUE);
CPU_GPIO_EnableOutputPin(LED2, TRUE);
CPU_GPIO_EnableOutputPin(LED3, TRUE);
#if defined(TARGETLOCATION_RAM)
CPU_GPIO_EnableOutputPin(LED4, TRUE);
#else
CPU_GPIO_EnableOutputPin(LED4, FALSE);
#endif
hal_fprintf( STREAM_LCD, "Waiting\r" );
break;
////////////////////////////////////////////////////////////////////////////////////
// State_ButtonPress - A button was pressed while Tinybooter
// The data parameter is a pointer to the timeout value for the booter mode.
////////////////////////////////////////////////////////////////////////////////////
case State_ButtonPress:
if(NULL != data)
{
UINT32 down, up;
INT32* timeout_ms = (INT32*)data;
// wait forever if a button was pressed
*timeout_ms = -1;
// process buttons
while(Buttons_GetNextStateChange(down, up))
{
// leave a way to exit boot mode incase it was accidentally entered
if(0 != (down & BUTTON_ENTR))
{
// force an enumerate and launch
*timeout_ms = 0;
}
}
}
break;
////////////////////////////////////////////////////////////////////////////////////
// State_ValidCommunication - TinyBooter has received valid communication from the host
// The data parameter is a pointer to the timeout value for the booter mode.
////////////////////////////////////////////////////////////////////////////////////
case State_ValidCommunication:
if(NULL != data)
{
INT32* timeout_ms = (INT32*)data;
// if we received any com/usb data then let's change the timeout to at least 20 seconds
if(*timeout_ms != -1 && *timeout_ms < 20000)
{
*timeout_ms = 20000;
}
}
break;
////////////////////////////////////////////////////////////////////////////////////
// State_Timeout - The default timeout for TinyBooter has expired and TinyBooter will
// perform an EnumerateAndLaunch
////////////////////////////////////////////////////////////////////////////////////
case State_Timeout:
break;
////////////////////////////////////////////////////////////////////////////////////
// State_MemoryXXX - Identifies memory accesses.
////////////////////////////////////////////////////////////////////////////////////
case State_MemoryWrite:
hal_fprintf( STREAM_LCD, "Wr: 0x%08x\r", (UINT32)data );
break;
case State_MemoryErase:
hal_fprintf( STREAM_LCD, "Er: 0x%08x\r", (UINT32)data );
break;
////////////////////////////////////////////////////////////////////////////////////
// State_CryptoXXX - Start and result of Crypto signature check
////////////////////////////////////////////////////////////////////////////////////
case State_CryptoStart:
hal_fprintf( STREAM_LCD, "Chk signature \r" );
hal_printf( "Chk signature \r" );
break;
// The data parameter is a boolean that represents signature PASS/FAILURE
case State_CryptoResult:
if((bool)data)
{
hal_fprintf( STREAM_LCD, "Signature PASS\r\n\r\n" );
hal_printf( "Signature PASS\r\n\r\n" );
}
else
{
hal_fprintf( STREAM_LCD, "Signature FAIL\r\n\r\n" );
hal_printf( "Signature FAIL\r\n\r\n" );
}
DebuggerPort_Flush(HalSystemConfig.DebugTextPort);
break;
////////////////////////////////////////////////////////////////////////////////////
// State_Launch - The host has requested to launch an application at a given address,
// or a timeout has occured and TinyBooter is about to launch the
// first application it finds in FLASH.
//
// The data parameter is a UINT32 value representing the launch address
////////////////////////////////////////////////////////////////////////////////////
case State_Launch:
if(NULL != data)
{
CPU_GPIO_EnableOutputPin(LED1, FALSE);
hal_fprintf( STREAM_LCD, "Starting application at 0x%08x\r\n", (UINT32)data );
// copy the native code from the Load area to execute area.
// set the *retAddres to real execute address after loading the data
// *retData = exeAddress
*retData =(void*) ((UINT32)data | 1); // set Thumb bit!
}
break;
}
}
BOOL USART_Driver::AddCharToRxBuffer( int ComPortNum, char c )
{
ASSERT_IRQ_MUST_BE_OFF();
if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) return FALSE;
HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];
if (USART_FLAG_STATE(State, HAL_USART_STATE::c_TX_SWFLOW_CTRL))
{
switch( c )
{
case XOFF:
State.TicksStartTxXOFF = HAL_Time_CurrentTicks();
CLEAR_USART_FLAG(State, HAL_USART_STATE::c_TX_XON_STATE);
return TRUE;
case XON:
SET_USART_FLAG(State, HAL_USART_STATE::c_TX_XON_STATE);
return TRUE;
}
}
{
GLOBAL_LOCK(irq);
UINT8* Dst = State.RxQueue.Push();
if(Dst)
{
*Dst = c;
if( State.RxQueue.NumberOfElements() >= State.RxBufferHighWaterMark )
{
if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL) )
{
// Set our XOFF state
SendXOFF( ComPortNum, XOFF_FLAG_FULL );
}
if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL) )
{
// Hold off receiving characters (should pull HW handshake automatically)
CPU_USART_RxBufferFullInterruptEnable(ComPortNum, FALSE);
}
}
}
else
{
SetEvent( ComPortNum, USART_EVENT_ERROR_RXOVER );
#if !defined(BUILD_RTM)
lcd_printf("\fBuffer OVFLW\r\n");
hal_printf("Buffer OVFLW\r\n");
#endif
return FALSE;
}
}
SetEvent( ComPortNum, USART_EVENT_DATA_CHARS );
Events_Set( SYSTEM_EVENT_FLAG_COM_IN );
return TRUE;
}
void ApplicationEntryPoint()
{
char Data[1], previousChar = '\0';
int ret = 0, TestItem = 0;
BOOL validCommand = TRUE;
MEMORY_MAPPED_NOR_BLOCK_CONFIG* config;
// BlockStorageDevice *device;
// ByteAddress datByteAddress;
// BlockStorageList::FindDeviceForPhysicalAddress( &device, 0, datByteAddress );
// const BlockDeviceInfo * deviceInfo=device->GetDeviceInfo();
Data[1] = '\0';
char ip[15];
int length;
unsigned long dest_ip=0;
UINT32 sleep = 100;
// TimedEvents eventsTest;
// UART usartTest ( COMTestPort, 9600, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE );
// GPIO gpioTest ( GPIOTestPin );
do
{
lcd_printf( "\n\n\n\n\n\n\n\n SH7619 EVB\n" );
lcd_printf( " Renesas America Inc." );
//Serial TEST
hal_printf( "\r\nSH7619 EVB .NET Micro Framework NativeSample\r\n" );
hal_printf( "Renesas Electronics America Inc.\r\n" );
hal_printf( "61 MHz Clk,Big-endian\r\n" );
hal_printf( ">" );
NATIVE_PROFILE_PAL_EVENTS();
do
{
UINT32 Events = Events_WaitForEvents( SYSTEM_EVENT_FLAG_COM_IN | SYSTEM_EVENT_FLAG_ETHER, sleep );
// if(Events == 0)
// {
// hal_printf("Slept %d sec\r\n", sleep / 1000);
// sleep += 1000;
// continue;
// }
if(Events & SYSTEM_EVENT_FLAG_ETHER)
{
//Network_Interface_Process_Packet();
//hal_printf("ETHER event\r\n");
Events_Clear( SYSTEM_EVENT_FLAG_ETHER );
}
if(Events & SYSTEM_EVENT_FLAG_COM_IN)
{
Events_Clear( SYSTEM_EVENT_FLAG_COM_IN );
while((ret = DebuggerPort_Read( HalSystemConfig.DebugTextPort, Data, 1 )) > 0)
{
switch(TestItem)
{
case 0: //None
if(Data[0] == 0xD) //0xD: ENTER key
{
hal_printf( "\r\n" );
if(validCommand)
{
TestItem = 1; //Enter test
validCommand = FALSE;
previousChar = '\0';
hal_printf( "\r\nTest Menu:\r\n" );
hal_printf( " [L]CD Tests\r\n" );
hal_printf( " [K]eypad Tests\r\n" );
hal_printf( " [N]etwork Tests\r\n" );
hal_printf( " [F]lash memory Tests\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
}
else if(previousChar == 'I')
{
hal_printf("** Invalid Selection\r\n>");
previousChar = '\0';
}
else
hal_printf( ">" );
}
else
{
hal_printf( Data );
if(Data[0] == 'd' || Data[0] == 'D')
{
if(previousChar == '\0')
previousChar = 'd';
else
{
validCommand = FALSE;
previousChar = 'I'; //Invalid character input
}
}
else if(Data[0] == 't' || Data[0] == 'T')
{
if(previousChar == 'd')
{
previousChar = 't';
validCommand = TRUE;
}
else
{
validCommand = FALSE;
previousChar = 'I'; //Invalid character input
}
}
else
{
validCommand = FALSE;
previousChar = 'I'; //Invalid character input
}
}
break;
case 1: //Enter test
hal_printf( Data );
switch(Data[0])
{
case 'X':
case 'x':
TestItem = 0;
hal_printf( "\r\n\n>" );
break;
case 'L':
case 'l':
TestItem = 5;
hal_printf( "\r\n\nLCD Menu:\r\n" );
hal_printf( " 1: Display colorful rectangles\r\n" );
hal_printf( " 2: Colorful wireframe rectangle\r\n" );
hal_printf( " 3: Colorful solid rectangle\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case 'K':
case 'k':
KeyPad_Test();
break;
case 'N':
case 'n':
TestItem = 7;
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case 'F':
case 'f':
TestItem = 8;
hal_printf( "\r\n\nFlash memory Menu:\r\n" );
hal_printf( " [1]Erase block\r\n" );
hal_printf( " [2]write block\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
default:
hal_printf( "\r\n\nTest Menu:\r\n" );
hal_printf( " [L]CD Tests\r\n" );
hal_printf( " [K]eypad Tests\r\n" );
hal_printf( " [N]etwork Tests\r\n" );
hal_printf( " [F]lash memory Tests\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
}
break;
case 5: //LCD test
hal_printf( Data );
switch(Data[0])
{
case 'X':
case 'x':
TestItem = 1;
hal_printf( "\r\n\nTest Menu:\r\n" );
hal_printf( " [L]CD Tests\r\n" );
hal_printf( " [K]eypad Tests\r\n" );
hal_printf( " [N]etwork Tests\r\n" );
hal_printf( " [F]lash memory Tests\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '1':
LCDTest_Driver::LCD_Sample1();
hal_printf( "\r\n\nLCD Menu:\r\n" );
hal_printf( " 1: Display colorful rectangles\r\n" );
hal_printf( " 2: Colorful wireframe rectangle\r\n" );
hal_printf( " 3: Colorful solid rectangle\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '2':
LCDTest_Driver::LCD_Sample2(0);
hal_printf( "\r\n\nLCD Menu:\r\n" );
hal_printf( " 1: Display colorful rectangles\r\n" );
hal_printf( " 2: Colorful wireframe rectangle\r\n" );
hal_printf( " 3: Colorful solid rectangle\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '3':
LCDTest_Driver::LCD_Sample2(1);
hal_printf( "\r\n\nLCD Menu:\r\n" );
hal_printf( " 1: Display colorful rectangles\r\n" );
hal_printf( " 2: Colorful wireframe rectangle\r\n" );
hal_printf( " 3: Colorful solid rectangle\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
default:
hal_printf( "\r\n\nLCD Menu:\r\n" );
hal_printf( " 1: Display colorful rectangles\r\n" );
hal_printf( " 2: Colorful wireframe rectangle\r\n" );
hal_printf( " 3: Colorful solid rectangle\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
}
break;
case 7: //Ethernet test
hal_printf( Data );
hal_printf( "\r\n" );
switch(Data[0])
{
case 'X':
case 'x':
TestItem = 1;
hal_printf( "\r\n\nTest Menu:\r\n" );
hal_printf( " [L]CD Tests\r\n" );
hal_printf( " [K]eypad Tests\r\n" );
hal_printf( " [N]etwork Tests\r\n" );
hal_printf( " [F]lash memory Tests\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '1':
//Network_Interface_IP_Address();
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '2':
//Network_Interface_EtherC_Registers();
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '3':
//Network_Interface_EDMAC_Registers();
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '4':
//do
//{
// hal_printf( "\r\nEnter dest IP: " );
// Get_IP_String(ip, &length);
// if( (dest_ip = Is_IP_Address(ip, length)) == 0)
// hal_printf( "\r\n*** Invalid IP Address!\r\n" );
//}while(dest_ip == 0);
//Ether_Ping(dest_ip, 4);
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
default:
hal_printf( "\r\n\nEthernet Menu:\r\n" );
hal_printf( " [1]Read IP Address\r\n" );
hal_printf( " [2]Read EtherC Registers\r\n" );
hal_printf( " [3]Read E-DMAC Registers\r\n" );
hal_printf( " [4]Ping Test\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
}
break;
case 8: //Flash memory test
hal_printf( Data );
hal_printf( "\r\n" );
switch(Data[0])
{
case 'X':
case 'x':
TestItem = 1;
hal_printf( "\r\n\nTest Menu:\r\n" );
hal_printf( " [L]CD Tests\r\n" );
hal_printf( " [K]eypad Tests\r\n" );
hal_printf( " [N]etwork Tests\r\n" );
hal_printf( " [F]lash memory Tests\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '1':
g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG);
g_AM29DL_16_BS_DeviceTable.EraseBlock(pBLOCK_CONFIG,0xa0080000);
hal_printf( "\r\n\nFlash memory Menu:\r\n" );
hal_printf( " [1]Erase block\r\n" );
hal_printf( " [2]write block\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
case '2':
BYTE Buff[0x10];
for(int i=0; i<0x10; i++) Buff[i]=i;
g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG);
g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,0xa0080000,0x10,Buff,0x0);
hal_printf( "\r\n\nFlash memory Menu:\r\n" );
hal_printf( " [1]Erase block\r\n" );
hal_printf( " [2]write block\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
default:
hal_printf( "\r\n\nFlash memory Menu:\r\n" );
hal_printf( " [1]Erase block\r\n" );
hal_printf( " [2]write block\r\n" );
hal_printf( " E[x]it\r\n" );
hal_printf( "Your choice: " );
break;
}
break;
}
}
}
} while(TRUE);
} while(FALSE); // run only once!
}
void SH7619_EDMAC_recv(PIFACE pi)
{
DCU msg;
RTP_UINT16 FrameLength = 0;
long leng;
UINT16 BufferLength;
UINT32 tmpIdx = rxTd.idx;
char* recv_packet;
int tries = 100;
BOOL recv_error = FALSE;
BOOL mem_error = FALSE;
EmacTDescriptor *pRxTd;
BOOL isFrame = FALSE;
GLOBAL_LOCK(encIrq);
pRxTd = *(rxTd.td + rxTd.idx);
while ((pRxTd->status & ACT) != 0 && tries-- > 0)
{
for(int i = 0; i < 500; i++);
}
if(tries <= 0)
{
//while ((pRxTd->status & ACT) != 0 && tries++ < RX_BUFFERS)
//{
// CIRC_INC(rxTd.idx, RX_BUFFERS);
// pRxTd = *(rxTd.td + rxTd.idx);
//}
//tmpIdx = rxTd.idx;
return;
}
while ((pRxTd->status & ACT) == 0)
{
leng = pRxTd->RDL;
// A start of frame has been received
if((pRxTd->status & FP1) != 0)
{
// Skip previous fragment
while (tmpIdx != rxTd.idx)
{
pRxTd = *(rxTd.td + rxTd.idx);
pRxTd->status |= ACT;
CIRC_INC(rxTd.idx, RX_BUFFERS);
}
FrameLength = 0;
// Start to gather buffers in a frame
isFrame = TRUE;
}
// Increment the pointer
CIRC_INC(tmpIdx, RX_BUFFERS);
if(isFrame)
{
if (tmpIdx == rxTd.idx)
{
hal_printf("Receive buffer is too small for the current frame!\r\n");
do
{
//FrameLength += pRxTd->RDL;
pRxTd = *(rxTd.td + rxTd.idx);
pRxTd->status |= ACT;
CIRC_INC(rxTd.idx, RX_BUFFERS);
} while(tmpIdx != rxTd.idx);
}
if((pRxTd->status & FE) != 0)
{
recv_error = TRUE;
}
FrameLength += leng;
// An end of frame has been received
if((pRxTd->status & FP0) != 0)
{
tries = 0;
if(recv_error == FALSE)
{
do
{
msg = os_alloc_packet_input(FrameLength, DRIVER_ALLOC);
if(!msg)
for(int i = 0; i < 5000; i++); //delay
}while(!msg && tries++ < 50);
if (msg)
{
recv_packet = (char*)DCUTODATA(msg);
msg->length = FrameLength;
}
else
{
mem_error = TRUE;
}
}
else
{
mem_error = TRUE;
}
BufferLength = EMAC_RX_UNITSIZE;
// Get all the data
while (rxTd.idx != tmpIdx)
{
pRxTd = *(rxTd.td + rxTd.idx);
if(mem_error == FALSE)
{
if(BufferLength >= FrameLength)
{
memcpy(recv_packet, (void*)(pRxTd->TRBA), FrameLength);
}
else
{
memcpy(recv_packet, (void*)(pRxTd->TRBA), BufferLength);
FrameLength -= BufferLength;
recv_packet += BufferLength;
}
}
pRxTd->status |= ACT;
CIRC_INC(rxTd.idx, RX_BUFFERS);
}
// signal IP layer that a packet is on its exchange
if(mem_error == FALSE)
rtp_net_invoke_input(pi, msg, msg->length);
// Prepare for the next Frame
isFrame = FALSE;
recv_error = FALSE;
mem_error = FALSE;
}
}// if(isFrame) ends
else
{
pRxTd->status |= ACT;
rxTd.idx = tmpIdx;
}
// Process the next buffer
pRxTd = *(rxTd.td + tmpIdx);
}
}
RTP_BOOL SH7619_EDMAC_open(PIFACE pi)
{
PSH7619_EDMAC_SOFTC sc = iface_to_softc(pi);
char c[1],Buffer[17];
int i;
UINT32 Events;
BYTE Buff[6];
if (!sc)
{
RTP_DEBUG_ERROR("SH7619_EDMAC_open: softc invalid!\r\n", NOVAR, 0, 0);
set_errno(ENUMDEVICE);
return(RTP_FALSE);
}
// Set Interface
sc->iface = pi;
iface = pi;
int macLen = __min(g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressLen, sizeof(sc->mac_address));
if(macLen > 0)
{
int addr = MAC_address_area;
for(i=0; i<macLen; i++) g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i] = *(volatile char *)(addr+i);
debug_printf( "MAC Address: %x.%x.%x.%x.%x.%x\r\n", (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0],
(UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[1],
(UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[2],
(UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[3],
(UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[4],
(UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[5]);
debug_printf( "Do you need to change MAC Address? If yes, press 'Enter' key\r\n" );
c[0] = 0x0;
for (i=0; i<0xff; i++){
DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1);
if (c[0] == 0x0d){
hal_printf( "new MAC Address :" );
while(c[0] == 0x0d) DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1);
for(i=0; i<17; ){
Events = Events_WaitForEvents( SYSTEM_EVENT_FLAG_COM_IN, 100 );
if(Events & SYSTEM_EVENT_FLAG_COM_IN){
Events_Clear( SYSTEM_EVENT_FLAG_COM_IN );
DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1);
Buffer[i] = c[0];
i++;
}
}
for (i=0; i<17; i++) hal_printf( "%c",Buffer[i] );
hal_printf( "\r\n");
for(i=0; i<macLen; i++) {
Buff[i]=SH7619_EDMAC_AtoH(Buffer[i*3])*0x10;
Buff[i]+=SH7619_EDMAC_AtoH(Buffer[i*3+1]);
}
for(i=0; i<macLen; i++) {
g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i]=Buff[i];
}
debug_printf( "Updating...\r\n" );
g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG);
g_AM29DL_16_BS_DeviceTable.EraseBlock(pBLOCK_CONFIG,MAC_address_area);
g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,MAC_address_area,macLen,Buff,0x0);
debug_printf( "Done\r\n" );
i=0x100;
}
}
memcpy(&sc->mac_address[0], &g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0], macLen);
}
else
{
RTP_DEBUG_ERROR("Device initialize without MAC address!!!\r\n", NOVAR, 0, 0);
}
/* Now put in a dummy ethernet address */
rtp_memcpy(&pi->addr.my_hw_addr[0], sc->mac_address, 6); // Get the ethernet address
/* clear statistic information */
sc->stats.packets_in = 0L;
sc->stats.packets_out = 0L;
sc->stats.bytes_in = 0L;
sc->stats.bytes_out = 0L;
sc->stats.errors_in = 0L;
sc->stats.errors_out = 0L;
if(RTP_FALSE == SH7619_EDMAC_SetupDevice())
{
return RTP_FALSE;
}
rtp_irq_hook_interrupt( (RTP_PFVOID) pi,
(RTP_IRQ_FN_POINTER)SH7619_EDMAC_recv,
(RTP_IRQ_FN_POINTER) 0);
return(RTP_TRUE);
}
void ApplicationEntryPoint()
{
UINT32 ComEvent;
g_State.Initialize();
ComEvent = 0;
if(COM_IsSerial(g_State.UsartPort) && (g_State.UsartPort != COM_NULL))
{
ComEvent = SYSTEM_EVENT_FLAG_COM_IN;
}
#if !defined(TARGETLOCATION_RAM)
g_State.WaitForActivity = (g_State.ProgramCount != 0); // is there a main app?
#else
g_State.WaitForActivity = FALSE; // forever
#endif
{
UINT32 ButtonsPressed;
UINT32 ButtonsReleased;
char c;
// clear any events present from startup
while(Events_Get( SYSTEM_EVENT_FLAG_ALL ));
// clear any junk from com port buffers
while(DebuggerPort_Read( g_State.UsartPort, &c, sizeof(c) ));
// clear any junk from button buffer
while(Buttons_GetNextStateChange( ButtonsPressed, ButtonsReleased ));
}
{
BOOL ProcessingSREC = FALSE;
BOOL ProcessingXREC = FALSE;
INT32 ProcessingZENFLASH = 0;
INT32 Mode = 0;
INT32 MenuChoice = 1; // main application location when USB not enabled
BOOL MenuUpdate = TRUE;
UINT32 USBEvent = 0;
COM_HANDLE ReadPort = COM_NULL;
int MenuOffset = 1; // no USB enabled
INT64 WaitTimeout = 0;
#if defined(PLATFORM_ARM_MOTE2)
CPU_GPIO_SetPinState( LED1_GREEN, LED_ON );
#endif
if(g_State.WaitForActivity)
{
WaitTimeout = HAL_Time_CurrentTime() + (INT64)g_State.WaitInterval * (10 * 1000);
hal_printf( "Waiting %d.%03d second(s) for hex upload\r\n", g_State.WaitInterval / 1000, g_State.WaitInterval % 1000 );
}
else
{
hal_printf( "Waiting forever for hex upload\r\n" );
}
// checking the existence of Usb Driver, all the default values are set to no USB
if( USB_DEVICE_STATE_NO_CONTROLLER != USB_GetStatus( ConvertCOM_UsbController(g_State.UsbPort) ) )
{
g_State.UsingUsb = TRUE;
MenuChoice = 2;
MenuOffset = 2;
}
while(true)
{
if(MenuUpdate)
{
MenuUpdate = FALSE;
LCD_Clear();
hal_fprintf( STREAM_LCD, "\f");
switch(Mode)
{
case 0:
hal_fprintf( STREAM_LCD, " Zen Boot\r\n\r\n" );
hal_fprintf( STREAM_LCD, "%c PortBooter\r\n", MenuChoice == 0 ? '*' : ' ' );
if(g_State.UsingUsb)
{
hal_fprintf( STREAM_LCD, "%c FlashUSB\r\n", MenuChoice == 1 ? '*' : ' ' );
}
for(int i = 0; i < g_State.ProgramCount; i++)
{
hal_fprintf( STREAM_LCD, "%c Prg:%08x\r\n", (i+MenuOffset) == MenuChoice ? '*' : ' ', g_State.Programs[i] );
}
break;
case 1:
hal_printf( "PortBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION);
hal_fprintf( STREAM_LCD, "Waiting forever for hex upload\r\n" );
break;
case 2:
hal_fprintf( STREAM_LCD, "FlashUSB\r\n" );
hal_fprintf( STREAM_LCD, "Waiting forever for hex upload\r\n" );
break;
}
}
UINT32 Events = Events_WaitForEvents( ComEvent | SYSTEM_EVENT_FLAG_BUTTON | SYSTEM_EVENT_FLAG_USB_IN, 2000 );
if(Events & SYSTEM_EVENT_FLAG_BUTTON)
{
UINT32 ButtonsPressed;
UINT32 ButtonsReleased;
Events_Clear( SYSTEM_EVENT_FLAG_BUTTON );
while(Buttons_GetNextStateChange( ButtonsPressed, ButtonsReleased ));
{
if(g_State.SerialPortActive == FALSE)
{
//printf("%02x %02x\r\n", ButtonsPressed, ButtonsReleased);
// up
if(ButtonsPressed & BUTTON_UP)
{
switch(Mode)
{
case 0:
MenuChoice = __max( MenuChoice-1, 0 );
break;
}
g_State.WaitForActivity = FALSE;
MenuUpdate = TRUE;
}
// down
if(ButtonsPressed & BUTTON_DOWN)
{
switch(Mode)
{
case 0:
MenuChoice = __min( MenuChoice+1, g_State.ProgramCount + MenuOffset-1 );
break;
}
g_State.WaitForActivity = FALSE;
MenuUpdate = TRUE;
}
// enter button
if(ButtonsPressed & BUTTON_ENTR)
{
switch(Mode)
{
case 0:
if(MenuChoice == 0)
{
Mode = 1;
//UsingUsb = FALSE;
}
else if(g_State.UsingUsb && MenuChoice == 1)
{
Mode = 2;
USB_Configure( ConvertCOM_UsbController(g_State.UsbPort), &UsbDefaultConfiguration );
USB_Initialize( ConvertCOM_UsbController(g_State.UsbPort) );
USB_OpenStream( ConvertCOM_UsbStream(g_State.UsbPort), USB_DEBUG_EP_WRITE, USB_DEBUG_EP_READ );
//UsingUsb = TRUE;
}
else
{
StartApplication( (void (*)())g_State.Programs[MenuChoice-MenuOffset] );
}
break;
case 1:
Mode = 0;
break;
case 2:
// USB_Uninitialize();
Mode = 0;
break;
}
g_State.WaitForActivity = FALSE;
MenuUpdate = TRUE;
}
if(ButtonsReleased)
{
MenuUpdate = TRUE;
}
}
}
}
if((Events & ComEvent) || (Events & SYSTEM_EVENT_FLAG_USB_IN))
{
char c;
if(Events & ComEvent)
{
Events_Clear( ComEvent );
ReadPort = g_State.UsartPort;
g_State.pStreamOutput = ReadPort;
}
else
{
USBEvent = USB_GetEvent( ConvertCOM_UsbController(g_State.UsbPort), USB_EVENT_ALL );
if( !(USBEvent & g_State.UsbEventCode) )
continue;
g_State.pStreamOutput = g_State.UsbPort;
ReadPort = g_State.UsbPort;
}
while(DebuggerPort_Read( ReadPort, &c, sizeof(c) ))
{
if(ProcessingSREC)
{
ProcessingSREC = g_SREC.Process( c );
}
else if(ProcessingXREC)
{
ProcessingXREC = g_XREC.Process( c );
}
else if(ProcessingZENFLASH)
{
const char Signature[] = "ZENFLASH\r";
//printf( "Got %d at %d\r\n", c, ProcessingZENFLASH );
if(Signature[ProcessingZENFLASH++] == c)
{
if(Signature[ProcessingZENFLASH] == 0)
{
SignalActivity();
ProcessingZENFLASH = 0;
}
}
else
{
ProcessingZENFLASH = 0;
}
}
else if('S' == c)
{
ProcessingSREC = TRUE;
}
else if('X' == c)
{
ProcessingXREC = TRUE;
}
else if('Z' == c)
{
ProcessingZENFLASH = 1;
}
}
}
if(g_State.WaitForActivity && WaitTimeout < HAL_Time_CurrentTime())
{
#if defined(PLATFORM_ARM_MOTE2)
CPU_GPIO_SetPinState(LED1_GREEN, LED_OFF); // Turn off Green LED for iMOTE2
#endif
// we didn't see anything on serial port for wait interval (2 seconds nominally),
// continue with code - just run the normal application
StartApplication( (void (*)())g_State.Programs[0] );
}
}
}
}
void Initialize()
{
#if defined(PLATFORM_ARM_MOTE2)
if (COM_IsUsb(HalSystemConfig.DebugTextPort))
WaitInterval = 5000; // The USB port must be selected and the Start button pressed all during this time
else
WaitInterval = 2000; // The USART port may be selected before powering on the Imote2, so it takes less time
#else
WaitInterval = 2000;
#endif
SerialPortActive = FALSE;
UsartPort = USART_DEFAULT_PORT;
UsingUsb = FALSE;
UsbPort = USB1;
UsbEventCode = USB_DEBUG_EVENT_IN;
//--//
// wait an extra second for buttons and COM port to stabilize
Events_WaitForEvents( 0, 1000 );
// COM init is now delayed for TinyBootloader, so we need to initialize it here
CPU_InitializeCommunication();
//--//
// set default baud rate
if(UsartPort != DEBUG_TEXT_PORT)
{
DebuggerPort_Initialize( UsartPort );
}
// extra time to allow USB setup, so that we can see the printf
Events_WaitForEvents( 0, 1000 );
hal_printf( "PortBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION);
hal_printf( "Build Date: %s %s\r\n", __DATE__, __TIME__);
#if defined(__GNUC__)
hal_printf( "GNU Compiler version %d\r\n", __GNUC__);
#elif defined(__ADSPBLACKFIN__)
hal_printf( "Blackfin Compiler version %d\r\n", __VERSIONNUM__ );
#else
hal_printf( "ARM Compiler version %d\r\n", __ARMCC_VERSION);
#endif
//--//
BlockStorageStream stream;
FLASH_WORD ProgramWordCheck;
if(!stream.Initialize(BlockUsage::CODE)) return;
do
{
do
{
UINT32 addr = stream.CurrentAddress();
FLASH_WORD *pWord = &ProgramWordCheck;
stream.Read( (BYTE**)&pWord, sizeof(FLASH_WORD) );
if(*pWord == PROGRAM_WORD_CHECK)
{
hal_printf("*** nXIP Program found at 0x%08x\r\n", addr );
Programs[ProgramCount++] = (UINT32)addr;
}
if(ProgramCount == MAX_PROGRAMS) break;
}
while( stream.Seek( BlockStorageStream::STREAM_SEEK_NEXT_BLOCK, BlockStorageStream::SeekCurrent ) );
} while(stream.NextStream());
}
BOOL Process( UINT8 c )
{
while(true)
{
switch(m_phase)
{
//
// Setup 'address' reception.
//
case 0:
m_ptr = (char*)&m_address;
m_len = sizeof(m_address);
m_phase++;
break;
//
// Setup 'size' reception.
//
case 2:
//printf( "Got address %08x\r\n", m_address );
m_ptr = (char*)&m_size;
m_len = sizeof(m_size);
m_phase++;
return TRUE;
//
// Setup 'crc' reception.
//
case 4:
//printf( "Got size %08x\r\n", m_size );
m_ptr = (char*)&m_crc;
m_len = sizeof(m_crc);
m_phase++;
return TRUE;
//
// Setup 'data' reception or jump to entrypoint.
//
case 6:
//printf( "Got crc %08x\r\n", m_crc );
m_crc += m_address;
m_crc += m_size;
if(m_size == 0)
{
if(m_crc != 0)
{
hal_fprintf( g_State.pStreamOutput, "X crc %08x %08x\r\n", m_address, m_crc );
// bad characters! realign
m_phase = 0;
return FALSE;
}
hal_fprintf( g_State.pStreamOutput, "X start %08x\r\n", m_address );
#if defined(PLATFORM_ARM_MOTE2)
CPU_GPIO_SetPinState(LED1_GREEN, LED_OFF); // Turn off Green LED for iMote2
#endif
StartApplication( (void (*)())m_address );
}
if(m_size > sizeof(m_data) || (m_size % sizeof(FLASH_WORD)) != 0)
{
hal_fprintf( g_State.pStreamOutput, "X size %d\r\n", m_size );
// bad characters! realign
m_phase = 0;
return FALSE;
}
m_ptr = (char*)m_data;
m_len = m_size;
m_phase++;
return TRUE;
case 8:
{
FLASH_WORD* src = (FLASH_WORD*)m_data;
FLASH_WORD* dst = (FLASH_WORD*)m_address;
BOOL success = TRUE;
int i;
BlockStorageDevice * pDevice;
ByteAddress WriteByteAddress ;
for(i=0; i<m_size; i++)
{
m_crc += m_data[i];
}
if(m_crc != 0)
{
hal_fprintf( g_State.pStreamOutput, "X crc %08x %08x\r\n", m_address, m_crc );
// bad characters! realign
m_phase = 0;
return FALSE;
}
SignalActivity();
// this slows things down to print every address, only print once per line
hal_fprintf( STREAM_LCD, "WR: 0x%08x\r", (UINT32)dst );
// if it not Block Device, assume it is RAM
if (BlockStorageList::FindDeviceForPhysicalAddress( & pDevice, m_address, WriteByteAddress))
{
UINT32 regionIndex, rangeIndex;
const BlockDeviceInfo* deviceInfo = pDevice->GetDeviceInfo() ;
if(!(pDevice->FindRegionFromAddress(WriteByteAddress, regionIndex, rangeIndex)))
{
#if !defined(BUILD_RTM)
hal_printf(" Invalid condition - Fail to find the block number from the ByteAddress %x \r\n",WriteByteAddress);
#endif
return FALSE;
}
// start from the block where the sector sits.
UINT32 iRegion = regionIndex;
UINT32 accessPhyAddress = (UINT32)m_address;
BYTE* bufPtr = (BYTE*)src;
BOOL success = TRUE;
INT32 writeLenInBytes = m_size;
while (writeLenInBytes > 0)
{
for(; iRegion < deviceInfo->NumRegions; iRegion++)
{
const BlockRegionInfo *pRegion = &(deviceInfo->Regions[iRegion]);
ByteAddress blkAddr = pRegion->Start;
while(blkAddr < accessPhyAddress)
{
blkAddr += pRegion->BytesPerBlock;
}
//writeMaxLength =the current largest number of bytes can be read from the block from the address to its block boundary.
UINT32 NumOfBytes = __min(pRegion->BytesPerBlock, writeLenInBytes);
if (accessPhyAddress == blkAddr && !pDevice->IsBlockErased(blkAddr, pRegion->BytesPerBlock))
{
hal_fprintf( STREAM_LCD, "ER: 0x%08x\r", blkAddr );
pDevice->EraseBlock(blkAddr);
blkAddr += pRegion->BytesPerBlock;
}
success = pDevice->Write(accessPhyAddress , NumOfBytes, (BYTE *)bufPtr, FALSE);
writeLenInBytes -= NumOfBytes;
if ((writeLenInBytes <=0) || (!success)) break;
bufPtr += NumOfBytes;
}
if ((writeLenInBytes <=0) || (!success)) break;
}
}
else
{
// must be RAM but don't verify, we write anyway, possibly causing a data abort if the address is bogus
memcpy( dst, src, m_size );
}
hal_fprintf( g_State.pStreamOutput, "X %s %08x\r\n", success ? "ack" : "nack", m_address );
m_phase = 0;
return FALSE;
}
break;
//
// Read data.
//
case 1:
case 3:
case 5:
case 7:
*m_ptr++ = c; if(--m_len) return TRUE;
m_phase++;
break;
}
}
}
BOOL ParseLine( const char* SRECLine )
{
UINT32 Address;
int i;
UINT32 BytesRemaining = 0;
UINT32 Temp = 0;
UINT32 Data32;
UINT32 RecordType;
UINT32 CheckSum;
UINT32 WordCount = 0;
UINT32 ByteCount = 0;
FLASH_WORD WordData[16/sizeof(FLASH_WORD)]; // we support 16 bytes of data per record max, 4 words, 8 shorts
UINT8 ByteData[16]; // we support 16 bytes of data per record max, 4 words, 8 shorts
BlockStorageDevice *pDevice;
UINT32 m_size;
ByteAddress WriteByteAddress;
RecordType = *SRECLine++;
SRECLine = htoi( SRECLine, 2, BytesRemaining ); if(!SRECLine) return FALSE;
// start the checksum with this byte
CheckSum = BytesRemaining;
// get the destination address
// do bytes only to make checksum calc easier
Data32 = 0;
for(i = 0; i < 4; i++)
{
SRECLine = htoi( SRECLine, 2, Temp ); if(!SRECLine) return FALSE;
CheckSum += Temp;
Data32 <<= 8;
Data32 |= Temp;
BytesRemaining -= 1;
}
Address = Data32;
// take off one byte for CRC;
m_size = BytesRemaining -1;
switch(RecordType)
{
case '3':
{
while(BytesRemaining > 1)
{
// get bytes into words, and checksum
Data32 = 0;
for(i = 0; i < sizeof(FLASH_WORD); i++)
{
SRECLine = htoi( SRECLine, 2, Temp ); if(!SRECLine) return FALSE;
CheckSum += Temp;
Data32 |= Temp << (i*8); // little endian format
ByteData[ByteCount++] = Temp;
BytesRemaining -= 1;
// leave the checksum in place
if(1 == BytesRemaining) break;
}
ASSERT(WordCount < (16/sizeof(FLASH_WORD)));
WordData[WordCount++] = Data32;
}
}
break;
case '7':
// just a return address (starting location)
m_StartAddress = (UINT32)Address;
break;
default:
// we only support S3 and S7 records, for now
return FALSE;
}
// get the checksum
SRECLine = htoi( SRECLine, 2, Temp ); if(!SRECLine) return FALSE;
CheckSum += Temp;
BytesRemaining -= 1;
ASSERT(0 == BytesRemaining);
// make sure we had a NULL terminator for line, and not more characters
if(*SRECLine != 0)
{
return FALSE;
}
if(0xff != (CheckSum & 0xff))
{
return FALSE;
}
else
{
// only write if we succeeded the checksum entirely for whole line
if(m_size > 0)
{
SignalActivity();
// this slows things down to print every address, only print once per line
hal_fprintf( STREAM_LCD, "WR: 0x%08x\r", (UINT32)Address );
if (BlockStorageList::FindDeviceForPhysicalAddress( &pDevice, Address, WriteByteAddress))
{
UINT32 regionIndex, rangeIndex;
const BlockDeviceInfo* deviceInfo = pDevice->GetDeviceInfo() ;
if(!(pDevice->FindRegionFromAddress(WriteByteAddress, regionIndex, rangeIndex)))
{
#if !defined(BUILD_RTM)
hal_printf(" Invalid condition - Fail to find the block number from the ByteAddress %x \r\n",WriteByteAddress);
#endif
return FALSE;
}
// start from the block where the sector sits.
UINT32 iRegion = regionIndex;
UINT32 accessPhyAddress = (UINT32)Address;
BYTE* bufPtr = (BYTE*)ByteData;
BOOL success = TRUE;
INT32 writeLenInBytes = m_size;
while (writeLenInBytes > 0)
{
for(; iRegion < deviceInfo->NumRegions; iRegion++)
{
const BlockRegionInfo *pRegion = &(deviceInfo->Regions[iRegion]);
ByteAddress blkAddr = pRegion->Start;
while(blkAddr < accessPhyAddress)
{
blkAddr += pRegion->BytesPerBlock;
}
//writeMaxLength =the current largest number of bytes can be read from the block from the address to its block boundary.
UINT32 NumOfBytes = __min(pRegion->BytesPerBlock, writeLenInBytes);
if (accessPhyAddress == blkAddr && !pDevice->IsBlockErased(blkAddr, pRegion->BytesPerBlock))
{
hal_fprintf( STREAM_LCD, "ER: 0x%08x\r", blkAddr );
pDevice->EraseBlock(blkAddr);
blkAddr += pRegion->BytesPerBlock;
}
success = pDevice->Write(accessPhyAddress , NumOfBytes, (BYTE *)bufPtr, FALSE);
writeLenInBytes -= NumOfBytes;
if ((writeLenInBytes <=0) || (!success)) break;
bufPtr += NumOfBytes;
}
if ((writeLenInBytes <=0) || (!success)) break;
}
}
else
{
FLASH_WORD *Addr = (FLASH_WORD *) Address;
for(i = 0; i < WordCount; i++)
{
// must be RAM but don't verify, we write anyway, possibly causing a data abort if the address is bogus
*Addr++ = WordData[i];
}
}
}
}
return TRUE;
}
BOOL MC9328MXL_SPI_Driver::Xaction_nWrite16_nRead16( SPI_XACTION_16& Transaction )
{
NATIVE_PROFILE_HAL_PROCESSOR_SPI();
UINT16 Data16;
if(!g_MC9328MXL_SPI_Driver.m_Enabled[ Transaction.SPI_mod ])
{
hal_printf("\fSPI Xaction OFF\r\n");
lcd_printf("\fSPI Xaction OFF\r\n");
ASSERT(FALSE);
return FALSE;
}
SPI_DEBUG_PRINT("\fxwr16\r\n");
MC9328MXL_SPI& SPI = MC9328MXL::SPI( Transaction.SPI_mod );
UINT16* Write16 = Transaction.Write16;
INT32 WriteCount = Transaction.WriteCount;
UINT16* Read16 = Transaction.Read16;
INT32 ReadCount = Transaction.ReadCount;
INT32 ReadStartOffset = Transaction.ReadStartOffset;
INT32 ReadTotal = 0;
// as master, we must always write something before reading or not
if(WriteCount <= 0) {
ASSERT(FALSE);
return FALSE;
}
if(Write16 == NULL) {
ASSERT(FALSE);
return FALSE;
}
if((ReadCount > 0) && (Read16 == NULL)) {
ASSERT(FALSE);
return FALSE;
}
if(ReadCount)
{
ReadTotal = ReadCount + ReadStartOffset; // we need to read as many bytes as the buffer is long, plus the offset at which we start
}
INT32 loopCnt= ReadTotal;
// take the max of Read+offset or WrCnt
if (loopCnt < WriteCount)
loopCnt = WriteCount;
// we will use WriteCount to move in the Write16 array
// so we do no want to go past the end when we will check for
// WriteCount to be bigger than zero
WriteCount -= 1;
while(loopCnt--)
{
SPI.TXDATAREG = Write16[0];
SPI.CONTROLREG |= SPI.CONTROLREG_XCH;
// wait while the transmit buffer is full and receive buffer is empty
while(!SPI.TransmitBufferEmpty() || !SPI.ShiftBufferEmpty()|| SPI.ReceiveBufferEmpty());
Data16 = SPI.RXDATAREG;
// repeat last write word for all subsequent reads
if(WriteCount)
{
WriteCount--;
Write16++;
}
// only save data once we have reached ReadCount-1 portion of words
ReadTotal--;
if((ReadTotal>=0) && (ReadTotal < ReadCount))
{
Read16[0] = Data16;
Read16++;
}
}
return TRUE;
}
void ApplicationEntryPoint()
{
INT32 timeout = 20000; // 20 second timeout
bool enterBootMode = false;
// crypto API needs to allocate memory. Initialize simple heap for it.
UINT8* BaseAddress;
UINT32 SizeInBytes;
HeapLocation ( BaseAddress, SizeInBytes );
SimpleHeap_Initialize( BaseAddress, SizeInBytes );
g_eng.Initialize( HalSystemConfig.DebuggerPorts[ 0 ] );
// internal reset and stop check
enterBootMode = g_PrimaryConfigManager.IsBootLoaderRequired( timeout );
// ODM defined method to enter bootloader mode
if(!enterBootMode)
{
enterBootMode = WaitForTinyBooterUpload( timeout );
}
if(!enterBootMode)
{
if(!g_eng.EnumerateAndLaunch())
{
timeout = -1;
enterBootMode = true;
}
}
if(enterBootMode)
{
LCD_Clear();
hal_fprintf( STREAM_LCD, "TinyBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION);
hal_fprintf( STREAM_LCD, "%s Build Date:\r\n\t%s %s\r\n", HalName, __DATE__, __TIME__ );
DebuggerPort_Initialize( HalSystemConfig.DebuggerPorts[ 0 ] );
TinyBooter_OnStateChange( State_EnterBooterMode, NULL );
DebuggerPort_Flush( HalSystemConfig.DebugTextPort );
hal_printf( "TinyBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION);
hal_printf( "%s Build Date: %s %s\r\n", HalName, __DATE__, __TIME__ );
#if defined(__GNUC__)
hal_printf("GNU Compiler version %d\r\n", __GNUC__);
#elif defined(_ARC)
hal_printf("ARC Compiler version %d\r\n", _ARCVER);
#elif defined(__ADSPBLACKFIN__)
hal_printf( "Blackfin Compiler version %d\r\n", __VERSIONNUM__ );
#elif defined(__RENESAS__)
hal_printf( "Renesas Compiler version %d\r\n", __RENESAS_VERSION__ );
#else
hal_printf( "ARM Compiler version %d\r\n", __ARMCC_VERSION );
#endif
DebuggerPort_Flush( HalSystemConfig.DebugTextPort );
//
// Send "presence" ping.
//
{
CLR_DBG_Commands::Monitor_Ping cmd;
cmd.m_source = CLR_DBG_Commands::Monitor_Ping::c_Ping_Source_TinyBooter;
g_eng.m_controller.SendProtocolMessage( CLR_DBG_Commands::c_Monitor_Ping, WP_Flags::c_NonCritical, sizeof(cmd), (UINT8*)&cmd );
}
UINT64 ticksStart = HAL_Time_CurrentTicks();
//
// Wait for somebody to press a button; if no button press comes in, lauch the image
//
do
{
const UINT32 c_EventsMask = SYSTEM_EVENT_FLAG_COM_IN |
SYSTEM_EVENT_FLAG_USB_IN |
SYSTEM_EVENT_FLAG_BUTTON;
UINT32 events = ::Events_WaitForEvents( c_EventsMask, timeout );
if(events != 0)
{
Events_Clear( events );
}
if(events & SYSTEM_EVENT_FLAG_BUTTON)
{
TinyBooter_OnStateChange( State_ButtonPress, (void*)&timeout );
}
if(events & (SYSTEM_EVENT_FLAG_COM_IN | SYSTEM_EVENT_FLAG_USB_IN))
{
g_eng.ProcessCommands();
}
if(LOADER_ENGINE_ISFLAGSET(&g_eng, Loader_Engine::c_LoaderEngineFlag_ValidConnection))
{
LOADER_ENGINE_CLEARFLAG(&g_eng, Loader_Engine::c_LoaderEngineFlag_ValidConnection);
TinyBooter_OnStateChange( State_ValidCommunication, (void*)&timeout );
ticksStart = HAL_Time_CurrentTicks();
}
else if((timeout != -1) && (HAL_Time_CurrentTicks()-ticksStart) > CPU_MillisecondsToTicks((UINT32)timeout))
{
TinyBooter_OnStateChange( State_Timeout, NULL );
g_eng.EnumerateAndLaunch();
}
} while(true);
}
::CPU_Reset();
}
// if program needs to loaded from non-XIP to XIP area, use this routine
// and return the new address for the applicatoin.
void PortBooterLoadProgram(void ** StartAddress)
{
hal_printf(" Prepare to launcah program %x \r\n", (UINT32)(*StartAddress));
// if needed, reload data to the desired ram type storage.
}
