/*FUNCTION*----------------------------------------------------------------
*
* Function Name : main (Main_Task if using MQX)
* Returned Value : none
* Comments :
* Execution starts here
*
*END*--------------------------------------------------------------------*/
void Main_Task ( uint32_t param )
{ /* Body */
USB_STATUS status = USB_OK;
/* _usb_otg_init needs to be done with interrupts disabled */
_int_disable();
_int_install_unexpected_isr();
_usb_host_driver_install(USBCFG_DEFAULT_HOST_CONTROLLER);
/*
** It means that we are going to act like host, so we initialize the
** host stack. This call will allow USB system to allocate memory for
** data structures, it uses later (e.g pipes etc.).
*/
status = _usb_host_init (
USBCFG_DEFAULT_HOST_CONTROLLER, /* Use value in header file */
&host_handle); /* Returned pointer */
if (status != USB_OK)
{
printf("\nUSB Host Initialization failed. STATUS: %x", status);
fflush(stdout);
}
/*
** Since we are going to act as the host driver, register the driver
** information for wanted class/subclass/protocols
*/
status = _usb_host_driver_info_register (
host_handle,
DriverInfoTable
);
if (status != USB_OK) {
printf("\nDriver Registration failed. STATUS: %x", status);
fflush(stdout);
}
_int_enable();
printf("\n MQX USB Audio Speaker Host Demo\n");
fflush(stdout);
/* Creat lwevents*/
if (MQX_OK !=_lwevent_create(&USB_Keyboard_Event, LWEVENT_AUTO_CLEAR)){
printf("\n_lwevent_create USB_Keyboard_Event failed.\n");
}
if (MQX_OK !=_lwevent_create(&USB_Audio_FU_Request, LWEVENT_AUTO_CLEAR)){
printf("\n_lwevent_create USB_Audio_FU_Request failed.\n");
}
if (MQX_OK !=_lwevent_create(&SD_Card_Event, LWEVENT_AUTO_CLEAR)){
printf("\n_lwevent_create SD_Card_Event failed.\n");
}
_task_create(0, AUDIO_TASK, (uint32_t) host_handle);
_task_create(0, HID_KEYB_TASK, (uint32_t) host_handle);
_task_create(0, SDCARD_TASK, (uint32_t) host_handle);
_task_create(0, SHELL_TASK, (uint32_t) host_handle);
/* The main task has done its job, so exit */
} /* Endbody */
// Main task
void Main_task(uint32_t task_init_data)
{
// switch the red LED on (line low sets LED on)
LED_RED_ClrVal(NULL);
LED_GREEN_SetVal(NULL);
LED_BLUE_SetVal(NULL);
// create the sensor sampling event (typically 200Hz)
_lwevent_create(&(mqxglobals.SamplingEventStruct), LWEVENT_AUTO_CLEAR);
// create the Kalman filter sensor fusion event (typically 25Hz)
_lwevent_create(&(mqxglobals.RunKFEventStruct), LWEVENT_AUTO_CLEAR);
// create the magnetic calibration event (typically once per minute)
_lwevent_create(&(mqxglobals.MagCalEventStruct), LWEVENT_AUTO_CLEAR);
// create the sensor read task (controlled by sensor sampling event SamplingEventStruct)
_task_create_at(0, RDSENSDATA_TASK, 0, RdSensData_task_stack, RDSENSDATA_TASK_STACK_SIZE);
// create the sensor fusion task (controlled by sensor fusion event RunKFEventStruct)
_task_create_at(0, FUSION_TASK, 0, Fusion_task_stack, FUSION_TASK_STACK_SIZE);
// create the magnetic calibration task (controlled by MagCalEventStruct)
_task_create_at(0, MAGCAL_TASK, 0, MagCal_task_stack, MAGCAL_TASK_STACK_SIZE);
// and this main task uses about 512 bytes stack for a grand total of 3K task stack space
// set the sensor sampling frequency (typically 200Hz)
// this is set to 200Hz by default in PE but we want to set it using value in proj_config.h
FTM_SetPeriodTicks(FTM_DeviceData, (uint16) (FTM_INCLK_HZ / SENSORFS));
// initialize globals
mqxglobals.FTMReload = (uint16)(FTM_INCLK_HZ / SENSORFS);
mqxglobals.FTMTimestamp = 0;
globals.iPacketNumber = 0;
globals.AngularVelocityPacketOn = true;
globals.DebugPacketOn = true;
globals.RPCPacketOn = true;
globals.AltPacketOn = true;
globals.iMPL3115Found = false;
globals.MagneticPacketID = 0;
// initialize the BlueRadios Bluetooth module and other user tasks
UserStartup();
// initialize the incoming command buffer to all '~' = 0x7E and trigger a callback
// when any single command character is received into the UART buffer
iCommand[0] = iCommand[1] = iCommand[2] = iCommand[3] = '~';
UART_ReceiveBlock(UART_DeviceData, sUARTInputBuf, 1);
// destroy this task (main task) now that the three new tasks are created
_task_destroy(MQX_NULL_TASK_ID);
return;
}
void HVAC_InitializeParameters(void)
{
_lwevent_create(&HVAC_Params.Event, 0);
HVAC_Params.HVACMode = HVAC_Auto;
HVAC_Params.FanMode = Fan_Automatic;
HVAC_Params.TemperatureScale = Celsius;
HVAC_Params.DesiredTemperature = HVAC_DEFAULT_TEMP;
}
void usb_class_audio_control_init
(
/* [IN] structure with USB pipe information on the interface */
PIPE_BUNDLE_STRUCT_PTR pbs_ptr,
/* [IN] audio call struct pointer */
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle;
USB_STATUS status;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_audio_control_init");
#endif
/* Make sure the device is still attached */
USB_lock();
status = usb_host_class_intf_init(pbs_ptr, if_ptr, &audio_control_anchor);
if (status == USB_OK) {
/*
** We generate a code_key based on the attached device. This is used to
** verify that the device has not been detached and replaced with another.
*/
ccs_ptr->code_key = 0;
ccs_ptr->code_key = usb_host_class_intf_validate(ccs_ptr);
if_ptr->AUDIO_G.IFNUM = ((INTERFACE_DESCRIPTOR_PTR)if_ptr->AUDIO_G.G.intf_handle)->bInterfaceNumber;
if_ptr->interrupt_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_INTERRUPT_PIPE, 0);
if (MQX_OK != (status = _lwevent_create(&if_ptr->control_event, 0))) {
status = USBERR_INIT_FAILED;
}
else {
/* prepare events to be auto or manual */
_lwevent_set_auto_clear(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE);
/* pre-set events */
_lwevent_set(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE);
}
} /* Endif */
/* Signal that an error has occured by setting the "code_key" */
if (status) {
ccs_ptr->code_key = 0;
} /* Endif */
USB_unlock();
#ifdef _HOST_DEBUG_
if (status)
DEBUG_LOG_TRACE("usb_class_audio_control_init, SUCCESSFUL");
else
DEBUG_LOG_TRACE("usb_class_audio_control_init, FAILED");
#endif
} /* Endbody */
os_event_handle OS_Event_create(uint32_t flag)
{
LWEVENT_STRUCT *event;
event = (LWEVENT_STRUCT*)_mem_alloc_system_zero(sizeof(LWEVENT_STRUCT));
if (event == NULL)
{
return NULL;
}
if (_lwevent_create(event, flag) != MQX_OK)
{
_mem_free((void*)event);
return NULL;
}
return (os_event_handle)event;
}
/**************************************************************************
Global variables
**************************************************************************/
int unit_test_usb_host(void) {
static _usb_host_handle host_handle;
USB_STATUS error;
USB_lock();
_int_install_unexpected_isr();
if (MQX_OK != _usb_host_driver_install(USBCFG_DEFAULT_HOST_CONTROLLER)) {
printf("\n Driver installation failed");
_task_block();
}
error = _usb_host_init(USBCFG_DEFAULT_HOST_CONTROLLER, &host_handle);
if (error == USB_OK) {
error = _usb_host_driver_info_register(host_handle, (pointer)DriverInfoTable);
if (error == USB_OK) {
error = _usb_host_register_service(host_handle, USB_SERVICE_HOST_RESUME, NULL);
}
}
USB_unlock();
if (error != USB_OK) {
_task_block();
}
if (MQX_OK != _lwevent_create(&usb_event, LWEVENT_AUTO_CLEAR)) {
return -1;
}
/* prepare events to be auto or manual */
_lwevent_set_auto_clear(&usb_event, 0xFFFFFFFF);
/* pre-set events */
_lwevent_clear(&usb_event, 0xFFFFFFFF);
_lwevent_wait_ticks(&usb_event, 0x1, FALSE, 0);
return 0;
}
static int sample_timer_init()
{
SIM_SCGC6 |= SIM_SCGC6_PIT_MASK; // Enable PIT Module Clock
sample_qpit_ptr = (VQPIT_REG_STRUCT_PTR)PIT_BASE_PTR;
sample_qpit_ptr->MCR = 0/* QPIT_MCR_FRZ*/;
printf("PIT reg 0x%x\n",PIT_BASE_PTR);
if(_int_install_isr(SAMPLE_INT, SAMPLE_TIMER_ISR, NULL) == NULL) {
printf("install sample timer isr failed\n");
return -1;
} /* Endif */
/* create lwevent group */
if (_lwevent_create(&sample_event, 0) != MQX_OK) { /* 0 - manual clear */
return -1;
}
_bsp_int_init(SAMPLE_INT, 2, 0, TRUE /*FALSE*/);
return 0;
}
/*TASK*-----------------------------------------------------
*
* Task Name : main_task
* Comments : Low power modes switching.
*
*END*-----------------------------------------------------*/
void main_task
(
uint32_t initial_data
)
{
LPM_OPERATION_MODE operation_mode;
IDLE_LOOP_STRUCT idle_loops;
uint32_t loop1;
/* Initialize switches */
button_led_init();
_int_install_unexpected_isr();
_lpm_register_wakeup_callback(BSP_LLWU_INTERRUPT_VECTOR, BSP_LLWU_INTERRUPT_PRIORITY, NULL);
/* Install interrupt for timer wakeup */
install_timer_interrupt();
/* Create global event */
if (_lwevent_create(&app_event, 0) != MQX_OK)
{
printf("\nCreating app_event failed.\n");
_task_block();
}
#if (PSP_MQX_CPU_IS_KINETIS)
if (_lpm_get_reset_source() != MQX_RESET_SOURCE_LLWU)
printf("\nMQX Low Power Modes Demo\n");
else
#endif
printf("\nWake up by reset from LLWU\n");
while (1)
{
#if (MQX_ENABLE_HSRUN)
/* Find out current mode setting */
operation_mode = _lpm_get_operation_mode();
printf("\n******************************************************************************\n");
printf("************** Operation mode : %s ***********************\n", get_operation_mode_name (operation_mode));
printf("******************************************************************************\n");
display_operation_mode_setting(operation_mode);
printf(
"Info: HSRUN operation mode is mapped on HSRUN power mode by default.\n"
" The core runs at full clock speed.\n"
" It continues the execution after entering the mode.\n"
" LED2 blinks quickly, LED1 toggles after the button press.\n");
/* Wait for button press */
printf ("Press button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
/* Change frequency to normal run mode. */
printf("\nChanging frequency to normal run mode.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_0))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", get_operation_mode_name (operation_mode));
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_RUN) == 0 ? "OK" : "ERROR");
#endif
/* Find out current mode setting */
operation_mode = _lpm_get_operation_mode();
printf("\n******************************************************************************\n");
printf("************** Operation mode : %s ***********************\n", get_operation_mode_name (operation_mode));
printf("******************************************************************************\n");
display_operation_mode_setting(operation_mode);
printf(
"Info: RUN operation mode is mapped on RUN power mode by default.\n"
" The core runs at full clock speed.\n"
" It continues the execution after entering the mode.\n"
" LED2 blinks quickly, LED1 toggles after the button press.\n");
/* Demonstration of idle task sleep feature */
printf("\nIdle task sleep feature disabled.\n");
_lpm_idle_sleep_setup (FALSE);
printf("Task suspended for 1 second to let run the idle task.\n");
_mqx_get_idle_loop_count (&idle_loops);
loop1 = idle_loops.IDLE_LOOP1;
_time_delay (1000);
_mqx_get_idle_loop_count (&idle_loops);
printf ("Idle loops per second with idle sleep disabled: %d\n", idle_loops.IDLE_LOOP1 - loop1);
printf("Idle task sleep feature enabled.\n");
_lpm_idle_sleep_setup (TRUE);
printf("Task suspended for 1 second to let run the idle task.\n");
_mqx_get_idle_loop_count (&idle_loops);
loop1 = idle_loops.IDLE_LOOP1;
_time_delay (1000);
_mqx_get_idle_loop_count (&idle_loops);
printf ("Idle loops per second with idle sleep enabled: %d\n", idle_loops.IDLE_LOOP1 - loop1);
printf("Idle task sleep feature disabled.\n\n");
_lpm_idle_sleep_setup (FALSE);
/* Wait for button press */
printf ("Press button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
operation_mode = LPM_OPERATION_MODE_WAIT;
printf("\n******************************************************************************\n");
printf("************** Operation mode : %s **********************\n", get_operation_mode_name (operation_mode));
printf("******************************************************************************\n");
display_operation_mode_setting(operation_mode);
printf(
"Info: WAIT operation mode is mapped on VLPR power mode by default.\n"
" It requires 2 MHz core clock and bypassed pll.\n"
" Core continues the execution after entering the mode.\n"
" LED2 blinks slowly, LED1 toggles after the button press.\n");
/* The LPM_OPERATION_MODE_WAIT is mapped on LPM_CPU_POWER_MODE_VLPR by default,
this mode requires 2 MHz, bypassed PLL clock setting. Change clocks to appropriate mode */
printf("\nChanging frequency to 2 MHz.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_2MHZ))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", get_operation_mode_name (operation_mode));
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_WAIT) == 0 ? "OK" : "ERROR");
/* Wait for button press */
printf ("\nPress button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed.\n");
/* Return to RUN mode */
printf ("\nSetting operation mode back to %s ... ", get_operation_mode_name (LPM_OPERATION_MODE_RUN));
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_RUN) == 0 ? "OK" : "ERROR");
/* Return default clock configuration */
printf("\nChanging frequency back to the default one.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_DEFAULT))
{
printf("Cannot change clock configuration");
_task_block();
}
printf("\nMoving to next operation mode.\n");
operation_mode = LPM_OPERATION_MODE_SLEEP;
printf("\n******************************************************************************\n");
printf("************** Operation mode : %s *********************\n", get_operation_mode_name (operation_mode));
printf("******************************************************************************\n");
display_operation_mode_setting(operation_mode);
printf(
"Info: SLEEP operation mode is mapped on WAIT power mode by default.\n"
" The core is inactive in this mode, reacting only to interrupts.\n"
" The LPM_CPU_POWER_MODE_FLAG_SLEEP_ON_EXIT is set on Kinetis, therefore\n"
" core goes to sleep again after any isr finishes. The core will stay awake\n"
" after call to _lpm_wakeup_core() from timer wakeup or serial interrupt.\n"
" LED2 doesn't blink, LED1 toggles after the button press.\n");
/* Wake up in 10 seconds */
set_timer_wakeup ();
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", get_operation_mode_name (operation_mode));
printf ("%s\n", _lpm_set_operation_mode (operation_mode) == 0 ? "OK" : "ERROR");
if (LWEVENT_WAIT_TIMEOUT == _lwevent_wait_ticks (&app_event, TIMER_EVENT_MASK, FALSE, 1))
{
printf("\nCore woke up by interrupt. Waiting for timer wakeup ... ");
_lwevent_wait_ticks (&app_event, TIMER_EVENT_MASK, FALSE, 0);
printf("OK\n");
}
else
{
printf("\nCore woke up by timer wakeup.\n");
}
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
/* Wait for button press */
printf ("\nPress button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
operation_mode = LPM_OPERATION_MODE_STOP;
printf("\n******************************************************************************\n");
printf("************** Operation mode : %s **********************\n", get_operation_mode_name (operation_mode));
printf("******************************************************************************\n");
display_operation_mode_setting(operation_mode);
printf(
"Info: STOP operation mode is mapped to LLS power mode by default.\n"
" Core and most peripherals are inactive in this mode, reacting only to\n"
" specified wake up events. The events can be changed in BSP (init_lpm.c).\n"
" Serial line is turned off in this mode. The core will wake up from\n"
" timer wakeup interrupt.\n"
" LED2 doesn't blink, LED1 toggles after the button press.\n");
/* Wake up in 10 seconds */
set_timer_wakeup ();
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... \n", get_operation_mode_name (operation_mode));
_lpm_set_operation_mode (operation_mode);
/**************************************************************************************************/
/* SCI HW MODULE IS DISABLED AT THIS POINT - SERIAL DRIVER MUST NOT BE USED UNTIL MODE IS CHANGED */
/**************************************************************************************************/
/* Return to RUN mode */
_lpm_set_operation_mode (LPM_OPERATION_MODE_RUN);
printf("\nCore is awake. Moved to next operation mode.\n");
#if MQX_ENABLE_HSRUN
/* Wait for button press */
printf ("Press button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", get_operation_mode_name (operation_mode));
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_HSRUN) == 0 ? "OK" : "ERROR");
/* Change frequency to HSRUN mode . */
printf("\nChanging frequency to HSRUN mode.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_3))
{
printf("Cannot change clock configuration");
_task_block();
}
#endif
}
}
void USB_task(uint_32 param)
{
_usb_host_handle host_handle;
USB_STATUS error;
pointer usb_fs_handle = NULL;
#if DEMO_USE_POOLS && defined(DEMO_MFS_POOL_ADDR) && defined(DEMO_MFS_POOL_SIZE)
_MFS_pool_id = _mem_create_pool((pointer)DEMO_MFS_POOL_ADDR, DEMO_MFS_POOL_SIZE);
#endif
_lwsem_create(&USB_Stick,0);
_lwevent_create(&USB_Event,0);
USB_lock();
_int_install_unexpected_isr();
if (MQX_OK != _usb_host_driver_install(USBCFG_DEFAULT_HOST_CONTROLLER)) {
printf("\n Driver installation failed");
_task_block();
}
error = _usb_host_init(USBCFG_DEFAULT_HOST_CONTROLLER, &host_handle);
if (error == USB_OK) {
error = _usb_host_driver_info_register(host_handle, (pointer)ClassDriverInfoTable);
if (error == USB_OK) {
error = _usb_host_register_service(host_handle, USB_SERVICE_HOST_RESUME,NULL);
}
}
USB_unlock();
if (error == USB_OK) {
for ( ; ; ) {
// Wait for insertion or removal event
_lwevent_wait_ticks(&USB_Event,USB_EVENT,FALSE,0);
if ( device.STATE== USB_DEVICE_ATTACHED) {
if (device.SUPPORTED) {
error = _usb_hostdev_select_interface(device.DEV_HANDLE,
device.INTF_HANDLE, (pointer)&device.CLASS_INTF);
if(error == USB_OK) {
device.STATE = USB_DEVICE_INTERFACED;
USB_handle = (pointer)&device.CLASS_INTF;
// Install the file system
usb_fs_handle = usb_filesystem_install( USB_handle, "USB:", "PM_C1:", "c:" );
if (usb_fs_handle) {
// signal the application
_lwsem_post(&USB_Stick);
}
}
} else {
device.STATE = USB_DEVICE_INTERFACED;
}
} else if ( device.STATE==USB_DEVICE_DETACHED) {
_lwsem_wait(&USB_Stick);
// remove the file system
usb_filesystem_uninstall(usb_fs_handle);
}
// clear the event
_lwevent_clear(&USB_Event,USB_EVENT);
}
}
}
/*!
* \brief This function initializes the Multi Core Communication subsystem for a given node.
*
* This function should only be called once per node (once in MQX, once per process in Linux).
*
* \param[in] node Node number that will be used in endpoints created by this process.
*
* \return MCC_SUCCESS
* \return MCC_ERR_SEMAPHORE (semaphore handling error)
* \return MCC_ERR_INT (interrupt registration error)
*
* \see mcc_destroy
* \see MCC_BOOKEEPING_STRUCT
*/
int mcc_initialize(MCC_NODE node)
{
int i,j = 0;
int return_value = MCC_SUCCESS;
MCC_SIGNAL tmp_signals_received = {(MCC_SIGNAL_TYPE)0, (MCC_CORE)0, (MCC_NODE)0, (MCC_PORT)0};
#if (MCC_OS_USED == MCC_MQX)
for(i=0; i<MCC_MQX_LWEVENT_COMPONENTS_COUNT; i++) {
_lwevent_create(&lwevent_buffer_queued[i],0);
}
_lwevent_create(&lwevent_buffer_freed,0);
#endif
/* Initialize synchronization module */
return_value = mcc_init_semaphore(MCC_SHMEM_SEMAPHORE_NUMBER);
if(return_value != MCC_SUCCESS)
return return_value;
/* Register CPU-to-CPU interrupt for inter-core signaling */
//mcc_register_cpu_to_cpu_isr(MCC_CORE0_CPU_TO_CPU_VECTOR);
return_value = mcc_register_cpu_to_cpu_isr();
if(return_value != MCC_SUCCESS)
return return_value;
/* Initialize the bookeeping structure */
bookeeping_data = (MCC_BOOKEEPING_STRUCT *)MCC_BASE_ADDRESS;
MCC_DCACHE_INVALIDATE_MLINES(bookeeping_data, sizeof(MCC_BOOKEEPING_STRUCT));
if(strcmp(bookeeping_data->init_string, init_string) != 0) {
/* Zero it all - no guarantee Linux or uboot didnt touch it before it was reserved */
_mem_zero((void*) bookeeping_data, (_mem_size) sizeof(struct mcc_bookeeping_struct));
/* Set init_string in case it has not been set yet by another core */
mcc_memcpy((void*)init_string, bookeeping_data->init_string, (unsigned int)sizeof(bookeeping_data->init_string));
/* Set version_string */
mcc_memcpy((void*)version_string, bookeeping_data->version_string, (unsigned int)sizeof(bookeeping_data->version_string));
/* Initialize the free list */
bookeeping_data->free_list.head = &bookeeping_data->r_buffers[0];
bookeeping_data->free_list.tail = &bookeeping_data->r_buffers[MCC_ATTR_NUM_RECEIVE_BUFFERS-1];
/* Initialize receive buffers */
for(i=0; i<MCC_ATTR_NUM_RECEIVE_BUFFERS-1; i++) {
bookeeping_data->r_buffers[i].next = &bookeeping_data->r_buffers[i+1];
}
bookeeping_data->r_buffers[MCC_ATTR_NUM_RECEIVE_BUFFERS-1].next = null;
/* Initialize signal queues */
for(i=0; i<MCC_NUM_CORES; i++) {
for(j=0; j<MCC_MAX_OUTSTANDING_SIGNALS; j++) {
bookeeping_data->signals_received[i][j] = tmp_signals_received;
}
bookeeping_data->signal_queue_head[i] = 0;
bookeeping_data->signal_queue_tail[i] = 0;
}
/* Mark all endpoint ports as free */
for(i=0; i<MCC_ATTR_MAX_RECEIVE_ENDPOINTS; i++) {
bookeeping_data->endpoint_table[i].endpoint.port = MCC_RESERVED_PORT_NUMBER;
}
}
MCC_DCACHE_FLUSH_MLINES(bookeeping_data, sizeof(MCC_BOOKEEPING_STRUCT));
return return_value;
}
/*TASK*-----------------------------------------------------------------
*
* Function Name : sdcard_task
* Returned Value : void
* Comments :
*
*END------------------------------------------------------------------*/
void sdcard_task(uint_32 temp)
{
boolean inserted = TRUE, readonly = FALSE, last = FALSE;
_mqx_int error_code;
_mqx_uint param;
MQX_FILE_PTR com_handle, sdcard_handle, filesystem_handle, partman_handle;
char filesystem_name[] = "a:";// 文件系统 名字
char partman_name[] = "pm:";// 分区管理 名字
#if defined BSP_SDCARD_GPIO_DETECT
#if ! BSP_SDCARD_GPIO_DETECT_INT
LWGPIO_STRUCT sd_detect;
#else
LWGPIO_STRUCT sd_detect;
/************************dx 20121210**********************************************
*/
GPIO_PIN_STRUCT sd_detect_int[] = {
BSP_SDCARD_GPIO_DETECT | GPIO_PIN_IRQ_FALLING | GPIO_PIN_IRQ_RISING,
GPIO_LIST_END
};
MQX_FILE_PTR port_file_sd_detect_int;
/***********************************************************************************/
#endif
#endif
#if defined BSP_SDCARD_GPIO_PROTECT
LWGPIO_STRUCT sd_protect;
#endif
#ifdef BSP_SDCARD_GPIO_CS
LWGPIO_STRUCT sd_cs;
SPI_CS_CALLBACK_STRUCT callback;
#endif
/* Open low level communication device */
com_handle = fopen (SDCARD_COM_CHANNEL, NULL);// 打开"esdhc:"模块底层驱动
if (NULL == com_handle)
{
printf("Error installing communication handle.\n");
_task_block();
}
#ifdef BSP_SDCARD_GPIO_CS
/* Open GPIO file for SPI CS signal emulation */
error_code = lwgpio_init(&sd_cs, BSP_SDCARD_GPIO_CS, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);// 安装简单引脚用于spi片选
if (!error_code)
{
printf("Initializing GPIO with associated pins failed.\n");
_task_block();
}
lwgpio_set_functionality(&sd_cs,BSP_SDCARD_CS_MUX_GPIO);
lwgpio_set_attribute(&sd_cs, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
/* Set CS callback */
callback.MASK = BSP_SDCARD_SPI_CS;
callback.CALLBACK = set_CS;
callback.USERDATA = &sd_cs;
if (SPI_OK != ioctl (com_handle, IO_IOCTL_SPI_SET_CS_CALLBACK, &callback))
{
printf ("Setting CS callback failed.\n");
_task_block();
}
#endif
#if defined BSP_SDCARD_GPIO_DETECT
#if ! BSP_SDCARD_GPIO_DETECT_INT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_detect, BSP_SDCARD_GPIO_DETECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);// 安装简单引脚用于插入检测
if (!error_code)
{
printf("Initializing GPIO with sdcard detect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_detect,BSP_SDCARD_DETECT_MUX_GPIO);
lwgpio_set_attribute(&sd_detect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#else
/******************dx 20121210***********************************************/
if (NULL == (port_file_sd_detect_int = fopen("gpio:read", (char_ptr) &sd_detect_int )))
{
printf("Opening port_file_sd_detect_int GPIO with associated button1_int failed.\n");
_task_block();
}
ioctl(port_file_sd_detect_int, GPIO_IOCTL_SET_IRQ_FUNCTION, (pointer)sd_detect_int__callback);
_lwevent_create(&SD_Event,0); // 创建轻量级事件用于检测SD插入
/****************************************************************************/
#endif
#endif
#if defined BSP_SDCARD_GPIO_PROTECT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_protect, BSP_SDCARD_GPIO_PROTECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);// 安装简单引脚用于只读检测
if (!error_code)
{
printf("Initializing GPIO with sdcard protect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_protect,BSP_SDCARD_PROTECT_MUX_GPIO);
lwgpio_set_attribute(&sd_protect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
/* Install SD card device */
error_code = _io_sdcard_install("sdcard:", (pointer)&_bsp_sdcard0_init, com_handle);// 安装SD卡驱动，基于"esdhc:"模块
if ( error_code != MQX_OK )
{
printf("Error installing SD card device (0x%x)\n", error_code);
_task_block();
}
/*使用内部IOCTL命令测试SD卡是否已经插入 dx20121223*/
uint_32 sd_param;
sd_param = 0;
if (ESDHC_OK != ioctl (com_handle, IO_IOCTL_ESDHC_GET_CARD, &sd_param))
{
printf("Error get SD card device type.\n");
_task_block();
}
if (ESDHC_CARD_NONE != sd_param)
{
inserted = TRUE; // 已插入SD卡
printf("inserted = 1 -> %d\n",(int)sd_param);
}else
{
inserted = FALSE; // 无SD卡
printf("inserted = 0 -> %d\n",(int)sd_param);
}
for (;;)/////////////////////////////////////////////////////////////////////////////循环
{
#if defined BSP_SDCARD_GPIO_PROTECT
/* Get value of protect pin */
readonly = lwgpio_get_value(&sd_protect);// 检测磁盘是否只读////////////////////////////////////////
#endif
#ifdef BSP_MPC8308RDB
/* Set function as SD_CD which indicate that card is present in Present State Register */
lwgpio_set_functionality(&sd_detect,BSP_SDCARD_DETECT_MUX_SD_CD);
lwgpio_set_attribute(&sd_detect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
if (last != inserted)
{
if (inserted)// 插入磁盘
{
// _time_delay (200);// 将活动的任务挂起指定的毫秒数
/* Open the device which MFS will be installed on */
sdcard_handle = fopen("sdcard:", 0);// 打开SD卡层驱动
if ( sdcard_handle == NULL )
{
printf("Unable to open SD card device.\n");
_task_block();
}
/* Set read only flag as needed */
param = 0;
if (readonly)
{
param = IO_O_RDONLY;
}
if (IO_OK != ioctl(sdcard_handle, IO_IOCTL_SET_FLAGS, (char_ptr) ¶m))
{
printf("Setting device read only failed.\n");
_task_block();
}
/* Install partition manager over SD card driver */
error_code = _io_part_mgr_install(sdcard_handle, partman_name, 0);// 分区管理
if (error_code != MFS_NO_ERROR)
{
printf("Error installing partition manager: %s\n", MFS_Error_text((uint_32)error_code));
_task_block();
}
/* Open partition manager */
partman_handle = fopen(partman_name, NULL);// 打开分区
if (partman_handle == NULL)
{
error_code = ferror(partman_handle);
printf("Error opening partition manager: %s\n", MFS_Error_text((uint_32)error_code));
_task_block();
}
/* Validate partition 1 */
param = 1;
error_code = _io_ioctl(partman_handle, IO_IOCTL_VAL_PART, ¶m);// 控制分区
if (error_code == MQX_OK)
{
/* Install MFS over partition 1 */
error_code = _io_mfs_install(partman_handle, filesystem_name, param);/////安装文件系统，基于分区
if (error_code != MFS_NO_ERROR)
{
printf("Error initializing MFS over partition: %s\n", MFS_Error_text((uint_32)error_code));
_task_block();
}
} else {
/* Install MFS over SD card driver */
error_code = _io_mfs_install(sdcard_handle, filesystem_name, (_file_size)0);////////安装文件系统，无分区
if (error_code != MFS_NO_ERROR)
{
printf("Error initializing MFS: %s\n", MFS_Error_text((uint_32)error_code));
_task_block();
}
}
/* Open file system */
filesystem_handle = fopen(filesystem_name, NULL);// 打开文件系统
error_code = ferror (filesystem_handle);
if ((error_code != MFS_NO_ERROR) && (error_code != MFS_NOT_A_DOS_DISK))
{
printf("Error opening filesystem: %s\n", MFS_Error_text((uint_32)error_code));
_task_block();
}
if ( error_code == MFS_NOT_A_DOS_DISK )
{
printf("NOT A DOS DISK! You must format to continue.\n");
}
printf ("SD card installed to %s\n", filesystem_name);
if (readonly)
{
printf ("SD card is locked (read only).\n");
}
}
else // 拔出磁盘
{
/* Close the filesystem */
if (MQX_OK != fclose (filesystem_handle))
{
printf("Error closing filesystem.\n");
_task_block();
}
filesystem_handle = NULL;
/* Uninstall MFS */
error_code = _io_dev_uninstall(filesystem_name);
if (error_code != MFS_NO_ERROR)
{
printf("Error uninstalling filesystem.\n");
_task_block();
}
/* Close partition manager */
if (MQX_OK != fclose (partman_handle))
{
printf("Unable to close partition manager.\n");
_task_block();
}
partman_handle = NULL;
/* Uninstall partition manager */
error_code = _io_dev_uninstall(partman_name);
if (error_code != MFS_NO_ERROR)
{
printf("Error uninstalling partition manager.\n");
_task_block();
}
/* Close the SD card device */
if (MQX_OK != fclose (sdcard_handle))
{
printf("Unable to close SD card device.\n");
_task_block();
}
sdcard_handle = NULL;
printf ("SD card uninstalled.\n");
printf ("sd unOK dx.\n");/////////////////////////dx
}
}
last = inserted;
// _time_delay (200);// 将活动的任务挂起指定的毫秒数
// #if defined BSP_SDCARD_GPIO_DETECT
// #if BSP_SDCARD_GPIO_DETECT_INT
// /****************dx 20121211************************************************************/
// _lwevent_wait_ticks(&SD_Event,SD_EVENT_DETECT,FALSE,0);///////////等待事件USB_EVENT
// _lwevent_clear(&SD_Event,SD_EVENT_DETECT);
// /****************************************************************************************/
// #endif
// #endif
/*使用SD外部端口测试SD卡是否已经插入*/
#if defined BSP_SDCARD_GPIO_DETECT
#ifdef BSP_MPC8308RDB
/* Set function as GPIO to detect sdcard */
lwgpio_set_functionality(&sd_detect,BSP_SDCARD_DETECT_MUX_GPIO);
lwgpio_set_attribute(&sd_detect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
#if ! BSP_SDCARD_GPIO_DETECT_INT
inserted = !lwgpio_get_value(&sd_detect);// 检测磁盘是否插入/////////////////////////////////////////
#else
/****************dx 20121211************************************************************/
_lwevent_wait_ticks(&SD_Event,SD_EVENT_DETECT,FALSE,0);///////////等待事件USB_EVENT
_lwevent_clear(&SD_Event,SD_EVENT_DETECT);
ioctl(port_file_sd_detect_int, GPIO_IOCTL_READ, (char_ptr) &sd_detect_int);
inserted = !( sd_detect_int[0] & GPIO_PIN_STATUS);
/****************************************************************************************/
#endif
#endif
}/////////////////////////////////////////////////////////////////////////////循环
}
void Main_Task(uint_32 param)
{
USB_STATUS status = USB_OK;
_usb_pipe_handle pipe;
TR_INIT_PARAM_STRUCT tr;
HID_COMMAND hid_com;
uchar *buffer;
printf("\n** MQX USB Keyboard To Mouse Demo **\n");
printf("\nDemo will allow you control mouse cursor on your PC using keyboard attached to TWR-SER2 board.");
printf("\nThis demo requires TWR-SER2 card and correct BSP setting.");
printf("\nSee FSL_MQX_getting_started.pdf chapter 7 for details.");
fflush(stdout);
MouseDev_Init();
/* Allocate buffer to receive data from interrupt. It must be created on uncached heap,
** since some USB host controllers use DMA to access those buffers.
*/
buffer = USB_mem_alloc_uncached(HID_BUFFER_SIZE);
if (buffer == NULL) {
printf("\nMemory allocation failed. STATUS: %x", status);
fflush(stdout);
_task_block();
}
/* _usb_otg_init needs to be done with interrupts disabled */
_int_disable();
/* event for USB callback signaling */
_lwevent_create(&USB_Event, LWEVENT_AUTO_CLEAR);
_int_install_unexpected_isr();
/* Register USB interface and its settings from BSP */
if (MQX_OK != _usb_host_driver_install(&_bsp_usb_host_khci0_if)) {
printf("\n\nUSB Host Installation failed.");
fflush(stdout);
_task_block();
}
/*
** It means that we are going to act like host, so we initialize the
** host stack. This call will allow USB system to allocate memory for
** data structures, it uses later (e.g pipes etc.).
*/
status = _usb_host_init(&_bsp_usb_host_khci0_if, &host_handle);
if(status != USB_OK) {
printf("\nUSB Host Initialization failed. STATUS: %x", status);
fflush(stdout);
_task_block();
}
/*
** since we are going to act as the host driver, register the driver
** information for wanted class/subclass/protocols
*/
status = _usb_host_driver_info_register(host_handle, DriverInfoTable);
if(status != USB_OK) {
printf("\nDriver Registration failed. STATUS: %x", status);
fflush(stdout);
_task_block();
}
_int_enable();
printf("\nHost initialization finished. Attach USB Keyboard to the board.");
/*
** Infinite loop, waiting for events requiring action
*/
for(;;) {
// Wait for insertion or removal event
_lwevent_wait_ticks(&USB_Event, USB_EVENT_CTRL, FALSE, 0);
switch (hid_device.DEV_STATE) {
case USB_DEVICE_IDLE:
break;
case USB_DEVICE_ATTACHED:
hid_device.DEV_STATE = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(hid_device.DEV_HANDLE, hid_device.INTF_HANDLE, (pointer) & hid_device.CLASS_INTF);
if(status != USB_OK) {
printf("\nError in _usb_hostdev_select_interface: %x", status);
fflush(stdout);
_task_block();
}
break;
case USB_DEVICE_SET_INTERFACE_STARTED:
break;
case USB_DEVICE_INTERFACED:
printf("\nKeyboard device interfaced, setting protocol.");
/* now we will set the USB Hid standard boot protocol */
hid_device.DEV_STATE = USB_DEVICE_SETTING_PROTOCOL;
hid_com.CLASS_PTR = (CLASS_CALL_STRUCT_PTR) & hid_device.CLASS_INTF;
hid_com.CALLBACK_FN = usb_host_hid_ctrl_callback;
hid_com.CALLBACK_PARAM = 0;
/* Force the keyboard to behave as in USB Hid class standard boot protocol */
status = usb_class_hid_set_protocol(&hid_com, USB_PROTOCOL_HID_KEYBOARD);
if(status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in usb_class_hid_set_protocol: %x", status);
fflush(stdout);
}
break;
case USB_DEVICE_INUSE:
pipe = _usb_hostdev_find_pipe_handle(hid_device.DEV_HANDLE, hid_device.INTF_HANDLE, USB_INTERRUPT_PIPE, USB_RECV);
if(pipe) {
printf("\n\nUse W, A, S or D to move the cursor.\nW = UP\nS = DOWN\nA = LEFT\nD = RIGHT\n");
while(1) {
/******************************************************************
Initiate a transfer request on the interrupt pipe
******************************************************************/
usb_hostdev_tr_init(&tr, usb_host_hid_recv_callback, NULL);
tr.G.RX_BUFFER = (uchar *) buffer;
tr.G.RX_LENGTH = HID_BUFFER_SIZE;
status = _usb_host_recv_data(host_handle, pipe, &tr);
if(status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in _usb_host_recv_data: %x", status);
fflush(stdout);
}
/* Wait untill we get the data from keyboard. */
_lwevent_wait_ticks(&USB_Event, USB_EVENT_CTRL | USB_EVENT_DATA, FALSE, 0);
/* if not detached in the meanwhile */
if(hid_device.DEV_STATE == USB_DEVICE_INUSE) {
process_kbd_buffer((uchar *)buffer);
}
else {
/* kick the outer loop again to handle the CTRL event */
_lwevent_set(&USB_Event, USB_EVENT_CTRL);
break;
}
/* Slight delay to be nice to other processes. (Note that keyboards have its
own autorepeat delay typically much longer than one would expect. In case
the user holds the key (without any other keys changed), the USB response
from keyboard is delayed (typ by 500ms). This is why the USB host should
handle autorepeat feature by itself (not done in this example) */
_time_delay(1);
USB_HID_Periodic_Task(); //feed the USB device with the correct setup answers
}
}
break;
case USB_DEVICE_DETACHED:
printf("Going to idle state\n");
hid_device.DEV_STATE = USB_DEVICE_IDLE;
break;
}
}
}
uint32_t MACNET_initialize
(
ENET_CONTEXT_STRUCT_PTR enet_ptr
)
{
MACNET_CONTEXT_STRUCT_PTR macnet_context_ptr=NULL;
ENET_MemMapPtr macnet_ptr;
VENET_BD_STRUCT_PTR bd_ptr;
unsigned char *buf_ptr;
MACNET_RX_PCB_PTR pcb_ptr;
uint32_t i, rxsize, txsize, ssize, lsize, pcbsize,rx_pcb_size, large_packet_size, rcr;
uint32_t timeout, error = ENET_OK;
bool bOK;
#if ENETCFG_SUPPORT_PTP
MACNET_PTP_PRIVATE_PTR macnet_ptp_ptr = NULL;
#endif /* ENETCFG_SUPPORT_PTP */
// Initialize the MACNET I/O Pins
MACNET_io_init(enet_ptr->PARAM_PTR->ENET_IF->MAC_NUMBER);
macnet_ptr = MACNET_get_base_address(enet_ptr->PARAM_PTR->ENET_IF->MAC_NUMBER);
if (macnet_ptr == NULL) {
return ENETERR_INVALID_DEVICE;
}
// currently limit number of TX BDs to 32, as a bitmask is used in the free function.
if (enet_ptr->PARAM_PTR->NUM_TX_ENTRIES > 32) {
return ENETERR_INVALID_INIT_PARAM;
}
/*
** This function can be called from any context, and it needs mutual
** exclusion with itself.
*/
MACNET_int_disable();
macnet_context_ptr = _mem_alloc_system_zero(sizeof(MACNET_CONTEXT_STRUCT));
IF_ERROR_EXIT((NULL==macnet_context_ptr), ENETERR_ALLOC_MAC_CONTEXT);
_mem_set_type((void *)macnet_context_ptr, MEM_TYPE_IO_ENET_MAC_CONTEXT_STRUCT);
enet_ptr->MAC_CONTEXT_PTR = (void *) macnet_context_ptr;
macnet_context_ptr->MACNET_ADDRESS = macnet_ptr;
macnet_context_ptr->PHY_PTR = MACNET_get_base_address(enet_ptr->PARAM_PTR->ENET_IF->PHY_NUMBER);
/* Stop the chip */
macnet_ptr->ECR = ENET_ECR_RESET_MASK;
/* wait until the initialization cycle completes */
timeout = 0;
while ((macnet_ptr->ECR & ENET_ECR_RESET_MASK) && (timeout<MACNET_RESET_TIMEOUT)){
_time_delay(1);
timeout++;
}
IF_ERROR_EXIT((macnet_ptr->ECR & ENET_ECR_RESET_MASK), ENETERR_INIT_FAILED);
/* Disable all MACNET interrupts */
macnet_ptr->EIMR = 0;
/* clear any pending interrpts */
macnet_ptr->EIR = ENET_EIR_ALL_PENDING;
macnet_context_ptr->NumRxBDs = enet_ptr->PARAM_PTR->NUM_RX_ENTRIES;
macnet_context_ptr->NumTxBDs = enet_ptr->PARAM_PTR->NUM_TX_ENTRIES;
// Compute aligned buffer sizes
if (enet_ptr->PARAM_PTR->TX_BUFFER_SIZE) {
macnet_context_ptr->AlignedTxBufferSize = MACNET_TX_ALIGN(enet_ptr->PARAM_PTR->TX_BUFFER_SIZE);
} else {
macnet_context_ptr->AlignedTxBufferSize = MACNET_TX_ALIGN(enet_ptr->MaxTxFrameSize);
}
if (enet_ptr->PARAM_PTR->RX_BUFFER_SIZE) {
macnet_context_ptr->AlignedRxBufferSize = MACNET_RX_ALIGN(enet_ptr->PARAM_PTR->RX_BUFFER_SIZE);
} else {
macnet_context_ptr->AlignedRxBufferSize = MACNET_RX_ALIGN(enet_ptr->MaxRxFrameSize);
}
// Allocate the Transmit and Receive buffer descriptors
// TODO remake to using alloc_align fn
#if BSPCFG_HAS_SRAM_POOL && BSPCFG_ENET_SRAM_BUF
bd_ptr = (VENET_BD_STRUCT_PTR)_mem_alloc_system_zero_from(_BSP_sram_pool, (sizeof(ENET_BD_STRUCT)*(macnet_context_ptr->NumRxBDs+macnet_context_ptr->NumTxBDs))+MACNET_BD_ALIGNMENT);
#else
bd_ptr = (VENET_BD_STRUCT_PTR)_mem_alloc_system_zero_uncached((sizeof(ENET_BD_STRUCT)*(macnet_context_ptr->NumRxBDs+macnet_context_ptr->NumTxBDs))+MACNET_BD_ALIGNMENT);
#endif
IF_ERROR_EXIT((NULL == bd_ptr), ENETERR_ALLOC_BD);
_mem_set_type((void *)bd_ptr, MEM_TYPE_IO_BD_STRUCT);
macnet_context_ptr->UNALIGNED_RING_PTR = (void *) bd_ptr;
macnet_context_ptr->MACNET_RX_RING_PTR = (VENET_BD_STRUCT_PTR) MACNET_BD_ALIGN((uint32_t)bd_ptr);
macnet_context_ptr->MACNET_TX_RING_PTR = &macnet_context_ptr->MACNET_RX_RING_PTR[macnet_context_ptr->NumRxBDs];
/* Set wrap bit in last BD */
macnet_context_ptr->MACNET_RX_RING_PTR[macnet_context_ptr->NumRxBDs - 1].CONTROL = HOST_TO_BE_SHORT_CONST(ENET_BD_ETHER_RX_WRAP);
macnet_context_ptr->MACNET_TX_RING_PTR[macnet_context_ptr->NumTxBDs - 1].CONTROL = HOST_TO_BE_SHORT_CONST(ENET_BD_ETHER_TX_WRAP);
macnet_context_ptr->AvailableTxBDs = macnet_context_ptr->NumTxBDs;
// Allocate array to hold Transmit PCB pointers while they are queued for transmission
macnet_context_ptr->TxPCBS_PTR = (PCB_PTR *) _mem_alloc_system_zero(sizeof(PCB_PTR)*macnet_context_ptr->NumTxBDs);
IF_ERROR_EXIT((NULL==macnet_context_ptr->TxPCBS_PTR), ENETERR_ALLOC_PCB);
_mem_set_type((void *)macnet_context_ptr->TxPCBS_PTR, MEM_TYPE_IO_PCB_PTR);
// Allocate the Receive PCBs
rx_pcb_size = sizeof(MACNET_RX_PCB);
pcbsize = enet_ptr->PARAM_PTR->NUM_RX_PCBS * rx_pcb_size;
macnet_context_ptr->RX_PCB_BASE = (MACNET_RX_PCB_PTR) _mem_alloc_system_zero(pcbsize);
IF_ERROR_EXIT((NULL==macnet_context_ptr->RX_PCB_BASE), ENETERR_ALLOC_PCB);
_mem_set_type((void *)macnet_context_ptr->RX_PCB_BASE, MEM_TYPE_IO_PCB_STRUCT);
// Allocate the Transmit and Receive buffers
txsize = (enet_ptr->PARAM_PTR->NUM_TX_BUFFERS * macnet_context_ptr->AlignedTxBufferSize) + MACNET_TX_BUFFER_ALIGNMENT;
rxsize = (enet_ptr->PARAM_PTR->NUM_RX_BUFFERS * macnet_context_ptr->AlignedRxBufferSize) +MACNET_RX_BUFFER_ALIGNMENT;
ssize = (enet_ptr->PARAM_PTR->NUM_SMALL_BUFFERS * MACNET_SMALL_PACKET_SIZE);
large_packet_size = enet_ptr->PARAM_PTR->OPTIONS&ENET_OPTION_VLAN ? ENET_FRAMESIZE_VLAN : ENET_FRAMESIZE;
lsize = (enet_ptr->PARAM_PTR->NUM_LARGE_BUFFERS * large_packet_size);
#if BSPCFG_HAS_SRAM_POOL && BSPCFG_ENET_SRAM_BUF
buf_ptr = _mem_alloc_system_from(_BSP_sram_pool, rxsize + txsize + ssize + lsize);
#else
buf_ptr = _mem_alloc_system_uncached(rxsize + txsize + ssize + lsize); // temporary fix for cache problems... previously _mem_alloc_system
#endif
IF_ERROR_EXIT((NULL==buf_ptr), ENETERR_ALLOC_BUFFERS);
_mem_set_type(buf_ptr, MEM_TYPE_IO_ENET_BUFFERS);
macnet_context_ptr->UNALIGNED_BUFFERS = buf_ptr;
// Align to TX buffer boundary
buf_ptr = (unsigned char *)MACNET_TX_ALIGN((uint32_t)buf_ptr);
// Queue packets on TX Buffer Q.
macnet_context_ptr->TX_BUFFERS = NULL;
for (i=0;i<enet_ptr->PARAM_PTR->NUM_TX_BUFFERS;i++) {
ENET_Enqueue_Buffer((void **)&macnet_context_ptr->TX_BUFFERS, buf_ptr);
buf_ptr += macnet_context_ptr->AlignedTxBufferSize;
}
// Align to RX buffer boundary
buf_ptr = (unsigned char *)MACNET_RX_ALIGN((uint32_t)buf_ptr);
// Queue packets on RX Buffer Q.
macnet_context_ptr->RX_BUFFERS = NULL;
for (i=0;i<enet_ptr->PARAM_PTR->NUM_RX_BUFFERS;i++) {
ENET_Enqueue_Buffer((void **)&macnet_context_ptr->RX_BUFFERS, buf_ptr);
buf_ptr += macnet_context_ptr->AlignedRxBufferSize;
}
// Queue small packets on small buffer Q.
for (i=0;i<enet_ptr->PARAM_PTR->NUM_SMALL_BUFFERS;i++) {
ENET_Enqueue_Buffer((void **)&macnet_context_ptr->SMALL_BUFFERS, buf_ptr);
buf_ptr += MACNET_SMALL_PACKET_SIZE;
}
// Queue large packets on large buffer Q.
for (i=0;i<enet_ptr->PARAM_PTR->NUM_LARGE_BUFFERS;i++) {
ENET_Enqueue_Buffer((void **)&macnet_context_ptr->LARGE_BUFFERS, buf_ptr);
buf_ptr += large_packet_size;
}
// Enqueue the RX PCBs onto the receive PCB queue
pcb_ptr = macnet_context_ptr->RX_PCB_BASE;
for (i = 0; i < enet_ptr->PARAM_PTR->NUM_RX_PCBS; i++) {
QADD(macnet_context_ptr->RxPCBHead, macnet_context_ptr->RxPCBTail, (PCB_PTR) pcb_ptr);
pcb_ptr++;
}
// Fill up the receive ring
MACNET_add_buffers_to_rx_ring(macnet_context_ptr);
/* Program this station's Ethernet physical address */
macnet_ptr->PALR = (uint32_t)((enet_ptr->ADDRESS[0] << 24)|(enet_ptr->ADDRESS[1] << 16)|(enet_ptr->ADDRESS[2] << 8)|(enet_ptr->ADDRESS[3] << 0));
macnet_ptr->PAUR = (uint32_t)((enet_ptr->ADDRESS[4] << 24)|(enet_ptr->ADDRESS[5] << 16));
// Clear the individual hash table registers
macnet_ptr->IAUR = 0;
macnet_ptr->IALR = 0;
// Clear the group hash table registers
macnet_ptr->GAUR = 0;
macnet_ptr->GALR = 0;
/* Program receive buffer size */
macnet_ptr->MRBR = macnet_context_ptr->AlignedRxBufferSize;
// Configure start of Rx and Tx BD rings
macnet_ptr->RDSR = (uint32_t)(macnet_context_ptr->MACNET_RX_RING_PTR);
macnet_ptr->TDSR = (uint32_t)(macnet_context_ptr->MACNET_TX_RING_PTR);
// Set Receive Frame size
// NOTE: Oddly, the Receive Control Register (RCR) afmacnetts the transmit side too. The RCR is used to determine if the
// transmitter is babbling, which means, if the RX buffer size < Tx Buffer size, we can get babling transmitter
// errors if we set RCR to the maximum Receive frame length. We really have no choice but to set RCR to one
// of ENET_FRAMESIZE or ENET_FRAMESIZE_VLAN.
//
rcr = ENET_RCR_MII_MODE_MASK | (ENET_RCR_MAX_FL_MASK & (large_packet_size << ENET_RCR_MAX_FL_SHIFT));
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_RMII) {
rcr |= ENET_RCR_RMII_MODE_MASK;
} else if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_7WIRE) {
rcr &= ~ENET_RCR_MII_MODE_MASK;
}
if (enet_ptr->PARAM_PTR->MODE & ENET_10M)
{
rcr |= ENET_RCR_RMII_10T_MASK;
}
macnet_ptr->RCR = rcr;
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_MAC_LOOPBACK) {
macnet_ptr->RCR |= ENET_RCR_LOOP_MASK;
}
// Set Full/Half duplex based on mode.
if (enet_ptr->PARAM_PTR->MODE & ENET_HALF_DUPLEX) {
macnet_ptr->TCR = 0; // half duplex
} else {
macnet_ptr->TCR = 4; // full duplex
}
// Enable MII_SPEED register
i = (MACNET_device[enet_ptr->PARAM_PTR->ENET_IF->MAC_NUMBER].BUS_CLOCK / enet_ptr->PARAM_PTR->ENET_IF->PHY_MII_SPEED + 1) & ~1;
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_NO_PREAMBLE) {
i |= ENET_MSCR_DIS_PRE_MASK;
}
macnet_context_ptr->PHY_PTR->MSCR = i;
// Zero counters
macnet_ptr->MIBC |= ENET_MIBC_MIB_CLEAR_MASK;
// Install the ISRs
bOK = MACNET_install_isrs( enet_ptr, &MACNET_device[enet_ptr->PARAM_PTR->ENET_IF->MAC_NUMBER] );
IF_ERROR_EXIT(!bOK, ENETERR_INSTALL_ISR);
// Unmask transmit/receive interrupts
// NOTE: need to enable both RXF and RXB, but only TXB, as RXB does not get generated with RXF,
// but TXB does get generated with TXF
// However, on 52259, enabling RXB is resulting in an HBERR interrupt. RXB is not required, so leave it disabled.
macnet_ptr->EIMR = ENET_EIR_TXB_MASK | ENET_EIR_RXF_MASK;
// Enable MACNET
macnet_ptr->ECR = (ENET_ECR_ETHEREN_MASK | ENET_ECR_EN1588_MASK);// | 0x100;
// Discover PHY address if PHY_DISCOVER option is set
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_PHY_DISCOVER) {
bOK = (*enet_ptr->PARAM_PTR->ENET_IF->PHY_IF->DISCOVER)(enet_ptr);
IF_ERROR_EXIT(!bOK, ENETERR_INIT_FAILED);
} else {
// Set Phy address from initialization parameter
enet_ptr->PHY_ADDRESS = enet_ptr->PARAM_PTR->ENET_IF->PHY_ADDRESS;
}
/******* Support of TCP/IP offload engine.*******/
/* Transmit Accelerator Function Configuration. */
macnet_ptr->TACC = 0;
#if BSPCFG_ENET_HW_TX_IP_CHECKSUM
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_HW_TX_IP_CHECKSUM)
{
macnet_ptr->TACC |= ENET_TACC_IPCHK_MASK; /* Insert IP header checksum.*/
}
#endif
#if BSPCFG_ENET_HW_TX_PROTOCOL_CHECKSUM
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_HW_TX_PROTOCOL_CHECKSUM)
{
macnet_ptr->TACC |= ENET_TACC_PROCHK_MASK; /* Insert Protocol checksum.*/
}
#endif
/* Receive Accelerator Function Configuration. */
macnet_ptr->RACC = 0;
#if BSPCFG_ENET_HW_RX_IP_CHECKSUM
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_HW_RX_IP_CHECKSUM)
{
macnet_ptr->RACC |= ENET_RACC_IPDIS_MASK; /* Discard of frames with wrong IPv4 header checksum.*/
}
#endif
#if BSPCFG_ENET_HW_RX_PROTOCOL_CHECKSUM
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_HW_RX_PROTOCOL_CHECKSUM)
{
macnet_ptr->RACC |= ENET_RACC_PRODIS_MASK; /* Discard of frames with wrong protocol checksum.*/
}
#endif
#if BSPCFG_ENET_HW_RX_MAC_ERR
if (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_HW_RX_MAC_ERR)
{
macnet_ptr->RACC |= ENET_RACC_LINEDIS_MASK; /* Discard of frames with MAC layer errors.*/
}
#endif
if (
#if BSPCFG_ENET_HW_TX_IP_CHECKSUM || BSPCFG_ENET_HW_TX_PROTOCOL_CHECKSUM
(enet_ptr->PARAM_PTR->OPTIONS & (ENET_OPTION_HW_TX_IP_CHECKSUM|ENET_OPTION_HW_TX_PROTOCOL_CHECKSUM))||
#endif
(enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_STORE_AND_FORW) )
{
/* Transmit FIFO Watermark Register.
* The TFWR[STRFWD] bit must be set to use the checksum feature.
* In this case, the MAC starts to transmit data only when a complete
* frame is stored in the transmit FIFO.*/
macnet_ptr->TFWR = ENET_TFWR_STRFWD_MASK;
}
if (
#if BSPCFG_ENET_HW_RX_IP_CHECKSUM || BSPCFG_ENET_HW_RX_PROTOCOL_CHECKSUM
(enet_ptr->PARAM_PTR->OPTIONS & (ENET_OPTION_HW_RX_IP_CHECKSUM|ENET_OPTION_HW_RX_PROTOCOL_CHECKSUM))||
#endif
(enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_STORE_AND_FORW) )
{
/* Discarding is only available when the RX FIFO operates in store and forward
* mode (RSFL cleared).*/
macnet_ptr->RSFL = 0;
}
// Perform Phy initialization
bOK = (*enet_ptr->PARAM_PTR->ENET_IF->PHY_IF->INIT)(enet_ptr);
IF_ERROR_EXIT(!bOK, ENETERR_INIT_FAILED);
// Signals the MACNET that empty buffers are available.
// It is NECESSARY to do this AFTER enabling the MACNET.
macnet_ptr->RDAR = ENET_RDAR_RDAR_MASK;
//jm _mem_copy((void*)0x400d0000, (void*)0x3f400000, 0x400);
#if ENETCFG_SUPPORT_PTP
macnet_ptp_ptr = _mem_alloc_system_zero(sizeof(MACNET_PTP_PRIVATE));
IF_ERROR_EXIT((NULL==macnet_context_ptr), ENETERR_ALLOC_MAC_CONTEXT);
macnet_ptp_ptr->MACNET_PTR = macnet_context_ptr->MACNET_ADDRESS;
macnet_ptp_ptr->PTIMER_PRESENT = 1;
bOK = _lwevent_create(&(macnet_ptp_ptr->LWEVENT_PTP), 0);
IF_ERROR_EXIT(bOK, ENETERR_1588_LWEVENT);
macnet_ptp_ptr->TXSTAMP = (MACNET_PTP_TIME){0,0};
macnet_ptp_ptr->L2PCKS_PTR = NULL;
macnet_context_ptr->PTP_PRIV = macnet_ptp_ptr;
MACNET_ptp_init(enet_ptr);
if (macnet_ptp_ptr->PTIMER_PRESENT) {
/* Set Timer count */
MACNET_ptp_start(macnet_ptp_ptr, (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_PTP_MASTER_CLK));
if(enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_PTP_MASTER_CLK)
MACNET_ptp_set_master_base_address(macnet_ptr);
macnet_ptp_ptr->MACNET_PTR->ECR |= ENET_ECR_EN1588_MASK;
}
/* Enable timer-relative interrupts */
macnet_ptp_ptr->MACNET_PTR->EIMR |= (ENET_EIR_TS_TIMER_MASK | ENET_EIR_TS_AVAIL_MASK);
#endif /* ENETCFG_SUPPORT_PTP */
// control transfers to this point on any error, with error set to error code.
EXIT:
if (ENET_OK!=error) {
#if BSPCFG_ENET_RESTORE
MACNET_uninstall_all_isrs(enet_ptr);
#endif
MACNET_free_context(macnet_context_ptr);
}
MACNET_int_enable();
return error;
}
void Mouse_Task( uint32_t param )
{
USB_STATUS status = USB_OK;
TR_INIT_PARAM_STRUCT tr;
HID_COMMAND_PTR hid_com;
unsigned char *buffer;
PIPE_STRUCT_PTR pipe;
uint32_t e;
_usb_host_handle mouse_host_handle = (_usb_host_handle) param;
hid_com = (HID_COMMAND_PTR) _mem_alloc(sizeof(HID_COMMAND));
/* event for USB callback signaling */
_lwevent_create(&USB_Mouse_Event, LWEVENT_AUTO_CLEAR);
printf("\nMQX USB HID Mouse Demo\nWaiting for USB Mouse to be attached...\n");
fflush(stdout);
/*
** Infinite loop, waiting for events requiring action
*/
for ( ; ; ) {
// Wait for insertion or removal event
_lwevent_wait_ticks(&USB_Mouse_Event, USB_EVENT_CTRL, FALSE, 0);
switch ( mouse_hid_device.DEV_STATE ) {
case USB_DEVICE_IDLE:
break;
case USB_DEVICE_ATTACHED:
printf("\nMouse device attached\n");
fflush(stdout);
mouse_hid_device.DEV_STATE = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(mouse_hid_device.DEV_HANDLE, mouse_hid_device.INTF_HANDLE, (void *)&mouse_hid_device.CLASS_INTF);
if (status != USB_OK) {
printf("\nError in _usb_hostdev_select_interface: %x", status);
fflush(stdout);
_task_block();
} /* Endif */
break;
case USB_DEVICE_SET_INTERFACE_STARTED:
break;
case USB_DEVICE_INTERFACED:
pipe = _usb_hostdev_find_pipe_handle(mouse_hid_device.DEV_HANDLE, mouse_hid_device.INTF_HANDLE, USB_INTERRUPT_PIPE, USB_RECV);
if (pipe == NULL) {
printf("\nError getting interrupt pipe.");
fflush(stdout);
_task_block();
}
_usb_hostdev_get_buffer(mouse_hid_device.DEV_HANDLE, pipe->MAX_PACKET_SIZE, (void **) &buffer);
if (buffer == NULL) {
printf("\nMemory allocation failed. STATUS: %x", status);
fflush(stdout);
_task_block();
}
printf("Mouse interfaced, setting protocol...\n");
/* now we will set the USB Hid standard boot protocol */
mouse_hid_device.DEV_STATE = USB_DEVICE_SETTING_PROTOCOL;
hid_com->CLASS_PTR = (CLASS_CALL_STRUCT_PTR)&mouse_hid_device.CLASS_INTF;
hid_com->CALLBACK_FN = usb_host_hid_mouse_ctrl_callback;
hid_com->CALLBACK_PARAM = 0;
status = usb_class_hid_set_protocol(hid_com, USB_PROTOCOL_HID_MOUSE);
if (status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in usb_class_hid_set_protocol: %x", status);
fflush(stdout);
}
break;
case USB_DEVICE_INUSE:
printf("Mouse device ready, try to move the mouse\n");
while (1) {
/******************************************************************
Initiate a transfer request on the interrupt pipe
******************************************************************/
usb_hostdev_tr_init(&tr, usb_host_hid_mouse_recv_callback, NULL);
tr.G.RX_BUFFER = buffer;
tr.G.RX_LENGTH = pipe->MAX_PACKET_SIZE;
status = _usb_host_recv_data(mouse_host_handle, pipe, &tr);
if (status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in _usb_host_recv_data: %x", status);
fflush(stdout);
}
/* Wait untill we get the data from keyboard. */
_lwevent_wait_ticks(&USB_Mouse_Event, USB_EVENT_CTRL | USB_EVENT_DATA | USB_EVENT_DATA_CORRUPTED, FALSE, 0);
e = _lwevent_get_signalled();
if (USB_EVENT_DATA == e) {
if(mouse_hid_device.DEV_STATE == USB_DEVICE_INUSE) {
process_mouse_buffer((unsigned char *)buffer);
}
}
else if (USB_EVENT_CTRL == e) {
/* kick the outer loop again to handle the CTRL event */
_lwevent_set(&USB_Mouse_Event, USB_EVENT_CTRL);
break;
}
}
break;
case USB_DEVICE_DETACHED:
printf("Going to idle state\n");
mouse_hid_device.DEV_STATE = USB_DEVICE_IDLE;
break;
case USB_DEVICE_OTHER:
break;
default:
printf("Unknown Mouse Device State = %d\n", mouse_hid_device.DEV_STATE);
fflush(stdout);
break;
} /* Endswitch */
} /* Endfor */
} /* Endbody */
/*TASK*-----------------------------------------------------------------
*
* Function Name : Sdcard_task
* Returned Value : void
* Comments :
*
*END------------------------------------------------------------------*/
void Sdcard_task
(
uint_32 temp
)
{
boolean inserted = TRUE, last = FALSE;
_mqx_int error_code;
MQX_FILE_PTR com_handle;
//#if defined BSP_SDCARD_GPIO_DETECT
// LWGPIO_STRUCT sd_detect;
//#endif
#if defined BSP_SDCARD_GPIO_PROTECT
LWGPIO_STRUCT sd_protect;
#endif
#ifdef BSP_SDCARD_GPIO_CS
LWGPIO_STRUCT sd_cs;
SPI_CS_CALLBACK_STRUCT callback;
#endif
_task_id player_task_id, sd_walker_id;
_mqx_int sd_event_value;
_mqx_uint wait_state;
#ifdef USB_ACCESSORY_PLAY
connect_msg_t msg;
int delaySetp = 0;
#endif
if (MQX_OK !=_lwevent_create(&(sddetect_event), LWEVENT_AUTO_CLEAR)) {
printf("\n_lwevent_create sddetect_event failed\n");
_task_block();
}
/* Open low level communication device */
com_handle = fopen (SDCARD_COM_CHANNEL, NULL);
if (NULL == com_handle)
{
printf("Error installing communication handle.\n");
_task_block();
}
#ifdef BSP_SDCARD_GPIO_CS
/* Open GPIO file for SPI CS signal emulation */
error_code = lwgpio_init(&sd_cs, BSP_SDCARD_GPIO_CS, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with associated pins failed.\n");
_task_block();
}
lwgpio_set_functionality(&sd_cs,BSP_SDCARD_CS_MUX_GPIO);
lwgpio_set_attribute(&sd_cs, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
/* Set CS callback */
callback.MASK = BSP_SDCARD_SPI_CS;
callback.CALLBACK = set_CS;
callback.USERDATA = &sd_cs;
if (SPI_OK != ioctl (com_handle, IO_IOCTL_SPI_SET_CS_CALLBACK, &callback))
{
printf ("Setting CS callback failed.\n");
_task_block();
}
#endif
#if defined BSP_SDCARD_GPIO_DETECT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_detect, BSP_SDCARD_GPIO_DETECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with sdcard detect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_detect,BSP_SDCARD_DETECT_MUX_GPIO);
lwgpio_set_attribute(&sd_detect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#ifndef SD_DETECT_POLLING // init sd detcet pin interrupt
lwgpio_int_init(&sd_detect,LWGPIO_INT_MODE_RISING | LWGPIO_INT_MODE_FALLING /* LWGPIO_INT_MODE_HIGH*/); /* falling,raising mode = 3 */
/* install gpio interrupt service routine */
_int_install_isr(lwgpio_int_get_vector(&sd_detect), EXT_SDDETECT_ISR, (void *) &sd_detect);
_bsp_int_init(lwgpio_int_get_vector(&sd_detect), 5, 0, TRUE);
lwgpio_int_enable(&sd_detect, TRUE);
#endif
#endif
#if defined BSP_SDCARD_GPIO_PROTECT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_protect, BSP_SDCARD_GPIO_PROTECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with sdcard protect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_protect,BSP_SDCARD_PROTECT_MUX_GPIO);
lwgpio_set_attribute(&sd_protect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
/* Install SD card device */
error_code = _io_sdcard_install("sdcard:", (pointer)&_bsp_sdcard0_init, com_handle);
if ( error_code != MQX_OK )
{
printf("Error installing SD card device (0x%x)\n", error_code);
_task_block();
}
_lwevent_set(&sddetect_event,SD_ATTACHED_EVENT); // set attached event at mode manager
_time_delay(1000); /* wait otg main task ready */
printf("start sd card task\n");
// use sd detect interrupt
for (;;) {
#ifdef SD_DETECT_POLLING
wait_state = _lwevent_wait_ticks(&sddetect_event,SD_EVENT_MASK, FALSE, 4/* 0*/);
#else
wait_state = _lwevent_wait_ticks(&sddetect_event,SD_EVENT_MASK, FALSE, 0);
#endif
//if (wait_state == LWEVENT_WAIT_TIMEOUT/* MQX_OK*/) {
if (wait_state != MQX_OK ) {
#ifndef SD_DETECT_POLLING
printf("waiting sddetect_event fail\n");
// _task_block(); // _lwevent_destroy(&sddetect_event);
//-goto wait_timeout;
continue;
#else
_lwevent_set(&sddetect_event,SD_ATTACHED_EVENT);
#endif
}
//else
sd_event_value = _lwevent_get_signalled();
if (sd_event_value == SD_ATTACHED_EVENT ) {
_time_delay (200);
inserted = !lwgpio_get_value(&sd_detect);
if(!inserted) // mount sd fs ,must attached sd card !
continue;
// printf("mount sd card...\n");
// mount_sdcard();
#ifndef USB_ACCESSORY_PLAY
/* create player and sd_walker task*/
player_task_id = _task_create(0, PLAYER_TASK, 0);
printf("Creating sd player task................");
if (player_task_id == MQX_NULL_TASK_ID) {
printf("[FAIL]\n");
}
else {
printf("[OK]\n");
}
sd_walker_id = _task_create(0, SD_WALKER_TASK, 0);
printf("Creating sd walker task................");
if (sd_walker_id == MQX_NULL_TASK_ID) {
printf("[FAIL]\n");
}
else {
printf("[OK]\n");
}
#else
msg.conct_source = mp_for_TF;
msg.conct_action = mp_plugIn; /* post message, TFcard plug in*/
if (LWMSGQ_FULL == _lwmsgq_send(connect_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform about TFCard device attached\n");
}
//_time_delay (1); // give mode manager task some times to cancel play ,if sd task high than mode task
#endif
// _lwevent_set(&player_event, PLAYER_EVENT_MSK_SD_FS_MOUNTED); //auto play event
last = inserted;
} // SD_ATTACHED_EVENT
else if (sd_event_value == SD_DETTACHED_EVENT ) {
// _time_delay (100);
//inserted = !lwgpio_get_value(&sd_detect);
//if(inserted)
// continue;
#ifndef USB_ACCESSORY_PLAY
_lwevent_set(&player_event, PLAYER_EVENT_MSK_SD_FS_UNMOUNTED);
_lwevent_wait_ticks(&player_event,
PLAYER_EVENT_MSK_PLAYER_TASK_KILLED,
TRUE, 0);
_lwevent_clear(&player_event, PLAYER_EVENT_MSK_PLAYER_TASK_KILLED);
/* And the destroy play_task and sd_walker task */
_task_destroy(sd_walker_id);
_task_destroy(player_task_id);
#else
/* post message, TFcard plug out*/
msg.conct_source = mp_for_TF;
msg.conct_action = mp_plugOut; /* post message, TFcard plug out*/
if (LWMSGQ_FULL == _lwmsgq_send(connect_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform about TFCard device de-attached\n");
}
//_time_delay (1); // give mode manager task some times to cancel play ,if sd task high than mode task
#endif
// printf("unmount sd card...\n");
// unmount_sdcard();
// printf ("SD card uninstalled.\n");
}
}
}
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : Main_Task
* Returned Value : None
* Comments :
* First function called. This function is the entry for
* the PHDC Application
*
*END*--------------------------------------------------------------------*/
void Main_Task(uint_32 param)
{
/* Initialize Global Variable Structure */
PHDC_CONFIG_STRUCT phdc_config;
phdc_config.phdc_callback.callback = USB_App_Callback;
phdc_config.phdc_callback.arg = (void*)&g_bridge.handle;
phdc_config.vendor_callback.callback = NULL;
phdc_config.vendor_callback.arg = NULL;
phdc_config.desc_callback_ptr = &desc_callback;
phdc_config.info = &usb_desc_ep;
USB_mem_zero(&g_bridge, sizeof(BRIDGE_GLOBAL_VARIABLE_STRUCT));
if (_lwevent_create(&lwevent,0) != MQX_OK)
{
#if _DEBUG
printf("\nMake event failed : Main_Task");
#endif
_task_block();
}
g_usb_rx_buff_ptr = USB_mem_alloc_zero(PHDC_BULK_OUT_EP_SIZE);
if(g_usb_rx_buff_ptr == NULL)
{
#if _DEBUG
printf("g_usb_rx_buff_ptr malloc failed\n");
#endif
}
g_bridge_rx_buff_ptr = USB_mem_alloc_zero(PHDC_BULK_IN_EP_SIZE);
if(g_bridge_rx_buff_ptr == NULL)
{
#if _DEBUG
printf("g_bridge_rx_buff_ptr malloc failed\n");
#endif
}
_int_disable();
g_bridge.handle = USB_Class_PHDC_Init(&phdc_config);
Bridge_Interface_Init(Bridge_Callback);
_int_enable();
while(TRUE)
{
/* Block the task untill USB Enumeration is completed */
if(_lwevent_wait_for(&lwevent,USB_ENUM_COMPLETED,FALSE,NULL) !=
MQX_OK)
{
#if _DEBUG
printf("USB_ENUM_COMPLETEDEvent Wait failed\n");
#endif
_task_block();
}
if(_lwevent_clear(&lwevent,USB_ENUM_COMPLETED) != MQX_OK)
{
#if _DEBUG
printf("Enum Event Clear failed\n");
#endif
_task_block();
}
Bridge_Interface_Open(param);
}
}
void TestApp_Init(void)
{
AUDIO_CONFIG_STRUCT audio_config;
USB_CLASS_AUDIO_ENDPOINT * endPoint_ptr;
/* Pointer to audio endpoint entry */
endPoint_ptr = USB_mem_alloc_zero(sizeof(USB_CLASS_AUDIO_ENDPOINT)*AUDIO_DESC_ENDPOINT_COUNT);
/* USB descriptor endpoint */
audio_config.usb_ep_data = &usb_desc_ep;
/* USB audio unit */
audio_config.usb_ut_data = &usb_audio_unit;
/* Endpoint count */
audio_config.desc_endpoint_cnt = AUDIO_DESC_ENDPOINT_COUNT;
/* Application callback */
audio_config.audio_class_callback.callback = USB_App_Callback;
/* Application callback argurment */
audio_config.audio_class_callback.arg = &g_app_handle;
/* Vendor callback */
audio_config.vendor_req_callback.callback = NULL;
/* Vendor callback argurment */
audio_config.vendor_req_callback.arg = NULL;
/* Param callback function */
audio_config.param_callback.callback = USB_Notif_Callback;
/* Param callback argurment */
audio_config.param_callback.arg = &g_app_handle;
/* Memory param callback */
audio_config.mem_param_callback.callback = NULL;
/* Memory param callback argurment */
audio_config.mem_param_callback.arg = &g_app_handle;
/* Descriptor callback pointer */
audio_config.desc_callback_ptr = &desc_callback;
/* Audio enpoint pointer */
audio_config.ep = endPoint_ptr;
/* Initialize timer module */
// audio_timer_init();
// _audio_timer_init_freq(AUDIO_TIMER, AUDIO_TIMER_CHANNEL, AUDIO_SPEAKER_FREQUENCY, AUDIO_TIMER_CLOCK, TRUE);
if (MQX_OK != _usb_device_driver_install(USBCFG_DEFAULT_DEVICE_CONTROLLER)) {
printf("Driver could not be installed\n");
return;
}
/* Initialize the USB interface */
g_app_handle = USB_Class_Audio_Init(&audio_config);
if (MQX_OK != _lwevent_create(&app_event, LWEVENT_AUTO_CLEAR)) {
printf("\n_lwevent_create app_event failed.\n");
_task_block();
}
if (MQX_OK != _lwevent_wait_ticks(&app_event, USB_APP_ENUM_COMPLETE_EVENT_MASK, FALSE, 0)) {
printf("\n_lwevent_wait_ticks app_event failed.\n");
_task_block();
}
if (MQX_OK != _lwevent_clear(&app_event, USB_APP_ENUM_COMPLETE_EVENT_MASK)) {
printf("\n_lwevent_clear app_event failed.\n");
_task_block();
}
printf("Audio speaker is working ... \r\n");
/* Prepare buffer for first isochronous input */
USB_Class_Audio_Recv_Data(g_app_handle,AUDIO_ISOCHRONOUS_ENDPOINT,
audio_data_buff0, DATA_BUFF_SIZE);
_task_block();
}
/*TASK*-----------------------------------------------------------------
*
* Function Name : localPlay_init_task
* Returned Value : void
* Comments :
*
*END------------------------------------------------------------------*/
void localPlay_init_task
(
uint_32 temp
)
{
MQX_TICK_STRUCT time;
_mqx_int errcode = 0;
/* Install MQX default unexpected ISR routines */
_int_install_unexpected_isr();
if(_lwevent_create(&player_event, 0)!= MQX_OK)
{
printf("\nMake event failed");
}
/* Setup time */
printf("Setting up time......................");
time.TICKS[0] = 0L;
time.TICKS[1] = 0L;
time.HW_TICKS = 0;
_time_set_ticks(&time);
printf("[OK]\n");
/* Init GPIOs */
lwgpio_init(&btn_next, BSP_SW1, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
lwgpio_set_functionality(&btn_next,BSP_SW1_MUX_GPIO);
lwgpio_set_attribute(&btn_next, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
lwgpio_int_init(&btn_next, LWGPIO_INT_MODE_RISING);
_int_install_isr(lwgpio_int_get_vector(&btn_next), int_service_routine_btn_pause, (void *) &btn_next);
hmi_init();
sgtl5000_power_on();
hmi_install(1, int_service_routine_btn_prev);
_bsp_int_init(lwgpio_int_get_vector(&btn_next), BTN_ISR_PRIORITY, 0, TRUE);
lwgpio_init(&btn_prev, BSP_SW2, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
lwgpio_set_functionality(&btn_prev, BSP_SW2_MUX_GPIO);
lwgpio_set_attribute(&btn_prev, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#ifdef SD_DETECT_POLLING
lwgpio_int_init(&btn_prev, LWGPIO_INT_MODE_RISING);
_int_install_isr(lwgpio_int_get_vector(&btn_prev), int_service_routine_btn_stop, (void *) &btn_prev);
_bsp_int_init(lwgpio_int_get_vector(&btn_prev), BTN_ISR_PRIORITY, 0, TRUE);
#endif
hmi_install(2, int_service_routine_btn_next);
hmi_install(3, int_service_routine_vol_up);
hmi_install(4, int_service_routine_vol_down);
#if 0
/* Initialize audio codec */
printf("Initializing audio codec.............");
if (errcode != 0)
{
printf("[FAIL]\n");
printf(" Error 0x%X\n", errcode);
}
else
{
printf("[OK]\n");
}
//#else
/* Initialize audio driver and codec */
/************************************************/
if ((errcode = msi_snd_init()) != 0)
{
printf("Initializing audio driver and codec........[FAIL]\n");
printf(" Error 0x%X\n", errcode);
return;
}
else
{
printf("Initializing audio driver and codec........[OK]\n");
}
/************************************************/
#endif
/* Create tasks */
errcode = _task_create(0, SDCARD_TASK, 0);
printf("Creating SD card task................");
if (errcode == MQX_NULL_TASK_ID)
{
printf("[FAIL]\n");
printf(" Error 0x%X.\n");
}
else
{
printf("[OK]\n");
}
#ifdef SD_PLAYER_SHELL_SUPPORTED
printf("Creating shell task..................");
errcode = _task_create(0, SHELL_TASK, 0);
if (errcode == MQX_NULL_TASK_ID)
{
printf("[FAIL]\n");
printf(" Error 0x%X.\n");
}
else
{
printf("[OK]\n");
}
#endif
lwgpio_int_enable(&btn_next, TRUE);
#ifdef SD_DETECT_POLLING
lwgpio_int_enable(&btn_prev, TRUE);
#endif
_task_abort(MQX_NULL_TASK_ID);
}
void Main_Task ( uint_32 param )
{ /* Body */
USB_STATUS status = USB_OK;
uint_32 i = 0;
_usb_host_handle host_handle;
boolean ch_avail;
if (NULL == (device_registered = _mem_alloc(sizeof(*device_registered))))
{
printf("\nMemory allocation failed");
_task_block();
}
if (USB_OK != _lwevent_create(device_registered, LWEVENT_AUTO_CLEAR))
{
printf("\nlwevent create failed");
_task_block();
}
if (MQX_OK != _lwevent_create(&acm_device.acm_event, LWEVENT_AUTO_CLEAR)) {
printf("\nlwevent create failed");
_task_block();
}
if (MQX_OK != _lwevent_create(&data_device.data_event, LWEVENT_AUTO_CLEAR)) {
printf("\nlwevent create failed");
_task_block();
}
/* _usb_otg_init needs to be done with interrupts disabled */
_int_disable();
_int_install_unexpected_isr();
if (MQX_OK != _usb_host_driver_install(USBCFG_DEFAULT_HOST_CONTROLLER)) {
printf("\n Driver installation failed");
_task_block();
}
/*
** It means that we are going to act like host, so we initialize the
** host stack. This call will allow USB system to allocate memory for
** data structures, it uses later (e.g pipes etc.).
*/
status = _usb_host_init (USBCFG_DEFAULT_HOST_CONTROLLER, &host_handle);
if (status != USB_OK)
{
printf("\nUSB Host Initialization failed. STATUS: %x", status);
_int_enable();
_task_block();
}
/*
** since we are going to act as the host driver, register the driver
** information for wanted class/subclass/protocols
*/
status = _usb_host_driver_info_register (
host_handle,
DriverInfoTable
);
if (status != USB_OK) {
printf("\nDriver Registration failed. STATUS: %x", status);
_int_enable();
_task_block();
}
_int_enable();
if (NULL == (f_uart = fopen("ittyb:", (pointer) (IO_SERIAL_XON_XOFF | IO_SERIAL_TRANSLATION) ))) {
printf("\nError opening ittyb:", status);
_task_block(); /* internal error occured */
}
printf("\nInitialization passed. Plug-in CDC device to USB port first.\n");
printf("Use ttyb: as the in/out port for CDC device data.\n");
printf("This example requires that the CDC device uses HW flow.\n");
printf("If your device does not support HW flow, then set \n");
printf("CDC_EXAMPLE_USE_HW_FLOW in cdc_serial.h to zero and rebuild example project.\n");
while (1) {
uart2usb_num = usb2uart_num = 0; /* reset number of bytes in buffers */
_lwevent_wait_ticks(device_registered, 0x01, TRUE, 0);
if (NULL == (f_usb = fopen(device_name, (pointer) &usb_open_param))) {
printf("\nInternal error occured");
_task_block(); /* internal error occured */
}
while (1) {
/* due to the fact that uart driver blocks task, we will check if char is available and then we read it */
do {
if (IO_OK != ioctl(f_uart, IO_IOCTL_CHAR_AVAIL, &ch_avail)) {
printf("\nUnexpected error occured");
_task_block(); /* unexpected error occured */
}
if (ch_avail == TRUE) {
/* read data from UART */
num_done = fread(uart2usb + uart2usb_num, sizeof(uart2usb[0]), 1, f_uart); /* read max. 1 character from UART */
if (IO_ERROR == num_done)
{
printf("\nUnexpected error occured");
_task_block(); /* unexpected error occured */
}
uart2usb_num += num_done;
}
} while ( (ch_avail == TRUE) && (uart2usb_num < (sizeof(uart2usb) / sizeof(uart2usb[0]))) );
/* write them to USB */
if (uart2usb_num)
{
num_done = fwrite(uart2usb, sizeof(uart2usb[0]), uart2usb_num, f_usb);
if (IO_ERROR == num_done)
{
if (ferror(f_usb) != USBERR_NO_INTERFACE)
{
printf("\nUnexpected error occured");
_task_block(); /* unexpected error occured */
}
break; /* device was detached */
}
for (i = num_done; i < uart2usb_num; i++) /* move buffer data, remove the written ones */
uart2usb[i - num_done] = uart2usb[i];
uart2usb_num -= num_done;
}
/* read data from USB */
num_done = fread(usb2uart + usb2uart_num, 1, sizeof(uart2usb) / sizeof(uart2usb[0]) - usb2uart_num, f_usb); /* read characters from USB */
if (IO_ERROR == num_done)
{
if (ferror(f_usb) != USBERR_NO_INTERFACE)
{
printf("\nUnexpected error occured");
_task_block(); /* unexpected error occured */
}
break; /* device was detached */
}
usb2uart_num += num_done;
/* write them to UART */
if (usb2uart_num)
{
num_done = fwrite(usb2uart, sizeof(usb2uart[0]), usb2uart_num, f_uart);
if (IO_ERROR == num_done)
{
printf("\nUnexpected error occured");
_task_block(); /* unexpected error occured */
}
for (i = num_done; i < usb2uart_num; i++) /* move buffer data, remove the read ones */
usb2uart[i - num_done] = usb2uart[i];
usb2uart_num -= num_done;
}
}
}
_lwevent_destroy(&data_device.data_event);
_lwevent_destroy(&acm_device.acm_event);
} /* Endbody */
uint32_t nRF24L01_Init (nRF24L01_STRUCT_PTR nRF_PTR){
uint32_t config_parameter;
/* Invalid argument */
if (nRF_PTR == NULL) {
return MQX_INVALID_POINTER;
}
/* Open SPI driver module */
nRF_PTR->spi_ptr = fopen(nRF24L01_SPI_PORT,NULL);
if (NULL == nRF_PTR->spi_ptr) {
return MQX_INVALID_DEVICE;
}
/* Configure GPIO for nRF24L01 module */
if (FALSE == lwgpio_init(nRF_PTR->CE, nRF24L01_CE_PIN,
LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE)) {
return MQX_ERROR;
}
/* swich pin functionality (MUX) to GPIO mode */
lwgpio_set_functionality(nRF_PTR->CE, nRF24L01_CE_PIN_MUX);
nRF24L01_pin_low(nRF_PTR->CE);
if (FALSE == lwgpio_init(nRF_PTR->CSN, nRF24L01_CSN_PIN,
LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE)) {
return MQX_ERROR;
}
/* swich pin functionality (MUX) to GPIO mode */
lwgpio_set_functionality(nRF_PTR->CSN, nRF24L01_CSN_PIN_MUX);
nRF24L01_pin_high(nRF_PTR->CSN);
if (MQX_OK != _lwevent_create(&IRQ_EV_STRUCT, 0)) {
return MQX_ERROR;
}
if(MQX_OK != init_IRQ_interrupt(nRF_PTR->IRQ, irq_isr)){
return MQX_ERROR;
}
/* Configure SPI driver according nRF24L01 specifications */
/* Set a different rate */
config_parameter = nRF24L01_PORT_BAUD_RATE;
if (SPI_OK != ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_SET_BAUD,
&config_parameter)) {
return SPI_ERROR_BAUD_RATE_INVALID;
}
#if PRINT_SPI_CONFIG
/* Display baud rate */
printf ("Current baud rate ... ");
if (SPI_OK == ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_GET_BAUD,
&config_parameter)) {
printf ("%d Hz\n", config_parameter);
} else {
printf ("ERROR\n");
}
#endif
/* Set clock mode */
config_parameter = SPI_CLK_POL_PHA_MODE0;
if (SPI_OK != ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_SET_MODE,
&config_parameter)) {
return SPI_ERROR_MODE_INVALID;
}
/* Set big endian */
config_parameter = SPI_DEVICE_BIG_ENDIAN;
if (SPI_OK != ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_SET_ENDIAN,
&config_parameter)) {
return SPI_ERROR_ENDIAN_INVALID;
}
#if PRINT_SPI_CONFIG
/* Get endian */
printf ("Getting endianness ... ");
if (SPI_OK == ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_GET_ENDIAN,
&config_parameter)) {
printf ("%s\n", config_parameter == SPI_DEVICE_BIG_ENDIAN ?
"SPI_DEVICE_BIG_ENDIAN" : "SPI_DEVICE_LITTLE_ENDIAN");
} else {
printf ("ERROR\n");
}
#endif
/* Set transfer mode */
config_parameter = SPI_DEVICE_MASTER_MODE;
if (SPI_OK != ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_SET_TRANSFER_MODE,
&config_parameter)) {
return SPI_ERROR_MODE_INVALID;
}
#if PRINT_SPI_CONFIG
/* Get transfer mode */
printf ("Getting transfer mode ... ");
if (SPI_OK == ioctl (nRF_PTR->spi_ptr,
IO_IOCTL_SPI_GET_TRANSFER_MODE,
&config_parameter)) {
printf ("%s\n", config_parameter == SPI_DEVICE_MASTER_MODE ?
"SPI Master Mode" : "SPI Device Mode");
} else {
printf ("ERROR\n");
}
#endif
return MQX_OK;
}
void Mouse_Task( uint_32 param )
{
USB_STATUS status = USB_OK;
_usb_pipe_handle pipe;
TR_INIT_PARAM_STRUCT tr;
HID_COMMAND_PTR hid_com;
uchar_ptr buffer;
_usb_host_handle mouse_host_handle = (_usb_host_handle) param;
/***************************************************************************
** Allocate memory for being able to send commands to HID class driver. Note
** that USB_mem_alloc_uncached() allocates aligned buffers on cache line boundry.
** This is required if program is running with data cache on system.
***************************************************************************/
hid_com = (HID_COMMAND_PTR) USB_mem_alloc_uncached(sizeof(HID_COMMAND));
/* event for USB callback signaling */
_lwevent_create(&USB_Mouse_Event, LWEVENT_AUTO_CLEAR);
/* Allocate buffer to receive data from interrupt. It must be created on uncached heap,
** since some USB host controllers use DMA to access those buffers.
*/
buffer = USB_mem_alloc_uncached(HID_MOUSE_BUFFER_SIZE);
if (!buffer) {
printf("\nError allocating buffer!");
fflush(stdout);
exit(1);
} /* Endif */
printf("\nMQX USB HID Mouse Demo\nWaiting for USB Mouse to be attached...\n");
fflush(stdout);
/*
** Infinite loop, waiting for events requiring action
*/
for ( ; ; ) {
// Wait for insertion or removal event
_lwevent_wait_ticks(&USB_Mouse_Event, USB_Mouse_Event_CTRL, FALSE, 0);
switch ( mouse_hid_device.DEV_STATE ) {
case USB_DEVICE_IDLE:
break;
case USB_DEVICE_ATTACHED:
printf("\nMouse device attached\n");
fflush(stdout);
mouse_hid_device.DEV_STATE = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(mouse_hid_device.DEV_HANDLE, mouse_hid_device.INTF_HANDLE, (pointer)&mouse_hid_device.CLASS_INTF);
if (status != USB_OK) {
printf("\nError in _usb_hostdev_select_interface: %x", status);
fflush(stdout);
exit(1);
} /* Endif */
break;
case USB_DEVICE_SET_INTERFACE_STARTED:
break;
case USB_DEVICE_INTERFACED:
printf("Mouse interfaced, setting protocol...\n");
/* now we will set the USB Hid standard boot protocol */
mouse_hid_device.DEV_STATE = USB_DEVICE_SETTING_PROTOCOL;
hid_com->CLASS_PTR = (CLASS_CALL_STRUCT_PTR)&mouse_hid_device.CLASS_INTF;
hid_com->CALLBACK_FN = usb_host_hid_mouse_ctrl_callback;
hid_com->CALLBACK_PARAM = 0;
status = usb_class_hid_set_protocol(hid_com, USB_PROTOCOL_HID_MOUSE);
if (status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in usb_class_hid_set_protocol: %x", status);
fflush(stdout);
}
break;
case USB_DEVICE_INUSE:
pipe = _usb_hostdev_find_pipe_handle(mouse_hid_device.DEV_HANDLE, mouse_hid_device.INTF_HANDLE, USB_INTERRUPT_PIPE, USB_RECV);
if(pipe){
printf("Mouse device ready, try to move the mouse\n");
while(1){
/******************************************************************
Initiate a transfer request on the interrupt pipe
******************************************************************/
usb_hostdev_tr_init(&tr, usb_host_hid_mouse_recv_callback, NULL);
tr.RX_BUFFER = buffer;
tr.RX_LENGTH = HID_MOUSE_BUFFER_SIZE;
status = _usb_host_recv_data(mouse_host_handle, pipe, &tr);
if (status != USB_STATUS_TRANSFER_QUEUED) {
printf("\nError in _usb_host_recv_data: %x", status);
fflush(stdout);
}
/* Wait untill we get the data from keyboard. */
_lwevent_wait_ticks(&USB_Mouse_Event, USB_Mouse_Event_CTRL | USB_Mouse_Event_DATA, FALSE, 0);
/* if not detached in the meanwhile */
if(mouse_hid_device.DEV_STATE == USB_DEVICE_INUSE) {
process_mouse_buffer((uchar *)buffer);
}
else {
/* kick the outer loop again to handle the CTRL event */
_lwevent_set(&USB_Mouse_Event, USB_Mouse_Event_CTRL);
break;
}
}
}
break;
case USB_DEVICE_DETACHED:
printf("Going to idle state\n");
mouse_hid_device.DEV_STATE = USB_DEVICE_IDLE;
break;
case USB_DEVICE_OTHER:
break;
default:
printf("Unknown Mouse Device State = %d\n", mouse_hid_device.DEV_STATE);
fflush(stdout);
break;
} /* Endswitch */
} /* Endfor */
} /* Endbody */
void main_task
(
uint32_t initial_data
)
{ /* Body */
uint32_t rtc_time;
uint32_t rtc_time_default;
TIME_STRUCT mqx_time;
DATE_STRUCT date_time;
if (_lwevent_create(&lwevent,0) != MQX_OK)
{
printf("\nMake event failed");
_task_block();
}
printf ("\f RTC Demo :\n\n");
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
/* initialize time */
date_time.YEAR = RTC_TIME_INIT_TM_YEAR;
date_time.MONTH = RTC_TIME_INIT_TM_MON;
date_time.DAY = RTC_TIME_INIT_TM_MDAY;
date_time.HOUR = RTC_TIME_INIT_TM_HOUR;
date_time.MINUTE = RTC_TIME_INIT_TM_MIN;
date_time.SECOND = RTC_TIME_INIT_TM_SEC;
date_time.MILLISEC = 0;
/* Convert date time to time struct */
if ( _time_from_date(&date_time, &mqx_time) == FALSE)
{
printf("\n Cannot convert date_time ");
_task_block();
}
/* Convert rtc time to TIME_STRUCT */
rtc_time = mqx_time.SECONDS;
printf(" Set RTC time is: %s %s %3d %.2d:%.2d:%.2d %d\n",
_days_abbrev[date_time.WDAY],
_months_abbrev[date_time.MONTH - 1],
date_time.DAY,
date_time.HOUR,
date_time.MINUTE,
date_time.SECOND,
date_time.YEAR);
/* Set MQX time*/
_time_set(&mqx_time);
/* Set RTC time*/
_rtc_set_time(rtc_time);
printf("\n MQX time: %d SECONDS, %d MILISECOND ", mqx_time.SECONDS, mqx_time.MILLISECONDS);
/*
* set-up alarm
*/
/* install callback */
_rtc_callback_reg((INT_ISR_FPTR)rtc_callback, (void*)NULL);
/* Set alarm to maximum time to avoid unexpected interrupt in next running */
_rtc_set_alarm(MAXIMUM_SECONDS_IN_TIME,(uint32_t)0);
_lwevent_clear(&lwevent,LWE_ALARM);
/* Get current time */
_rtc_get_time(&rtc_time);
/* setup alarm in next 10 seconds & period 4 seconds*/
rtc_time += (uint32_t)ALARM_NEXT_TIME; /* Alarm occurs in next 10 seconds */
printf("\n Setup to occur alarm in next %d seconds & with period: %d seconds",ALARM_NEXT_TIME, ALARM_PERIOD);
_rtc_set_alarm(rtc_time,(uint32_t)ALARM_PERIOD);
printf("\n Wait %d seconds ....",ALARM_NEXT_TIME);
/* Wait to clear LWE_ALARM event */
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM! ALARM! ALARM!\n");
/* Print current time */
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf("\n Wait next alarm in %d seconds....",ALARM_PERIOD);
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM! ALARM! ALARM!\n");
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf ("\nClearing RTC:\n");
_rtc_set_time(0);
_rtc_get_time(&rtc_time_default);
print_rtc_time(rtc_time_default);
/* Wait 2 seconds after resynchronize rtc time with mqx time*/
do{
_rtc_get_time(&rtc_time);
} while ((rtc_time - rtc_time_default) < 2);
/* Get current time & display on terminal */
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
printf ("Synchronize RTC to MQX time again:\n");
_time_get(&mqx_time);
rtc_time = mqx_time.SECONDS;
_rtc_set_time(rtc_time);
_rtc_get_time(&rtc_time);
print_rtc_time(rtc_time);
#if PSP_HAS_IRTC == 1
irtc_test();
#endif /* PSP_HAS_IRTC == 1 */
printf ("Finish, press/hold reset to repeat.\n");
_task_block() ;
} /* Endbody */
void main_task
(
uint_32 initial_data
)
{
DATE_STRUCT time_rtc;
TIME_STRUCT time_mqx;
if (_lwevent_create(&lwevent,0) != MQX_OK)
{
printf("\nMake event failed");
_task_block();
}
printf ("\fStart time (MQX synchronized to RTC time during bsp init):\n\n");
/* initialize time */
time_rtc.YEAR = 2010;
time_rtc.MONTH = 10;
time_rtc.DAY = 15;
time_rtc.HOUR = 10;
time_rtc.MINUTE = 8;
time_rtc.SECOND = 0;
time_rtc.MILLISEC = 0;
_time_from_date (&time_rtc, &time_mqx);
_time_set( &time_mqx);
if( _rtc_sync_with_mqx(FALSE) != MQX_OK )
{
printf("\nError synchronize time!\n");
_task_block();
}
_time_get (&time_mqx);
_time_to_date (&time_mqx, &time_rtc);
print_mqx_time(&time_rtc, &time_mqx);
print_current_time();
/* except MPC5125 */
#ifndef BSP_TWRMPC5125
install_interrupt();
/* enable stopwatch */
install_stopwatch();
/* enable alarm */
install_alarm();
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("\nALARM!\n");
print_current_time();
/* end of alarm */
printf ("Continue wasting time (2 minutes max) ...\n");
_lwevent_wait_ticks(&lwevent,LWE_STOPWATCH,FALSE,0);
_lwevent_clear(&lwevent,LWE_STOPWATCH);
printf ("\nSTOPWATCH!\n");
print_current_time();
printf ("\nClearing RTC:\n");
_rtc_init (RTC_INIT_FLAG_CLEAR | RTC_INIT_FLAG_ENABLE);
print_current_time();
install_alarm();
_lwevent_wait_ticks(&lwevent,LWE_ALARM,FALSE,0);
_lwevent_clear(&lwevent,LWE_ALARM);
printf ("ALARM!\n");
print_current_time();
#else /* BSP_TWRMPC5125 */
printf ("Waste 10 seconds here\n");
_time_delay(10000);
_rtc_get_time_mqxd (&time_rtc);
print_rtc_time(&time_rtc, &time_mqx);
#endif
printf ("Synchronize RTC to MQX time again:\n");
_rtc_sync_with_mqx (FALSE);
_rtc_get_time_mqxd (&time_rtc);
_time_from_date (&time_rtc, &time_mqx);
print_rtc_time(&time_rtc, &time_mqx);
#if PSP_HAS_IRTC == 1
irtc_test();
#endif /* PSP_HAS_IRTC == 1 */
/* Test tamper event functionality on MCF51EMxx device */
#if PSP_MQX_CPU_IS_MCF51EM
test_tamper();
#else
printf ("Finish, press/hold reset to repeat.\n");
_task_block() ;
#endif
}
void main_task
(
uint32_t initial_data
)
{
BSP_CLOCK_CONFIGURATION clock_configuration;
printf("\n***********************************************************\n");
printf(" MQX frequency change demo\n");
printf("***********************************************************\n");
/* Create global event */
if (_lwevent_create(&app_event, LWEVENT_AUTO_CLEAR) != MQX_OK)
{
printf("\nCreating app_event failed.\n");
_task_block();
}
printf("\n*********** DEFAULT CLOCK CONFIGURATION **********\n");
/* Get and print active clock configuration */
clock_configuration = _lpm_get_clock_configuration();
display_clock_values(clock_configuration);
printf("\nPress button on the board to loop over frequency modes.\n");
while (1)
{
/* wait for button press */
wait_for_event();
printf("\n*************** BSP_CLOCK_CONFIGURATION_0 **************\n");
/* Switch clock configuration */
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_0))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Get active clock configuration */
clock_configuration = _lpm_get_clock_configuration();
/* Display new clock settings */
display_clock_values(clock_configuration);
/* wait for button press */
wait_for_event();
printf("\n*************** BSP_CLOCK_CONFIGURATION_1 **************\n");
/* Switch clock configuration */
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_1))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Get active clock configuration */
clock_configuration = _lpm_get_clock_configuration();
/* Display new clock settings */
display_clock_values(clock_configuration);
/* wait for button press */
wait_for_event();
printf("\n*************** BSP_CLOCK_CONFIGURATION_2 **************\n");
/* Switch clock configuration */
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_2))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Get active clock configuration */
clock_configuration = _lpm_get_clock_configuration();
/* Display new clock settings */
display_clock_values(clock_configuration);
}
}
void main_task
(
uint_32 initial_data
)
{
LPM_OPERATION_MODE power_mode;
/* Initialize switches */
button_led_init();
/* Install interrupt for RTC alarm */
install_rtc_interrupt();
/* Create global event */
if (_lwevent_create(&app_event, 0) != MQX_OK)
{
printf("\nCreating app_event failed.\n");
_task_block();
}
printf("\nMQX Low Power Modes Demo\n");
while (1)
{
/* Find out current mode setting */
power_mode = _lpm_get_operation_mode();
printf("\n******************************************************************************\n");
printf("**************** Current Mode : %s ***********************\n", predefined_power_modes_names[power_mode]);
printf("******************************************************************************\n");
display_operation_mode_setting(power_mode);
/* Wait for button press */
printf ("Press button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
power_mode = LPM_OPERATION_MODE_WAIT;
printf("\n******************************************************************************\n");
printf("**************** Current Mode : %s **********************\n", predefined_power_modes_names[power_mode]);
printf("******************************************************************************\n");
display_operation_mode_setting(power_mode);
printf(
"Info: WAIT mode is mapped on Kinets VLPR mode by default.\n"
" It requires 2 MHz clock and bypassed pll.\n"
" Core continues the execution after entering the mode.\n");
/* The LPM_OPERATION_MODE_WAIT is mapped on LPM_CPU_POWER_MODE_KINETIS_VLPR by default,
this mode requires 2 MHz, bypassed PLL clock setting. Change clocks to appropriate mode */
printf("\nChanging frequency to 2 MHz.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_2MHZ))
{
printf("Cannot change clock configuration");
_task_block();
}
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", predefined_power_modes_names[power_mode]);
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_WAIT) == 0 ? "OK" : "ERROR");
/* Wait for button press */
printf ("\nPress button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed.\n");
/* Return to RUN mode */
printf ("\nSetting operation mode back to %s ... ", predefined_power_modes_names[LPM_OPERATION_MODE_RUN]);
printf ("%s\n", _lpm_set_operation_mode (LPM_OPERATION_MODE_RUN) == 0 ? "OK" : "ERROR");
/* Return default clock configuration */
printf("\nChanging frequency back to the default one.\n");
if (CM_ERR_OK != _lpm_set_clock_configuration(BSP_CLOCK_CONFIGURATION_DEFAULT))
{
printf("Cannot change clock configuration");
_task_block();
}
printf("\nMoving to next operation mode.\n");
power_mode = LPM_OPERATION_MODE_SLEEP;
printf("\n******************************************************************************\n");
printf("**************** Current Mode : %s *********************\n", predefined_power_modes_names[power_mode]);
printf("******************************************************************************\n");
display_operation_mode_setting(power_mode);
printf(
"Info: SLEEP mode is mapped on Kinetis WAIT mode by default. Core is inactive\n"
" in this mode, reacting only to interrupts.\n"
" The LPM_CPU_POWER_MODE_FLAG_SLEEP_ON_EXIT is set, therefore core goes\n"
" to sleep again after any isr finishes. The core will stay awake after\n"
" call to _lpm_wakeup_core() from RTC or serial line interrupt.\n");
/* Wake up in 10 seconds */
set_rtc_alarm(10);
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... ", predefined_power_modes_names[power_mode]);
printf ("%s\n", _lpm_set_operation_mode (power_mode) == 0 ? "OK" : "ERROR");
if (LWEVENT_WAIT_TIMEOUT == _lwevent_wait_ticks (&app_event, RTC_EVENT_MASK, FALSE, 1))
{
printf("\nCore woke up by serial interrupt. Waiting for RTC alarm ... ");
_lwevent_wait_ticks (&app_event, RTC_EVENT_MASK, FALSE, 0);
printf("OK\n");
}
else
{
printf("\nCore woke up by RTC interrupt.\n");
}
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
/* Wait for button press */
printf ("\nPress button to move to next operation mode.\n");
_lwevent_wait_ticks (&app_event, SW_EVENT_MASK, FALSE, 0);
_lwevent_clear (&app_event, ALL_EVENTS_MASK);
printf("\nButton pressed. Moving to next operation mode.\n");
power_mode = LPM_OPERATION_MODE_STOP;
printf("\n******************************************************************************\n");
printf("**************** Current Mode : %s **********************\n", predefined_power_modes_names[power_mode]);
printf("******************************************************************************\n");
display_operation_mode_setting(power_mode);
printf(
"Info: STOP mode is mapped to Kinets LLS mode by default.\n"
" Core and most peripherals are inactive in this mode, reacting only to\n"
" specified wake up events. The events can be changed in BSP (init_lpm.c).\n"
" Serial line is turned off in this mode. The core will wake up from\n"
" RTC interrupt.\n");
/* Wake up in 10 seconds */
set_rtc_alarm(10);
/* Change the operation mode */
printf ("\nSetting operation mode to %s ... \n", predefined_power_modes_names[power_mode]);
_lpm_set_operation_mode (power_mode);
/**************************************************************************************************/
/* SCI HW MODULE IS DISABLED AT THIS POINT - SERIAL DRIVER MUST NOT BE USED UNTIL MODE IS CHANGED */
/**************************************************************************************************/
/* Return to RUN mode */
_lpm_set_operation_mode (LPM_OPERATION_MODE_RUN);
printf("\nCore is awake. Moved to next operation mode.\n");
}
}
