static void prvConfigureVBus( void )
{
const Pin xVBusPin = PIN_USB_VBUS;
const uint32_t ulPriority = 7; /* Highest. */
/* Configure PIO to generate an interrupt on status change. */
PIO_Configure( &xVBusPin, 1 );
PIO_ConfigureIt( &xVBusPin );
/* Ensure interrupt is disabled before setting the mode and installing the
handler. The priority of the tick interrupt should always be set to the
lowest possible. */
AIC->AIC_SSR = ID_PIOE;
AIC->AIC_IDCR = AIC_IDCR_INTD;
AIC->AIC_SMR = AIC_SMR_SRCTYPE_EXT_POSITIVE_EDGE | ulPriority;
AIC->AIC_SVR = ( uint32_t ) prvVBusISRHandler;
/* Start with the interrupt clear. */
AIC->AIC_ICCR = AIC_ICCR_INTCLR;
PIO_EnableIt( &xVBusPin );
AIC_EnableIT( ID_PIOE );
/* Check current level on VBus */
if( PIO_Get( &xVBusPin ) != pdFALSE )
{
/* If VBUS present, force the connect */
USBD_Connect();
}
else
{
USBD_Disconnect();
}
}
void usb_isr_vbus(const Pin *pin) {
// Check current level on VBus
if (PIO_Get(&pin_usb_detect)) {
USBD_Connect();
} else {
USBD_Disconnect();
}
}
/***************************************************************************//**
* @brief
* Stop USB device stack operation.
*
* @details
* The data-line pullup resistor is turned off, USB interrupts are disabled,
* and finally the USB pins are disabled.
******************************************************************************/
void USBD_Stop( void )
{
USBD_Disconnect();
NVIC_DisableIRQ( USB_IRQn );
USBHAL_DisableGlobalInt();
USB->IEN = _USB_IEN_RESETVALUE;
USB->ROUTE = _USB_ROUTE_RESETVALUE;
USBD_SetUsbState( USBD_STATE_NONE );
}
void UsbSerial_begin( void )
{
USBD_Disconnect(); // tell the host we're not attached
CDCDSerialDriver_Initialize();
USBD_Connect();
usbSerial.readSemaphore = SemaphoreCreate();
SemaphoreTake( usbSerial.readSemaphore, -1 );
usbSerial.writeSemaphore = SemaphoreCreate();
SemaphoreTake( usbSerial.writeSemaphore, -1 );
}
/***************************************************************************//**
* @brief
* Stop USB device stack operation.
*
* @details
* The data-line pullup resistor is turned off, USB interrupts are disabled,
* and finally the USB pins are disabled.
******************************************************************************/
void USBD_Stop( void )
{
USBD_Disconnect();
NVIC_DisableIRQ( USB_IRQn );
USBHAL_DisableGlobalInt();
USBHAL_DisableUsbInt();
USBHAL_DisablePhyPins();
USBD_SetUsbState( USBD_STATE_NONE );
/* Turn off USB clocks. */
CMU->HFCORECLKEN0 &= ~(CMU_HFCORECLKEN0_USB | CMU_HFCORECLKEN0_USBC);
}
static void prvVBusISRHandler( void )
{
const Pin xVBusPin = PIN_USB_VBUS;
/* Check current level on VBus to detect a connect/disconnect. */
if( PIO_Get( &xVBusPin ) != 0 ) {
USBD_Connect();
} else {
USBD_Disconnect();
}
}
//------------------------------------------------------------------------------
/// Handles interrupts coming from PIO controllers.
//------------------------------------------------------------------------------
static void ISR_VBus(const Pin *pPin)
{
// Check current level on VBus
if (PIO_Get(&pinVbus)) {
TRACE_INFO("VBUS conn\n\r");
USBD_Connect();
}
else {
TRACE_INFO("VBUS discon\n\r");
USBD_Disconnect();
}
}
static void prvVBusISRHandler( const Pin *pxPin )
{
/* NOTE: As this was written for the XPlained board, which is powered
through the USB and cannot be on without the USB connected, this function
has not been exercised. */
/* Check current level on VBus to detect a connect/disconnect. */
if( PIO_Get( pxPin ) != 0 )
{
USBD_Connect();
}
else
{
USBD_Disconnect();
}
}
//////////////////////////////////////////////////
// boot
void
prepare_boot(char *in)
{
uint8_t bl = 0;
if(in)
fromhex(in+1, &bl, 1);
if(bl == 0xff) // Allow testing
while(1);
#ifdef ARM
unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM;
//Reset
if(bl)
*ram = 0xaa; // Next reboot we'd like to jump to the bootloader.
USBD_Disconnect();
my_delay_ms(250);
my_delay_ms(250);
my_delay_ms(250);
my_delay_ms(250);
AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24;
while (1);
#else
if(bl) // Next reboot we'd like to jump to the bootloader.
ewb( EE_REQBL, 1 ); // Simply jumping to the bootloader from here
// wont't work. Neither helps to shutdown USB
// first.
#ifdef HAS_USB
USB_ShutDown(); // ??? Needed?
#endif
#ifdef HAS_FS
fs_sync(&fs); // Sync the filesystem
#endif
TIMSK0 = 0; // Disable the clock which resets the watchdog
cli();
wdt_enable(WDTO_15MS); // Make sure the watchdog is running
while (1); // go to bed, the wathchdog will take us to reset
#endif
}
/**
* Configures the VBus pin to trigger an interrupt when the level on that pin
* changes.
*/
static void VBus_Configure( void )
{
/* Configure PIO */
PIO_Configure(&pinVbus, 1);
PIO_ConfigureIt(&pinVbus, ISR_Vbus);
PIO_EnableIt(&pinVbus);
/* Check current level on VBus */
if (PIO_Get(&pinVbus)) {
/* if VBUS present, force the connect */
USBD_Connect();
}
else {
TRACE_INFO("discon\n\r");
USBD_Disconnect();
}
}
//------------------------------------------------------------------------------
/// Configures the VBus pin to trigger an interrupt when the level on that pin
/// changes.
//------------------------------------------------------------------------------
static void VBus_Configure( void )
{
// Configure PIO
PIO_Configure(&pinVbus, 1);
PIO_ConfigureIt(&pinVbus, ISR_Vbus);
PIO_EnableIt(&pinVbus);
// Check current level on VBus
if (PIO_Get(&pinVbus)) {
// if VBUS present, force the connect
USBD_Connect();
}
else {
USBD_Disconnect();
}
}
static void prvConfigureVBus( void )
{
const Pin xVBusPin = PIN_USB_VBUS;
/* Configure PIO to generate an interrupt on status change. */
PIO_Configure( &xVBusPin, 1 );
PIO_ConfigureIt( &xVBusPin, prvVBusISRHandler );
PIO_EnableIt( &xVBusPin );
/* Check current level on VBus */
if( PIO_Get( &xVBusPin ) != pdFALSE )
{
/* if VBUS present, force the connect */
USBD_Connect();
}
else
{
USBD_Disconnect();
}
}
/**
* @brief Configures the VBus pin to trigger an interrupt when the level on
* that pin changes.
*/
static void VBus_Configure( void )
{
TRACE_INFO("VBus configuration\n\r");
// Configure PIO
PIO_Configure(&pinVbus, 1);
PIO_ConfigureIt(&pinVbus, ISR_Vbus);
PIO_EnableIt(&pinVbus);
// Check current level on VBus
if (PIO_Get(&pinVbus)) {
// if VBUS present, force the connect
TRACE_INFO("VBUS conn\n\r");
USBD_Connect();
} else {
USBD_Disconnect();
TRACE_INFO("VBUS DISconn\n\r");
}
}
void __usb_init_cdc()
{
//BSP_Init(BSP_INIT_DEFAULT); /* Initialize DK board register access */
//CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize the communication class device. */
CDC_Init();
/* Initialize and start USB device stack. */
USBD_Init(&usbInitStruct);
/*
* When using a debugger it is practical to uncomment the following three
* lines to force host to re-enumerate the device.
*/
USBD_Disconnect();
USBTIMER_DelayMs(1000);
USBD_Connect();
}
bool usb_init() {
if(!usb_is_connected()) {
return false;
}
send_status = 0;
receive_status = 0;
usb_configure_clock_48mhz();
USBDDriver_Initialize(&usbd_driver, &driver_descriptors, 0);
USBD_Init();
// Check current level on VBus
if(usb_is_connected()) {
USBD_Connect();
} else {
USBD_Disconnect();
return false;
}
return true;
}
/**************************************************************************//**
* Disconnect USB link with optional delays.
*****************************************************************************/
static void Disconnect( int predelay, int postdelay )
{
if ( BOOTLDIO_usbMode() )
{
if ( predelay )
{
/* Allow time to do a disconnect in a terminal program. */
USBTIMER_DelayMs( predelay );
}
USBD_Disconnect();
if ( postdelay )
{
/*
* Stay disconnected long enough to let host OS tear down the
* USB CDC driver.
*/
USBTIMER_DelayMs( postdelay );
}
}
}
//------------------------------------------------------------------------------
/// USB interrupt subroutine
///
/// This function is called each time a USB interrupt occurs.
/// The following USB DEVICE events are taken in charge:
/// - VBus On / Off
/// - Start Of Frame
/// - Suspend
/// - Wake-Up
/// - Resume
/// - Reset
/// - Start of frame
///
/// The following USB HOST events are taken in charge:
/// - Device connection
/// - Device Disconnection
/// - Start Of Frame
/// - ID pin change
/// - SOF (or Keep alive in low speed) sent
/// - Wake up on USB line detected
///
/// The following USB HOST events are taken in charge:
/// - HNP success (Role Exchange)
/// - HNP failure (HNP Error)
///
/// For each event, the user can launch an action by completing
/// the associate define (See conf_usb.h file to add action upon events)
///
/// Note: Only interrupts events that are enabled are processed
//------------------------------------------------------------------------------
void usb_general_interrupt(void)
{
//TRACE_DEBUG("usb_general_interrupt\n\r");
// ---------- DEVICE events management -----------------------------------
// -----------------------------------------------------------------------
//- VBUS state detection
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled()
&& Is_usb_id_device()) {
Usb_ack_vbus_transition();
if (Is_usb_vbus_high()) {
usb_connected = TRUE;
Usb_vbus_on_action();
Usb_send_event(EVT_USB_POWERED);
//jcb Usb_enable_reset_interrupt();
//usb_start_device();
USBD_Connect();//Usb_attach();
}
else {
TRACE_DEBUG("VBUS low\n\r");
USBD_Disconnect();
Usb_device_stop_hnp();
TRACE_DEBUG("Usb_select_device4\n\r");
Usb_select_device();
Clear_all_user_request();
Usb_vbus_off_action();
usb_connected = FALSE;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
}
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Device start of frame received
if (Is_usb_sof() && Is_sof_interrupt_enabled()) {
// TRACE_DEBUG_WP("F"); // device
Usb_ack_sof();
Usb_sof_action();
//sof_seen_in_session = TRUE;
otg_last_sof_received = UDFNUML; // store last frame number received
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Device Suspend event (no more USB activity detected)
if (Is_usb_suspend()) { //&& Is_suspend_interrupt_enabled()) {
//TRACE_DEBUG_WP("D\n\r");
// 1st : B-PERIPH mode ?
if (Is_usb_id_device()) {
// HNP Handler
TRACE_DEBUG("HNP Handler\n\r");
//TRACE_DEBUG("device_state = %d\n\r", device_state);
//TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
if (Is_host_requested_hnp() // "b_hnp_enable" feature received
&& (Is_session_started_with_srp() || Is_user_requested_hnp() )) {
if (otg_device_nb_hnp_retry == 0) {
otg_features_supported &= ~USBFeatureRequest_OTG_B_HNP_ENABLE;
}
else {
Ack_user_request_hnp();
Usb_ack_hnp_error_interrupt();
Usb_ack_role_exchange_interrupt();
Usb_enable_role_exchange_interrupt();
Usb_enable_hnp_error_interrupt();
Usb_device_initiate_hnp();
otg_device_nb_hnp_retry--;
}
}
else
{
// Remote wake-up handler
//TRACE_DEBUG("Remote wake-up handler\n\r");
//TRACE_DEBUG("device_state = %d\n\r", device_state);
//TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
if ((remote_wakeup_feature == ENABLE) && (usb_configuration_nb != 0))
{
//TRACE_DEBUG("enabled\n\r");
// After that user can execute "Usb_initiate_remote_wake_up()" to initiate a remote wake-up
// Note that the suspend interrupt flag SUSPI must still be set to enable upstream resume
// So the SUSPE enable bit must be cleared to avoid redundant interrupt
// ****************
// Please note also that is Vbus is lost during an upstream resume (Host disconnection),
// the RMWKUP bit (used to initiate remote wake up and that is normally cleared by hardware when sent)
// remains set after the event, so that a good way to handle this feature is :
// Usb_initiate_remote_wake_up();
// while (Is_usb_pending_remote_wake_up())
// {
// if (Is_usb_vbus_low())
// {
// // Emergency action (reset macro, etc.) if Vbus lost during resuming
// break;
// }
// }
// Usb_ack_remote_wake_up_start();
// ****************
}
else {
//TRACE_DEBUG("disabled: %d %d\n\r", usb_configuration_nb, remote_wakeup_feature);
// No remote wake-up supported
Usb_send_event(EVT_USB_SUSPEND);
}
}
}
else
{
//TRACE_DEBUG("ici\n\r");
// A-PERIPH mode (will cause a session end, handled in usb_host_task.c)
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
//jcb Usb_ack_suspend();
}
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Wake up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_swake_up_interrupt_enabled()) {
TRACE_DEBUG("W\n\r");
Usb_unfreeze_clock();
Usb_send_event(EVT_USB_WAKE_UP);
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Resume state bus detection
if (Is_usb_resume() && Is_resume_interrupt_enabled()) {
TRACE_DEBUG("Resume state bus detect\n\r");
Usb_send_event(EVT_USB_RESUME);
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - USB bus reset detection
if (Is_usb_reset()&& Is_reset_interrupt_enabled()) {
TRACE_DEBUG_WP("B\n\r");
if (Is_usb_id_host()) {
//TRACE_DEBUG_WP("id_host\n\r");
dev_configure_endpoint(EP_CONTROL,
TYPE_CONTROL,
DIRECTION_OUT,
SIZE_64,
ONE_BANK,
NYET_DISABLED);
}
// First initialization is important to be synchronized
// A reset must first have been received
if (device_state == A_PERIPHERAL) {
//TRACE_DEBUG_WP("r A_PERIPHERAL\n\r");
otg_last_sof_received = UDFNUML;
otg_last_sof_stored = UDFNUML;
Usb_ack_sof();
Usb_enable_sof_interrupt();
reset_received = TRUE;
Timer16_set_counter(0);
}
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
// ---------- OTG events management ------------------------------------
// ---------------------------------------------------------------------
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - OTG HNP Success detection
if (Is_usb_role_exchange_interrupt() && Is_role_exchange_interrupt_enabled()) {
// TRACE_DEBUG("OTG HNP detect\n\r");
Usb_ack_role_exchange_interrupt();
Host_ack_device_connection();
Host_ack_device_disconnection();
Otg_send_event(EVT_OTG_HNP_SUCCESS);
End_session_with_srp();
Clear_otg_features_from_host();
if (Is_usb_id_host()) {
// HOST (A- or B-) mode
if ((device_state != A_PERIPHERAL) && (device_state != A_END_HNP_WAIT_VFALL)) {
static volatile unsigned int jcb;
// Current mode is A-HOST, device will take the A-PERIPHERAL role
b_uut_device_state = B_PERIPHERAL;
device_state = A_PERIPHERAL;
usb_connected = FALSE;
usb_configuration_nb = 0;
Usb_select_device();
USBD_Connect();//Usb_attach();
Usb_unfreeze_clock();
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Usb_device_stop_hnp();
Usb_ack_reset();
Timer16_set_counter(0);
Usb_freeze_clock(); // USB clock can be freezed to slow down events and condition detection
//jcb while (Timer16_get_counter_low() != 20);
jcb=0;
while( jcb <100000){ jcb++; }
Usb_unfreeze_clock();
reset_received = FALSE;
Usb_disable_sof_interrupt(); // will be set in the next OTG Timer IT (mandatory)
Usb_enable_suspend_interrupt();
Usb_enable_reset_interrupt();
dev_configure_endpoint(EP_CONTROL,
TYPE_CONTROL,
DIRECTION_OUT,
SIZE_64,
ONE_BANK,
NYET_DISABLED);
}
}
else {
// In B_HOST mode, the HNPREQ bit must not be cleared because it releases the bus in suspend mode (and sof can't start)
if ((b_uut_device_state != B_HOST) && (b_uut_device_state != B_END_HNP_SUSPEND)) {
static volatile unsigned int jcb2;
// Current mode is B-PERIPHERAL, device will go into B-HOST role
End_session_with_srp();
Clear_otg_features_from_host();
b_uut_device_state = B_HOST;
device_state = DEVICE_ATTACHED;
usb_connected = FALSE;
usb_configuration_nb = 0;
TRACE_DEBUG("Select host 3\n\r");
Usb_select_host();
TRACE_DEBUG("Send reset\n\r");
Host_send_reset(); // send the first RESET
while (Host_is_reset());
TRACE_DEBUG("Reset passed\n\r");
jcb2=0;
while( jcb2 <1000000){ jcb2++; }
Host_enable_sof(); // start Host (sof)
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Clear_all_user_request();
TRACE_DEBUG("Select host 3\n\r");
}
}
}
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - OTG HNP Failure detection
if (Is_usb_hnp() && Is_usb_hnp_error_interrupt()&& Is_hnp_error_interrupt_enabled()) {
TRACE_DEBUG("OTG HNP failure\n\r");
Usb_device_stop_hnp();
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Usb_ack_hnp_error_interrupt();
if (Is_usb_id_device()) {
Otg_send_event(EVT_OTG_HNP_ERROR);
Clear_all_user_request();
}
}
// ---------- HOST events management -----------------------------------
// ---------------------------------------------------------------------
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - ID pin change detection
if(Is_usb_id_transition()&&Is_usb_id_interrupt_enabled()) {
TRACE_DEBUG("ID pin change\n\r");
TRACE_DEBUG("device_state = %d\n\r", device_state);
TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
Usb_device_stop_hnp();
Clear_all_user_request();
if(Is_usb_id_device()) {
g_usb_mode = USB_MODE_DEVICE;
}
else {
g_usb_mode = USB_MODE_HOST;
}
Usb_ack_id_transition();
if( g_usb_mode != g_old_usb_mode) { // Basic Debounce
if(Is_usb_id_device()) { // Going into device mode
Usb_send_event(EVT_USB_DEVICE_FUNCTION);
b_uut_device_state = B_IDLE;
device_state = DEVICE_UNATTACHED;
id_changed_to_host_event = DISABLE;
}
else { // Going into host mode
b_uut_device_state = B_IDLE;
device_state = DEVICE_UNATTACHED;
Usb_send_event(EVT_USB_HOST_FUNCTION);
id_changed_to_host_event = ENABLE;
}
Usb_id_transition_action();
TRACE_INFO("Pin Id changed\n\r");
}
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - The device has been disconnected
// JCB to be fix
if(Is_device_disconnection() && Is_host_device_disconnection_interrupt_enabled()) {
TRACE_DEBUG("device disconnect\n\r");
host_disable_all_pipe();
Host_ack_device_disconnection();
device_state=DEVICE_DISCONNECTED;
Usb_send_event(EVT_HOST_DISCONNECTION);
TRACE_INFO("Device disconnected\n\r");
Host_device_disconnection_action();
Clear_all_user_request();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Device connection
if(Is_device_connection() && Is_host_device_connection_interrupt_enabled()) {
TRACE_DEBUG("device connect\n\r");
Host_ack_device_connection();
host_disable_all_pipe();
Host_device_connection_action();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Host Start of frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled()) {
//TRACE_DEBUG_WP("_"); // host
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
private_sof_counter++;
// delay timeout management for interrupt tranfer mode in host mode
#if ((USB_HOST_PIPE_INTERRUPT_TRANSFER==ENABLE) && (TIMEOUT_DELAY_ENABLE==ENABLE))
if (private_sof_counter>=250) { // Count 1/4 sec
private_sof_counter=0;
for(i=0;i<MAX_EP_NB;i++) {
if(it_pipe_str[i].enable==ENABLE) {
save_pipe_nb=Host_get_selected_pipe();
Host_select_pipe(i);
if((++it_pipe_str[i].timeout>TIMEOUT_DELAY) && (Host_get_pipe_type()!=TYPE_INTERRUPT)) {
it_pipe_str[i].enable=DISABLE;
it_pipe_str[i].status=PIPE_DELAY_TIMEOUT;
Host_stop_pipe_interrupt(i);
if (is_any_interrupt_pipe_active()==FALSE) { // If no more transfer is armed
if (g_sav_int_sof_enable==FALSE) {
Host_disable_sof_interrupt();
}
}
it_pipe_str[i].handle(PIPE_DELAY_TIMEOUT,it_pipe_str[i].nb_byte_processed);
}
Host_select_pipe(save_pipe_nb);
}
}
}
#endif // (USB_HOST_PIPE_INTERRUPT_TRANSFER==ENABLE) && (TIMEOUT_DELAY_ENABLE==ENABLE))
Host_sof_action();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Host Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled()) {
TRACE_DEBUG("Host wake up\n\r");
Host_disable_hwup_interrupt(); // Wake up interrupt should be disable host is now wake up !
Host_disable_remote_wakeup_interrupt();
// CAUTION HWUP can be cleared only when USB clock is active (not frozen)!
Usb_unfreeze_clock(); // Enable clock on USB interface
Host_enable_sof(); // start sending SOF
Host_ack_hwup(); // Clear HWUP interrupt flag
Host_ack_remote_wakeup();
Usb_send_event(EVT_HOST_HWUP); // Send software event
Usb_send_event(EVT_HOST_REMOTE_WAKEUP);
Host_hwup_action(); // Map custom action
if (Is_usb_hnp()) {
Usb_host_reject_hnp();
Usb_disable_hnp_error_interrupt();
Usb_disable_role_exchange_interrupt();
}
Host_send_resume();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// Remote Wake Up has been received
if (Is_host_remote_wakeup_interrupt_enabled() && Is_host_remote_wakeup()) {
TRACE_DEBUG("Remote wake up\n\r");
Host_disable_remote_wakeup_interrupt();
Host_disable_hwup_interrupt();
Host_ack_remote_wakeup();
Host_ack_hwup(); // Clear HWUP interrupt flag
Usb_unfreeze_clock(); // Enable clock on USB interface
Host_enable_sof(); // start sending SOF
Usb_send_event(EVT_HOST_REMOTE_WAKEUP);
Usb_send_event(EVT_HOST_HWUP); // Send software event
if (Is_usb_hnp()) {
Usb_host_reject_hnp();
Usb_disable_hnp_error_interrupt();
Usb_disable_role_exchange_interrupt();
}
Host_send_resume();
}
}
void USBD_Stop(void)
{
USB_DisableInts();
USBD_Disconnect();
USBD_SetUsbState(USBD_STATE_NONE);
}
//------------------------------------------------------------------------------
/// Application entry point. Configures the DBGU, PIT, TC0, LEDs and buttons
/// and makes LED\#1 blink in its infinite loop, using the Wait function.
/// \return Unused (ANSI-C compatibility).
//------------------------------------------------------------------------------
int main(void)
{
// DBGU configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO_WP("\n\r");
TRACE_INFO("Getting new Started Project --\n\r");
TRACE_INFO("%s\n\r", BOARD_NAME);
TRACE_INFO("Compiled: %s %s --\n\r", __DATE__, __TIME__);
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR= 0xa5<<24;
// Configure EMAC PINS
PIO_Configure(emacRstPins, PIO_LISTSIZE(emacRstPins));
// Execute reset
RSTC_SetExtResetLength(0xd);
RSTC_ExtReset();
// Wait for end hardware reset
while (!RSTC_GetNrstLevel());
TRACE_INFO("init Flash\n\r");
flash_init();
TRACE_INFO("init Timer\n\r");
// Configure timer 0
ticks=0;
extern void ISR_Timer0();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_SR;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCTRG;
AT91C_BASE_TC0->TC_RC = 375;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Configure timer 1
extern void ISR_Timer1();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; //Stop clock
AT91C_BASE_TC1->TC_IDR = 0xFFFFFFFF; //Disable Interrupts
AT91C_BASE_TC1->TC_SR; //Read Status register
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV4_CLOCK | AT91C_TC_CPCTRG; // Timer1: 2,666us = 48MHz/128
AT91C_BASE_TC1->TC_RC = 0xffff;
AT91C_BASE_TC1->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC1, 1, ISR_Timer1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
led_init();
TRACE_INFO("init EEprom\n\r");
eeprom_init();
rb_reset(&TTY_Rx_Buffer);
rb_reset(&TTY_Tx_Buffer);
input_handle_func = analyze_ttydata;
LED_OFF();
LED2_OFF();
LED3_OFF();
spi_init();
fht_init();
tx_init();
#ifdef HAS_ETHERNET
ethernet_init();
#endif
TRACE_INFO("init USB\n\r");
CDCDSerialDriver_Initialize();
USBD_Connect();
wdt_enable(WDTO_2S);
fastrf_on=0;
display_channel = DISPLAY_USB;
TRACE_INFO("init Complete\n\r");
checkFrequency();
// Main loop
while (1) {
CDC_Task();
Minute_Task();
RfAnalyze_Task();
#ifdef HAS_FASTRF
FastRF_Task();
#endif
#ifdef HAS_RF_ROUTER
rf_router_task();
#endif
#ifdef HAS_ASKSIN
rf_asksin_task();
#endif
#ifdef HAS_MORITZ
rf_moritz_task();
#endif
#ifdef HAS_RWE
rf_rwe_task();
#endif
#ifdef HAS_MBUS
rf_mbus_task();
#endif
#ifdef HAS_MAICO
rf_maico_task();
#endif
#ifdef HAS_ETHERNET
Ethernet_Task();
#endif
#ifdef DBGU_UNIT_IN
if(DBGU_IsRxReady()){
unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM;
unsigned char x;
x=DBGU_GetChar();
switch(x) {
case 'd':
puts("USB disconnect\n\r");
USBD_Disconnect();
break;
case 'c':
USBD_Connect();
puts("USB Connect\n\r");
break;
case 'r':
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR=AT91C_RSTC_URSTEN | 0xa5<<24;
break;
case 'S':
USBD_Disconnect();
my_delay_ms(250);
my_delay_ms(250);
//Reset
*ram = 0xaa;
AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24;
while (1);
break;
default:
rb_put(&TTY_Tx_Buffer, x);
}
}
#endif
if (USBD_GetState() == USBD_STATE_CONFIGURED) {
if( USBState == STATE_IDLE ) {
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
LED3_ON();
USBState=STATE_RX;
}
}
if( USBState == STATE_SUSPEND ) {
TRACE_INFO("suspend !\n\r");
USBState = STATE_IDLE;
}
if( USBState == STATE_RESUME ) {
TRACE_INFO("resume !\n\r");
USBState = STATE_IDLE;
}
}
}
