boolean HVAC_WaitParameters(int_32 timeout) { boolean catched; #if DEMOCFG_ENABLE_SWITCH_TASK // switch-sensing task is running, we can simply wait for the event or timeout _lwevent_wait_ticks(&HVAC_Params.Event, HVAC_PARAMS_CHANGED, TRUE, timeout); #else // poll the keys frequenly until the event or timeout expires uint_32 poll_wait = BSP_ALARM_FREQUENCY/20; // 50ms int_32 elapsed; MQX_TICK_STRUCT tickstart, ticknow; _time_get_elapsed_ticks(&tickstart); do { Switch_Poll(); _lwevent_wait_ticks(&HVAC_Params.Event, HVAC_PARAMS_CHANGED, TRUE, poll_wait); _time_get_elapsed_ticks(&ticknow); elapsed = _time_diff_ticks_int32 (&ticknow, &tickstart, NULL); } while (elapsed < timeout); #endif catched = (HVAC_Params.Event.VALUE & HVAC_PARAMS_CHANGED) != 0; _lwevent_clear(&HVAC_Params.Event, HVAC_PARAMS_CHANGED); return catched; }
void service_task ( uint_32 initial_data ) { _task_id second_task_id; _int_install_unexpected_isr(); /* create lwevent group */ if (_usr_lwevent_create(&lwevent,0) != MQX_OK) { printf("\nMake event failed"); _task_block(); } /* Create the ISR task */ second_task_id = _usr_task_create(0, ISR_TASK, 0); if (second_task_id == MQX_NULL_TASK_ID) { printf("Could not create simulated_ISR_task \n"); _task_block(); } while (TRUE) { if (_lwevent_wait_ticks(&lwevent,1,TRUE,0) != MQX_OK) { printf("\nEvent Wait failed"); _task_block(); } if (_lwevent_clear(&lwevent,0x01) != MQX_OK) { printf("\nEvent Clear failed"); _task_block(); } printf(" Tick \n"); } }
int unit_test_pm2p5() { int ret = 0; int i = READ_ADC_TIMES; int pm_adc[READ_ADC_TIMES] = {0}; int tmp; int32_t microsec; int overflow; MQX_TICK_STRUCT start_tick,cur_tick,diff_tick; /* for test led clk do { _time_delay(500); printf(".\n"); }while(1); */ #if (ADC_INPUT_CH == 3) adcc_init(0); mux_74hc595_clear_bit(BSP_74HC595_0, BSP_74HC595_SPI_S0); mux_74hc595_set_bit(BSP_74HC595_0, BSP_74HC595_SPI_S1); //mux_74hc595_clear_bit(BSP_74HC595_0, BSP_74HC595_SPI_S1); //mux_74hc595_set_bit(BSP_74HC595_0, BSP_74HC595_SPI_S0); do { _time_get_elapsed_ticks_fast(&start_tick); tmp = adc_measure_pm2p5(); _time_get_elapsed_ticks_fast(&cur_tick); overflow = 0; microsec = _time_diff_microseconds(&cur_tick,&start_tick,&overflow); printf("read batt = %d, microsecs %d ,overflow %d\n",tmp,microsec,overflow); } while (1); #else pm2p5_sample_start(); #ifdef ALWAYS_SAMPLING do{ if(sample_value != 0) printf("read pm2.5 = %d\n",sample_value); } while(1); #else do { _lwevent_wait_ticks(&sample_event, 1, FALSE, 0); _lwevent_clear(&sample_event, 1); // sampling tmp = adc_measure_pm2p5(); pm_adc[READ_ADC_TIMES - i] = tmp; } while (i--); printf("current PM2.5 density = %f mg/m3\n",lookup_pm25table(pm_adc,READ_ADC_TIMES)); #endif sample_timer_deinit(); #endif return 0; }
/*TASK*----------------------------------------------------------- * * Task Name : Tx_Task * Comments : * * *END*-----------------------------------------------------------*/ void Tx_Task(uint32_t parameter) { /* Body */ unsigned char data = 0; uint32_t result; unsigned char string[] = { 0xa, 0xb, 0xe, 0xc, 0xe, 0xd, 0xa, 0x0 }; /* Init, Active, Install ISR */ if(FLEXCAN_OK != FLEXCAN_Tx_Init()) printf("FLEXCAN tx mailbox initialization. result: 0x%lx \r\n", result); /* Let Rx Task start to initialize */ // _time_delay(1000); while(1) { /* Send Tx Msg 1 sec period message */ //_time_delay(1000); // data++; /* Block forever until it is time to send an event */ if (_lwevent_wait_ticks(&event, 1 << TX_mailbox_num, FALSE, 0) != MQX_OK) { printf("Event Wait failed \r\n"); } /* (id, dlc, pdata, FLEXCAN_TX_XTD_FRAME) */ result = FLEXCAN_Tx_message(CAN_DEVICE, TX_mailbox_num, TX_identifier, format, data_len_code, &data); if(result != FLEXCAN_OK) printf("\nTransmit error. Error Code: 0x%lx", result); else printf("Data transmit: %d \r\n", data); /* result = FLEXCAN_Tx_mailbox(CAN_DEVICE, TX_mailbox_num, &data); if(result != FLEXCAN_OK) printf("\nTransmit error. Error Code: 0x%lx", result); else printf("\nData transmit: %d", data);*/ /* string[7] = data; result = FLEXCAN_Update_message(CAN_DEVICE, string, 8, format, TX_remote_mailbox_num); printf("\nFLEXCAN tx update message. result: 0x%lx", result); */ } } /* EndBody */
void wait_for_event (void) { _mqx_uint app_event_value; /* Wait for button press */ _lwevent_wait_ticks (&app_event, (SW_EVENT_MASK), FALSE, 0); /* Copy event masks into temporary variable */ app_event_value = _lwevent_get_signalled(); /* If button pressed or switch expires, moving to next clock configuration */ if (app_event_value & SW_EVENT_MASK) { printf("\nButton pressed. Moving to next clock configuration.\n"); } }
uint32_t OS_Event_wait(os_event_handle handle, uint32_t bitmask, uint32_t flag, uint32_t timeout) { LWEVENT_STRUCT *event = (LWEVENT_STRUCT*)handle; uint32_t ret; ret = _lwevent_wait_ticks(event, bitmask, flag, timeout * _time_get_ticks_per_sec() / 1000); //printf("os 0x%x\n", ret); if (LWEVENT_WAIT_TIMEOUT == ret) { return (uint32_t)OS_EVENT_TIMEOUT; } else if(MQX_OK == ret) { return (uint32_t)OS_EVENT_OK; } return (uint32_t)OS_EVENT_ERROR; }
/************************************************************************** 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; }
void pcm_flush_task(uint_32 para) { while(1) { _lwevent_wait_ticks(&player_event, PLAYER_EVENT_MSK_SONG_RESUME, FALSE, 0); if (_lwsem_wait(&pcm_decoded_sem) != MQX_OK) { LOCALPLAY_LOG("\n pcm_flush : Error - Unable to wait pcm_decoded_sem."); } else{ if(gPcmFlushTaskFinish == 1){ break; } } #if 0 if (g_device_ptr == NULL) { LOCALPLAY_LOG( "The audio device pointer is NULL. audio_fulsh_task exits. \n"); break; } #endif if(g_audio_buf_ptr != NULL) put_file_data(g_audio_buf_ptr, g_buf_bytes_to_flush, NULL); if (_lwsem_post(&pcm_flush_sem) != MQX_OK) { //LOCALPLAY_LOG("\n pcm_flush : Error - Unable to post pcmFlush_sem."); } } //LOCALPLAY_LOG("__guoyifang__: pcm_flush_task destroyed.\n"); printf("pcm_flush_task exit.\n"); gPcmFlushTaskFinish = 0; //_task_block(); //wait for being destroyed }
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); } } }
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; } } }
/*! * \brief MQX API handler for usermode - part of wrapper around standard MQX API * which require privilege mode. * * \param[in] api_no API number - number of wrapped function * \param[in] params generic parameter - direct use with called MQX API fn * * \return uint32_t return of called function */ uint32_t _mqx_api_call_handler ( // [IN] API number - number of wrapped function MQX_API_NUMBER_ENUM api_no, // [IN] generic parameter - direct use with called MQX API fn MQX_API_CALL_PARAMS_PTR params ) { int32_t res = -1; uint32_t param0 = params->param0; uint32_t param1 = params->param1; uint32_t param2 = params->param2; uint32_t param3 = params->param3; uint32_t param4 = params->param4; switch (api_no) { // _lwsem case MQX_API_LWSEM_POLL: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) res = (uint32_t)_lwsem_poll((LWSEM_STRUCT_PTR)param0); break; case MQX_API_LWSEM_POST: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) res = _lwsem_post((LWSEM_STRUCT_PTR)param0); break; case MQX_API_LWSEM_WAIT: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) res = _lwsem_wait((LWSEM_STRUCT_PTR)param0); break; case MQX_API_LWSEM_CREATE: res = _lwsem_create_internal((LWSEM_STRUCT_PTR)param0, (_mqx_int)param1, (bool)param2, TRUE); break; #if MQX_HAS_TICK case MQX_API_LWSEM_WAIT_FOR: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) res = _lwsem_wait_for((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1); break; case MQX_API_LWSEM_WAIT_TICKS: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) res = _lwsem_wait_ticks((LWSEM_STRUCT_PTR)param0, (_mqx_uint)param1); break; case MQX_API_LWSEM_WAIT_UNTIL: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) res = _lwsem_wait_until((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1); break; case MQX_API_LWSEM_DESTROY: if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) { res = _lwsem_destroy_internal((LWSEM_STRUCT_PTR)param0, TRUE); } break; #endif // MQX_HAS_TICK // _lwevent #if MQX_USE_LWEVENTS case MQX_API_LWEVENT_CLEAR: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) res = _lwevent_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1); break; case MQX_API_LWEVENT_SET: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) res = _lwevent_set((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1); break; case MQX_API_LWEVENT_SET_AUTO_CLEAR: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) res = _lwevent_set_auto_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1); break; case MQX_API_LWEVENT_WAIT_FOR: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \ (!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) { res = _lwevent_wait_for((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3); } break; case MQX_API_LWEVENT_WAIT_FOR_TICKS: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) { res = _lwevent_wait_ticks((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (_mqx_uint)param3); } break; case MQX_API_LWEVENT_WAIT_UNTIL: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \ (!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) { res = _lwevent_wait_until((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3); } break; case MQX_API_LWEVENT_GET_SIGNALLED: res = _lwevent_get_signalled(); break; case MQX_API_LWEVENT_CREATE: res = _lwevent_create_internal((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, TRUE); break; case MQX_API_LWEVENT_DESTROY: if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) { res = _lwevent_destroy_internal((LWEVENT_STRUCT_PTR)param0, TRUE); } break; #endif #if MQX_USE_LWMSGQ case MQX_API_LWMSGQ_INIT: res = _lwmsgq_init_internal((void *)param0, (_mqx_uint)param1, (_mqx_uint)param2, TRUE); break; case MQX_API_LWMSGQ_RECEIVE: if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \ _psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW) && \ (!param4 || _psp_mem_check_access(param4, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) res = _lwmsgq_receive((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2, (_mqx_uint)param3, (MQX_TICK_STRUCT_PTR)param4); break; case MQX_API_LWMSGQ_SEND: if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \ _psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW)) res = _lwmsgq_send((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2); break; #endif // MQX_USE_LWMSGQ case MQX_API_TASK_CREATE: res = _task_create_internal((_processor_number)param0, (_mqx_uint)param1, (uint32_t)param2, TRUE); break; case MQX_API_TASK_DESTROY: res = _task_destroy_internal((_task_id)param0, TRUE); break; case MQX_API_TASK_ABORT: res = _task_abort_internal((_task_id)param0, TRUE); break; case MQX_API_TASK_READY: _task_ready((void *)param0); res = MQX_OK; // irelevant, function is without return value break; case MQX_API_TASK_SET_ERROR: res = _task_set_error((_mqx_uint)param0); break; case MQX_API_TASK_GET_TD: res = (uint32_t)_task_get_td((_task_id)param0); break; #if MQX_USE_LWMEM case MQX_API_LWMEM_ALLOC: res = (uint32_t)_usr_lwmem_alloc_internal((_mem_size)param0); break; case MQX_API_LWMEM_ALLOC_FROM: if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \ _psp_mem_check_access((uint32_t)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_END_PTR) - (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), MPU_UM_RW)) res = (uint32_t)_lwmem_alloc_from((_lwmem_pool_id)param0, (_mem_size)param1); else res = 0; // NULL, allocation failed break; case MQX_API_LWMEM_FREE: if (_psp_mem_check_access(param0, 4, MPU_UM_RW)) res = _lwmem_free((void *)param0); break; case MQX_API_LWMEM_CREATE_POOL:\ if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \ _psp_mem_check_access(param1, param2, MPU_UM_RW)) res = (uint32_t)_lwmem_create_pool((LWMEM_POOL_STRUCT_PTR)param0, (void *)param1, (_mem_size)param2); break; case MQX_API_LWMEM_REALLOC: if (_psp_mem_check_access(param0, 4, MPU_UM_RW)) res = (uint32_t)_lwmem_realloc((void *)param0,(_mem_size)param1); break; #endif // MQX_USE_LWMEM // _time case MQX_API_TIME_DELAY: _time_delay(param0); res = MQX_OK; // irelevant, function is without return value break; #if MQX_HAS_TICK case MQX_API_TIME_DELAY_TICKS: _time_delay_ticks(param0); res = MQX_OK; // irelevant, function is without return value break; case MQX_API_TIME_GET_ELAPSED_TICKS: if (_psp_mem_check_access(param0, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)) { _time_get_elapsed_ticks((MQX_TICK_STRUCT_PTR)param0); res = MQX_OK; // irelevant, function is without return value } else { _task_set_error(MQX_ACCESS_ERROR); } break; #endif // MQX_HAS_TICK default: while (1); } return res; }
/*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 ) { /* 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 */
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(); }
/*! * \brief This function receives a message from the specified endpoint if one is available. The data is NOT copied into the user-app. buffer. * * This is the "zero-copy receive" version of the MCC receive function. No data is copied. * Only the pointer to the data is returned. This version is fast, but it requires the user to manage * buffer allocation. Specifically, the user must decide when a buffer is no longer in use and * make the appropriate API call to free it. * * \param[in] endpoint Pointer to the receiving endpoint to receive from. * \param[out] buffer_p Pointer to the MCC buffer of the shared memory where the received data is stored. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of valid bytes in the buffer. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv_copy * \see MCC_ENDPOINT */ int mcc_recv_nocopy(MCC_ENDPOINT *endpoint, void **buffer_p, MCC_MEM_SIZE *recv_size, unsigned int timeout_us) { MCC_RECEIVE_LIST *list; int return_value; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; unsigned int lwevent_index = endpoint->port / MCC_MQX_LWEVENT_GROUP_SIZE; unsigned int lwevent_group_index = endpoint->port % MCC_MQX_LWEVENT_GROUP_SIZE; MQX_TICK_STRUCT tick_time; #endif /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* The endpoint is not valid */ if(list == null) { return MCC_ERR_ENDPOINT; } if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_TIMEOUT; } /* Blocking call */ else { #if (MCC_OS_USED == MCC_MQX) if(timeout_us == 0xFFFFFFFF) { _lwevent_wait_ticks(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, 0); } /* timeout_us > 0 */ else { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); _lwevent_wait_until(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, &tick_time); } #endif MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); } } /* Clear event bit specified for the particular endpoint in the lwevent_buffer_queued lwevent group */ _lwevent_clear(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } /* Get the message pointer from the head of the receive buffer list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); *buffer_p = (void*)&list->head->data; MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data_len, sizeof(MCC_MEM_SIZE)); *recv_size = (MCC_MEM_SIZE)(list->head->data_len); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the endpoint list */ mcc_dequeue_buffer(list); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }
uint_32 MACNET_send ( ENET_CONTEXT_STRUCT_PTR enet_ptr, /* [IN] the Ethernet state structure */ PCB_PTR packet, /* [IN] the packet to send */ uint_32 size, /* [IN] total size of the packet */ uint_32 frags, /* [IN] total fragments in the packet */ uint_32 flags /* [IN] optional flags, zero = default */ ) { MACNET_CONTEXT_STRUCT_PTR macnet_context_ptr = (MACNET_CONTEXT_STRUCT_PTR) enet_ptr->MAC_CONTEXT_PTR; ENET_MemMapPtr macnet_ptr= macnet_context_ptr->MACNET_ADDRESS; PCB_FRAGMENT_PTR frag_ptr; VENET_BD_STRUCT_PTR tx_bd_ptr; uint_32 len,totlen,frag; uchar_ptr txmem; boolean aligned; uint_32 err = ENET_OK; #if ENETCFG_SUPPORT_PTP MACNET_PTP_DATA tmp_tx_time; boolean wait_for_ts=FALSE; #endif if (macnet_ptr == NULL) return ENETERR_INVALID_DEVICE; MACNET_int_disable(); /* ** Make sure there aren't too many fragments. (We really should check ** this every time through the previous loop, but it is extremely ** unlikely that the fragment counter overflowed -- there would have ** to be over 2^32 fragments.) */ if (macnet_context_ptr->AvailableTxBDs < 1) { ENET_INC_STATS(COMMON.ST_TX_MISSED); err = ENETERR_SEND_FULL; goto END; } #if BSPCFG_ENABLE_ENET_HISTOGRAM { uint_32 index = size>> ENET_HISTOGRAM_SHIFT; if (index < ENET_HISTOGRAM_ENTRIES) { ENET_INC_STATS(TX_HISTOGRAM[index]); } } #endif aligned = TRUE; for (frag_ptr = packet->FRAG; frag_ptr->LENGTH; frag_ptr++) { if (MACNET_TX_ALIGN((uint_32)frag_ptr->FRAGMENT)!= (uint_32)frag_ptr->FRAGMENT) aligned = FALSE; } if (aligned) { ENET_INC_STATS(TX_ALL_ALIGNED); } /* ** Enqueue the packet on the transmit ring. Don't set the ready ** bit in the first descriptor until all descriptors are enqueued. */ tx_bd_ptr = &macnet_context_ptr->MACNET_TX_RING_PTR[macnet_context_ptr->NextTxBD]; frag_ptr = packet->FRAG; frag = (uint_32) frag_ptr->FRAGMENT; if (frags > 1 || (MACNET_TX_ALIGN(frag)!= frag)) { // Packet is fragmented and/or it is misaligned, needs to be copied txmem = NULL; // See if it fits in a small buffer if (size <= MACNET_SMALL_PACKET_SIZE) { // it does txmem = ENET_Dequeue_Buffer((pointer *) &macnet_context_ptr->SMALL_BUFFERS); } // If it didn't fit, or the small alloc failed, try for a large buffer if (txmem) { // signal buffer is to be deallocated. macnet_context_ptr->FREE_TX_SMALL |= (1<<macnet_context_ptr->NextTxBD); ENET_INC_STATS(ST_TX_COPY_SMALL); } else { if (size <= macnet_context_ptr->AlignedTxBufferSize) { txmem = ENET_Dequeue_Buffer((pointer *) &macnet_context_ptr->TX_BUFFERS); } if (txmem) { // signal buffer is to be deallocated. macnet_context_ptr->FREE_TX |= (1<<macnet_context_ptr->NextTxBD); } else { ENET_INC_STATS(COMMON.ST_TX_MISSED); err = ENETERR_NO_TX_BUFFER; goto END; } } totlen = 0; for (len = frag_ptr->LENGTH; len != 0; len = frag_ptr->LENGTH) { _mem_copy(frag_ptr->FRAGMENT, txmem + totlen, len); totlen += len; frag_ptr++; } } else { // Packet is not fragmented and it is not misaligned totlen = frag_ptr->LENGTH; txmem = frag_ptr->FRAGMENT; ENET_INC_STATS(TX_ALIGNED); } // Flush the buffer from cache _DCACHE_FLUSH_MBYTES(txmem, totlen); // Invalidate the bd from cache _DCACHE_INVALIDATE_MBYTES((pointer)tx_bd_ptr, sizeof(ENET_BD_STRUCT)); // set up the tx bd tx_bd_ptr->CONTROL &= HOST_TO_BE_SHORT_CONST(ENET_BD_ETHER_TX_WRAP); tx_bd_ptr->BUFFER = (uchar_ptr)HOST_TO_BE_LONG((uint_32)txmem); tx_bd_ptr->LENGTH = HOST_TO_BE_SHORT(totlen); tx_bd_ptr->CONTROL |= HOST_TO_BE_SHORT_CONST(ENET_BD_ETHER_TX_LAST | ENET_BD_ETHER_TX_SEND_CRC | ENET_BD_ETHER_TX_READY); tx_bd_ptr->CONTROL_EXT0 |= HOST_TO_BE_SHORT_CONST(ENET_BD_EXT0_ETHER_TX_GENERATE_INTR); #if ENETCFG_SUPPORT_PTP if (macnet_context_ptr->PTP_PRIV->PTIMER_PRESENT) { /* PTP over Ethernet frames: Check the PTPv2 over Ethernet type (identifier) */ if((totlen > 44) && (*(uint_16 *)(txmem + MACNET_PTP_ETHER_PKT_TYPE_OFFS) == HOST_TO_BE_SHORT_CONST(MACNET_PACKET_TYPE_IEEE_802_3))) { /* Allow interrupt and timestamp generation */ tx_bd_ptr->CONTROL_EXT0 |= HOST_TO_BE_SHORT_CONST(ENET_BD_EXT0_ETHER_TX_TIMESTAMP); tmp_tx_time.KEY = HOST_TO_BE_SHORT(*((uint_16 *)(txmem + MACNET_PTP_ETHER_SEQ_ID_OFFS))); for(len=0;len<MACNET_PTP_CLOCKID_SIZE;len++) tmp_tx_time.CLOCKID[len] = *((uint_8 *)(txmem + MACNET_PTP_ETHER_CLOCKID + len)); wait_for_ts = TRUE; } /* PTP over UDP: Check if port is 319 for PTP Event, and check for UDP */ else if((totlen > 44) && (*(uchar_ptr)(txmem + MACNET_PTP_UDP_PKT_TYPE_OFFS) == MACNET_PACKET_TYPE_UDP) && (*(uint_16 *)(txmem + MACNET_PTP_UDP_PORT_OFFS) == HOST_TO_BE_SHORT_CONST(MACNET_PTP_EVNT_PORT))) { tx_bd_ptr->CONTROL_EXT0 |= HOST_TO_BE_SHORT_CONST(ENET_BD_EXT0_ETHER_TX_TIMESTAMP); tmp_tx_time.KEY = HOST_TO_BE_SHORT(*((uint_16 *)(txmem + MACNET_PTP_UDP_SEQ_ID_OFFS))); for(len=0;len<MACNET_PTP_CLOCKID_SIZE;len++) tmp_tx_time.CLOCKID[len] = *((uint_8 *)(txmem + MACNET_PTP_UDP_CLOCKID + len)); wait_for_ts = TRUE; } } #endif /* ENETCFG_SUPPORT_PTP */ // Flush the tx bd from cache _DCACHE_FLUSH_MBYTES((pointer)tx_bd_ptr, sizeof(ENET_BD_STRUCT)); macnet_context_ptr->TxPCBS_PTR[macnet_context_ptr->NextTxBD] = packet; macnet_context_ptr->AvailableTxBDs--; BD_INC(macnet_context_ptr->NextTxBD,macnet_context_ptr->NumTxBDs); macnet_ptr->TDAR = ENET_TDAR_TDAR_MASK; END: MACNET_int_enable(); #if ENETCFG_SUPPORT_PTP if(wait_for_ts) { /* Wait for the interrupt */ _lwevent_wait_ticks(&macnet_context_ptr->PTP_PRIV->LWEVENT_PTP, MACNET_PTP_LWEVENT_TX_TS_INTR, FALSE, (uint_32)NULL); /* Clear the event */ _lwevent_clear(&macnet_context_ptr->PTP_PRIV->LWEVENT_PTP, MACNET_PTP_LWEVENT_TX_TS_INTR); /* Clear the TS flag from the BD */ tx_bd_ptr->CONTROL_EXT0 &= HOST_TO_BE_SHORT_CONST(~ENET_BD_EXT0_ETHER_TX_TIMESTAMP); tmp_tx_time.TS_TIME.NSEC = macnet_context_ptr->PTP_PRIV->TXSTAMP.NSEC; tmp_tx_time.TS_TIME.SEC = macnet_context_ptr->PTP_PRIV->TXSTAMP.SEC; MACNET_ptp_insert(&(macnet_context_ptr->PTP_PRIV->TX_TIME), &tmp_tx_time); wait_for_ts = FALSE; } #endif /* ENETCFG_SUPPORT_PTP */ return err; }
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 ( 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 ) { /* 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 local_player_task(uint_32 para) { _mqx_int return_code, res; my_audio_format_t format; FILE_PTR stream_ptr = NULL, stream_ptr1 = NULL; //device_ptr = NULL, uint_32 mclk_freq, fs_freq, bit_width = 0; I2S_STATISTICS_STRUCT stats; int32_t numberOfSamples =0, sampleProduced, bufOut; file_meta_data_t * metadata = NULL; audio_stream_type_t stream_type; char_ptr mem_ptr = NULL; boolean shell_cmd = FALSE; CCI_Ctx ctx; int32_t strLen, i; uint32_t file_extension=0; _task_id pcm_flush_id = MQX_NULL_TASK_ID; uint_32 cnt = 0; int32_t max_audio_buf_size = 0; lp_param_t * lpp_param = (lp_param_t *)para; TASK_TEMPLATE_STRUCT task_template; printf("local_player_task.. Enter 1\n"); if (msi_snd_init_with_periodbuffer(1024, 18) != 0) /* for SPI sd card play FLAC, 18K buffer is at least! */ { LOCALPLAY_LOG(" Error: Unable to open the device \"%s\".\n", AUDIO_DIVECE_NAME_STR); return; } /* create semaphore must before pcm_flush_task */ if(MQX_OK != _lwsem_create(&pcm_decoded_sem, 0)) { LOCALPLAY_LOG("\n Error - Unable to creat lwsem: pcm_decoded_sem\n"); } LOCALPLAY_LOG("Creating pcm flush task.........\n"); task_template.TASK_TEMPLATE_INDEX = 0; task_template.TASK_ADDRESS = pcm_flush_task; task_template.TASK_STACKSIZE = 2000; task_template.TASK_PRIORITY = 12; task_template.TASK_NAME = "pcm_flush"; task_template.TASK_ATTRIBUTES = 0; task_template.CREATION_PARAMETER = 0; task_template.DEFAULT_TIME_SLICE = 0; pcm_flush_id = _task_create_blocked(0, 0, (uint_32)&task_template); if (pcm_flush_id == MQX_NULL_TASK_ID) { printf("local_player_task create pcm_flush_task failed \n"); goto clean_up; } else{ gPcmFlushTaskFinish = 0; _task_ready(_task_get_td(pcm_flush_id)); _lwevent_set(&player_event, PLAYER_EVENT_MSK_SONG_RESUME); } metadata = (file_meta_data_t *) _mem_alloc_system_zero(sizeof(file_meta_data_t)); if (NULL == metadata) { LOCALPLAY_LOG("\n Failed to allocate memory for metadata.\n"); return; } decoding = TRUE; while (1) { #ifndef USB_ACCESSORY_PLAY _lwevent_wait_ticks( &player_event, PLAYER_EVENT_MSK_SONG_READY | PLAYER_EVENT_MSK_SD_FS_UNMOUNTED | PLAYER_EVENT_MSK_SHELL_COMMAND, FALSE, 0); #else _lwevent_wait_ticks( &player_event, PLAYER_EVENT_MSK_SONG_READY | PLAYER_EVENT_MSK_SD_FS_UNMOUNTED | PLAYER_EVENT_MSK_SHELL_COMMAND | PLAYER_EVENT_MSK_USB_ATTACHED, FALSE, 0); #endif shell_cmd = FALSE; #ifdef USB_ACCESSORY_PLAY if (player_event.VALUE & PLAYER_EVENT_MSK_USB_ATTACHED) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_USB_ATTACHED); //LOCALPLAY_LOG("__guoyifang__: sd_player_task PLAYER_EVENT_MSK_USB_ACC_ATTACHED \n"); break; } #endif if (player_event.VALUE & PLAYER_EVENT_MSK_SD_FS_UNMOUNTED) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SD_FS_UNMOUNTED); //LOCALPLAY_LOG("__guoyifang__: sd_player_task PLAYER_EVENT_MSK_SD_FS_UNMOUNTED \n"); break; } if (player_event.VALUE & PLAYER_EVENT_MSK_SONG_READY) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SONG_READY); } if (player_event.VALUE & PLAYER_EVENT_MSK_SHELL_COMMAND) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SHELL_COMMAND); shell_cmd = TRUE; } LOCALPLAY_LOG(" --------------------------------------------------------------\n"); printf("play lock umount at %d\n",lpp_param->lp_type); _lwsem_wait(lpp_param->mfs_io_sem); /******************decoding is a critical value, assume decoding is TRUE every time.*******************/ printf("SET decoding.\n"); decoding = TRUE; // next/prev btn ISR may clear decoding to 0 /*******************************************/ /*config the audio subsystem according metadata*/ printf( " Open stream file %s\n", full_path); stream_ptr = fopen(full_path, "r"); if (stream_ptr == NULL) { printf(" Unable to open the file: %s\n", full_path); goto clean_up; } stream_ptr1 = fopen(full_path, "r"); if (stream_ptr1 == NULL) { printf(" Unable to open the file: %s\n", full_path); goto clean_up; } /* Determine the extension of the file */ i=0; strLen= strlen((const char *)full_path); if(strLen > 4){ /* find the '.' */ while(strLen--){ if(full_path[i]=='.') break; i++; } if(strLen){ char *p; /* Copy out the extension : 8.3 filename */ memcpy(&file_extension, full_path+i+1, 3); p = (char *) (&file_extension); for(i = 0; i < 4; i++, p++){ if((*p >= 'a') && (*p <= 'z')){ *p -= ('a' - 'A'); } } } ctx.user_data = (void*) stream_ptr; ctx.cci_dec_read = get_file_data;; ctx.cci_dec_seek = seek_file_data; ctx.cci_dec_tell = get_file_position; /* Check if metadata was found. */ return_code = cci_extract_meta_data(file_extension, metadata, &ctx); if (return_code != 0) { printf("\n Metadata not found\n"); goto clean_up; } print_metadata(metadata); //todo } else { printf("\n Metadata not found\n"); goto clean_up; } if ( metadata->stream_type == STREAM_TYPE_MP3 ) { /* Seek from the beginning of the file */ seek_file_data(0, metadata->start_pos, 0, stream_ptr); } else { /* Seek from the beginning of the file */ seek_file_data(0, 0, 0, stream_ptr); } stream_type = metadata->stream_type; #if 0 format.audio_format.ENDIAN = AUDIO_LITTLE_ENDIAN; format.audio_format.ALIGNMENT = AUDIO_ALIGNMENT_LEFT; if((streamType == kCodecStreamTypePcm) || // bitsPerSample Value is 8/16/24 /* * The demo not support kCodecStreamTypeImaAdpcm/kCodecStreamTypeMsAdpcm currently. */ (streamType == kCodecStreamTypeImaAdpcm) || // bitsPerSample Value is 4 (streamType == kCodecStreamTypeMsAdpcm)) // bitsPerSample Value is 4 { format.audio_format.BITS = metadata->i32BitsPerSample; }else{ format.audio_format.BITS = 16; } // Currently, the wave decoder output 16bits only for kCodecStreamTypePcm. format.audio_format.BITS = 16; format.audio_format.SIZE = (format.audio_format.BITS + 7)/8; format.audio_format.CHANNELS = metadata->i32NumChannels; format.fs_freq = metadata->u32SampleRate; fs_freq = format.fs_freq; mclk_freq = fs_freq * CLK_MULT; // Setup audio data format in device if (ioctl(device_ptr, IO_IOCTL_AUDIO_SET_IO_DATA_FORMAT, &format.audio_format) != I2S_OK) { LOCALPLAY_LOG(" Error: Input data format not supported.\n"); goto clean_up; } // Setup rest of parameters - master clock, valid data bits and sampling frequency if ((ioctl(device_ptr, IO_IOCTL_I2S_SET_MCLK_FREQ, &mclk_freq) != I2S_OK) || (ioctl(device_ptr, IO_IOCTL_I2S_SET_DATA_BITS, &format.audio_format.BITS) != I2S_OK) || (ioctl(device_ptr, IO_IOCTL_I2S_SET_FS_FREQ, &fs_freq) != I2S_OK)) { LOCALPLAY_LOG(" Error: Unable to setup \"%s\" device driver.\n", AUDIO_DIVECE_NAME_STR); goto clean_up; } // Setup audio codec return_code = SetupCodec(device_ptr); if (return_code != 0) { LOCALPLAY_LOG(" Audio codec configuration failed. Error 0x%X.\n", return_code); goto clean_up; } ioctl(device_ptr, IO_IOCTL_I2S_GET_FS_FREQ, &fs_freq); ioctl(device_ptr, IO_IOCTL_I2S_GET_DATA_BITS, &bit_width); LOCALPLAY_LOG(" Playback information\n"); LOCALPLAY_LOG(" Sampling frequency: %d Hz\n", fs_freq); LOCALPLAY_LOG(" Bit depth: %d bits\n", (uint_8)bit_width); LOCALPLAY_LOG(" Channels: "); if (format.audio_format.CHANNELS == 1) { LOCALPLAY_LOG("mono\n"); } else { LOCALPLAY_LOG("stereo\n"); } #else if((stream_type == STREAM_TYPE_PCM) || // bitsPerSample Value is 8/16/24 /* * The demo not support kCodecStreamTypeImaAdpcm/kCodecStreamTypeMsAdpcm currently. */ (stream_type == STREAM_TYPE_IMAADPCM) || // bitsPerSample Value is 4 (stream_type == STREAM_TYPE_MSADPCM)) // bitsPerSample Value is 4 { format.audio_format.BITS = metadata->bits_per_sample; }else{ format.audio_format.BITS = 16; } format.audio_format.CHANNELS = metadata->num_channels; // Currently, the wave decoder output 16bits only for kCodecStreamTypePcm. format.audio_format.BITS = 16; #if 0 if(audio_ioctl(setChNum, format.audio_format.CHANNELS)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setChNum failed.\n"); goto clean_up; } if(audio_ioctl(setBitWidth, format.audio_format.BITS)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setBitWidth failed.\n"); goto clean_up; } #endif format.fs_freq = metadata->sample_rate; #if 0 if(audio_ioctl(setSamplerate, format.fs_freq)!= I2S_OK) { LOCALPLAY_LOG(" Error: audio_ioctl setSamplerate failed.\n"); goto clean_up; } #endif msi_snd_set_format(format.fs_freq, format.audio_format.BITS, format.audio_format.CHANNELS); #endif mem_ptr = (char_ptr) _mem_alloc_system_zero(codec_get_mem_info(stream_type)); if (NULL == mem_ptr) { LOCALPLAY_LOG("Failed to allocate memory for the decoder.\n"); goto clean_up; } // MP4 decoder need two fd g_userData[0] = (int) stream_ptr; g_userData[1] = (int) stream_ptr1; if (metadata->audio_sub_type == MEDIA_SUBTYPE_ADTS) g_userData[2] = 1; else if (metadata->audio_sub_type == MEDIA_SUBTYPE_M4A) g_userData[2] = 2; else if ( metadata->stream_type == STREAM_TYPE_OPUS ) { g_userData[2] = metadata->sample_rate; g_userData[3] = metadata->num_channels; } else g_userData[2] = 0; g_callbackFunctionArray[0] = (int32_t *) &get_file_data; g_callbackFunctionArray[1] = (int32_t *) &seek_file_data; g_callbackFunctionArray[2] = (int32_t *) &get_file_position; while (1) { res = codec_init(stream_type, (long **)&mem_ptr,g_callbackFunctionArray, &g_userData[0]); if (res == CODEC_INIT_ERROR) { LOCALPLAY_LOG("\n Codec Init Failed with error code %d\n", res); decoding = FALSE; goto clean_up; } if (res == CODEC_MORE_DATA_REQUIRED) { LOCALPLAY_LOG("\n More Data Processing Required for Init \n"); } if (res == CODEC_SUCCESS) { LOCALPLAY_LOG("\n Codec Init Done Successfully \n\n"); break; } else { printf("codec init other err\n"); decoding = FALSE; goto clean_up; } } if (res == CODEC_SUCCESS) { LOCALPLAY_LOG(" Playing %s...\n\n", full_path); // ioctl(device_ptr, IO_IOCTL_I2S_CLEAR_STATISTICS, NULL); /* Reset variables before every song's playbacking */ //printf("SET decoding.\n"); //decoding = TRUE; // next/prev btn ISR may clear decoding to 0 cnt = 0; max_audio_buf_size = 0; g_audio_buf_ptr = NULL; //_lwevent_clear(&player_event, PLAYER_EVENT_MSK_AUDIO_BUF_FILLED); /* Clear pcm_decoded_sem for play next song */ _lwsem_poll(&pcm_decoded_sem); _lwsem_poll(&pcm_decoded_sem); if(MQX_OK != _lwsem_create(&pcm_flush_sem, AUDIO_BUF_CNT)) { LOCALPLAY_LOG("\n Error - Unable to create lwsem: pcm_flush_sem\n"); } /* * umute */ msi_snd_umute(); //sai_dma_output_init(); while (decoding) { /* * For FLAC decoder, it produced more than 18K bytes per frame, and takes about 30ms. * While take 44.1K/16bit/2ch/4Kbytes DMA buffer as example, the margin time is 4K/4/2/44100~=10ms. * We need bigger DMA buffer, or decode in a ping-pong way. */ res = codec_decode(stream_type, (long **)&mem_ptr, &sampleProduced, &bufOut); if (res == CODEC_END_OF_DECODE) { printf("\n End of Decode \n"); break; } else if (res == CODEC_DECODE_ERROR) { printf("\n Codec Decode Failed \n"); break; } else if(res != CODEC_SUCCESS){ printf("codec_decode else err %d\n",res); break; } cnt += sampleProduced; while (decoding) { numberOfSamples = codec_get_pcm_samples(stream_type, (long **)&mem_ptr, &sampleProduced, &bufOut); if (numberOfSamples == 0) break; #if 1 if (max_audio_buf_size < sampleProduced) { //More bigger buffer needed max_audio_buf_size = sampleProduced; if (NULL != g_audio_buf_ptr) { LOCALPLAY_LOG(" Bigger buffer needed.\n"); _mem_free(g_audio_buf_ptr); } g_audio_buf_ptr = (uchar_ptr) _mem_alloc_system_zero(max_audio_buf_size); if (NULL == g_audio_buf_ptr) { LOCALPLAY_LOG(" Failed to allocate g_audio_buf_ptr. max_audio_buf_size %d \n", max_audio_buf_size); decoding = 0; break; } #if 1 //sai_dma_buffer_adjust(sampleProduced); #endif } #endif if (MQX_OK != _lwsem_wait(&pcm_flush_sem)) { LOCALPLAY_LOG("\n Error: Wait for pcm_flush_sem failed.\n"); // _task_set_error(res); } _mem_copy((void *)bufOut, g_audio_buf_ptr, sampleProduced); //g_audio_buf_ptr = bufOut; g_buf_bytes_to_flush = sampleProduced; if (_lwsem_post(&pcm_decoded_sem) != MQX_OK) { LOCALPLAY_LOG("\n pcm_flush : Error - Unable to set pcm_decoded_sem."); } if (numberOfSamples == sampleProduced) sampleProduced = 0; }//end while decoding }//end while decoding }//end if res==kCodeSuccess #if 0 fflush(device_ptr); #else msi_snd_mute(); if (MQX_OK != _lwsem_wait(&pcm_flush_sem)) LOCALPLAY_LOG("\n Error: Wait for latest pcm_flush_sem failed.\n"); msi_snd_flush(); #endif #if 1 //sai_dma_output_stop(); #endif #if 0 /* Print transfer statistics */ if (ioctl(device_ptr, IO_IOCTL_I2S_GET_STATISTICS, &stats) != I2S_OK) { LOCALPLAY_LOG(" Error: Cannot read I2S statistics.\n"); } else { LOCALPLAY_LOG("\n Playback stats\n"); LOCALPLAY_LOG(" Total interrupts: %d\n", stats.INTERRUPTS); LOCALPLAY_LOG(" Bytes requested for transmit: %d\n", stats.PACKETS_REQUESTED * format.audio_format.SIZE); LOCALPLAY_LOG(" Bytes transmitted: %d\n", stats.TX_PACKETS * format.audio_format.SIZE); LOCALPLAY_LOG(" Underruns of hardware FIFO: %d\n", stats.FIFO_ERROR); LOCALPLAY_LOG(" Software buffer empty: %d\n", stats.BUFFER_ERROR); } #endif LOCALPLAY_LOG("\n DONE\n"); clean_up: printf("done to clean up,decoding %d \n",decoding); /* Clean up for next song */ if (NULL != mem_ptr) { _mem_free(mem_ptr); mem_ptr = NULL; } if (NULL != g_audio_buf_ptr) { _mem_free(g_audio_buf_ptr); g_audio_buf_ptr = NULL; } if (NULL != stream_ptr) { res = fclose(stream_ptr); if ((res != MQX_OK)&&(res != MFS_DISK_IS_WRITE_PROTECTED)) { /*LOCALPLAY_LOG*/printf(" Error: Unable to close file 0x%x.\n", res); } stream_ptr = NULL; } if (NULL != stream_ptr1) { res = fclose(stream_ptr1); if ((res != MQX_OK)&&(res != MFS_DISK_IS_WRITE_PROTECTED)) { /*LOCALPLAY_LOG*/printf(" Error: Unable to close file 0x%x.\n", res); } stream_ptr1 = NULL; } if(MQX_OK != _lwsem_destroy(&pcm_flush_sem)) { LOCALPLAY_LOG("\n Error - Unable to destroy lwsem: pcm_flush_sem\n"); } if (decoding == TRUE) { // playback finished in normal way, ie, next/prev not pressed if (!shell_cmd) { // and was not triggered by Shell // just like next btn being pressed _lwevent_set(&player_event, PLAYER_EVENT_MSK_NEXT_BTN_PRESSED); } } /* if exit this task ,must route this point ! */ printf("play unlock umount at %d\n",lpp_param->lp_type); _lwsem_post(lpp_param->mfs_io_sem); }//end while(1) #if 0 // clean up further if (NULL != device_ptr) { if (fclose(device_ptr) != MQX_OK) { LOCALPLAY_LOG(" Error: Unable to close \"%s\" device driver.\n", full_path); } } #else msi_snd_deinit(); #endif if (NULL != metadata) _mem_free(metadata); if (MQX_NULL_TASK_ID != pcm_flush_id) { gPcmFlushTaskFinish = 1; _lwsem_post(&pcm_decoded_sem); while(gPcmFlushTaskFinish == 1){ _sched_yield(); } //_task_destroy(pcm_flush_id); pcm_flush_id = MQX_NULL_TASK_ID; ///*LOCALPLAY_LOG*/printf(" pcm flush task destoryed \n"); } if(MQX_OK != _lwsem_destroy(&pcm_decoded_sem)) { LOCALPLAY_LOG("\n Error - Unable to destroy lwsem: pcm_decoded_sem\n"); } //printf("__guoyifang__: sd_player_task %d set PLAYER_TASK_KILLED.\n",lpp_param->lp_type); _lwevent_set(&player_event, PLAYER_EVENT_MSK_PLAYER_TASK_KILLED); printf("sd_player_task exit.\n"); //_task_block(); //wait for being destroyed }
/*! * \brief This function sends a message to an endpoint. * * The message is copied into the MCC buffer and the destination core is signaled. * * \param[in] endpoint Pointer to the receiving endpoint to send to. * \param[in] msg Pointer to the message to be sent. * \param[in] msg_size Size of the message to be sent in bytes. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_INVAL (the msg_size exceeds the size of a data buffer) * \return MCC_ERR_TIMEOUT (timeout exceeded before a buffer became available) * \return MCC_ERR_NOMEM (no free buffer available and timeout_us set to 0) * \return MCC_ERR_SQ_FULL (signal queue is full) * * \see mcc_recv_copy * \see mcc_recv_nocopy * \see MCC_ENDPOINT */ int mcc_send(MCC_ENDPOINT *endpoint, void *msg, MCC_MEM_SIZE msg_size, unsigned int timeout_us) { int return_value, end_time_set_flag = 0; MCC_RECEIVE_LIST *list; MCC_RECEIVE_BUFFER * buf; MCC_SIGNAL affiliated_signal; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; MQX_TICK_STRUCT tick_time; #endif /* Check if the size of the message to be sent does not exceed the size of the mcc buffer */ if(msg_size > sizeof(bookeeping_data->r_buffers[0].data)) { return MCC_ERR_INVAL; } /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); buf = mcc_dequeue_buffer(&bookeeping_data->free_list); while(buf == null) { mcc_release_semaphore(); /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_NOMEM; } /* Blocking calls: CPU-to-CPU ISR sets the event and thus resumes tasks waiting for a free MCC buffer. * As the interrupt request is send to all cores when a buffer is freed it could happen that several * tasks from different cores/nodes are waiting for a free buffer and all of them are notified that the buffer * has been freed. This function has to check (after the wake up) that a buffer is really available and has not been already * grabbed by another "competitor task" that has been faster. If so, it has to wait again for the next notification. */ /* wait forever */ else if(timeout_us == 0xFFFFFFFF) { #if (MCC_OS_USED == MCC_MQX) _lwevent_wait_ticks(&lwevent_buffer_freed, 1, TRUE, 0); _lwevent_clear(&lwevent_buffer_freed, 1); #endif } /* timeout_us > 0 */ else { #if (MCC_OS_USED == MCC_MQX) if(!end_time_set_flag) { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); end_time_set_flag = 1; } return_value = _lwevent_wait_until(&lwevent_buffer_freed, 1, TRUE, &tick_time); if(return_value == LWEVENT_WAIT_TIMEOUT) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } _lwevent_clear(&lwevent_buffer_freed, 1); #endif } MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_get_semaphore(); buf = mcc_dequeue_buffer(&bookeeping_data->free_list); } /* Semaphore-protected section end */ mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Copy the message into the MCC receive buffer */ mcc_memcpy(msg, (void*)buf->data, (unsigned int)msg_size); MCC_DCACHE_FLUSH_MLINES((void*)buf->data, msg_size); buf->data_len = msg_size; MCC_DCACHE_FLUSH_MLINES((void*)&buf->data_len, sizeof(MCC_MEM_SIZE)); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); if(list == null) { /* The endpoint does not exists (has not been registered so far), free the buffer and return immediately - error */ /* Enqueue the buffer back into the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); mcc_release_semaphore(); return MCC_ERR_ENDPOINT; } /* Write the signal type into the signal queue of the particular core */ affiliated_signal.type = BUFFER_QUEUED; affiliated_signal.destination = *endpoint; return_value = mcc_queue_signal(endpoint->core, affiliated_signal); if(return_value != MCC_SUCCESS) { /* Signal queue is full, free the buffer and return immediately - error */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); mcc_release_semaphore(); return return_value; } /* Enqueue the buffer into the endpoint buffer list */ mcc_queue_buffer(list, buf); /* Semaphore-protected section end */ mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Signal the other core by generating the CPU-to-CPU interrupt */ return_value = mcc_generate_cpu_to_cpu_interrupt(); return return_value; }
void usbh_acc_task(uint32_t param) { struct _usb_accessoy_host_info_ * acc_host_info = (struct _usb_accessoy_host_info_ *)param; _mqx_int app_event_value; printf("usbh_acc_task start\n"); while(1) { if (_lwevent_wait_ticks(&acc_host_info->acc_event,USBH_AOA_ALL_EVENTS_MASK, FALSE, 0) != MQX_OK) { printf("waiting accessory event fail\n"); // return /*USBERR_ERROR*/; continue; } else { app_event_value = _lwevent_get_signalled(); } if(app_event_value & /* USBH_AOA_DETACH_EVENT */USBH_AOA_STOP_TASK_EVENT) { acc_host_info->acc_task_state = USBH_AOA_TASK_STATE_STOP; acc_host_info->adk_status = WATIING_TRY_ACC; printf("acc task stop adk status %d\n",acc_host_info->adk_status); return; } if( app_event_value & USBH_AOA_DETACH_EVENT ) { acc_host_info->adk_status = WATIING_TRY_ACC; printf("acc task detach at adk status %d\n",acc_host_info->adk_status); //return; /* Can't return ,because it is detach,not plug out! */ } switch(acc_host_info->adk_status) { case WATIING_TRY_ACC: { printf("event %d in WATIING_TRY_ACC\n",app_event_value); if(/* acc_host_info->acc_event.VALUE */app_event_value & USBH_TRY_AOA_START_EVENT) { acc_host_info->adk_status = TRYING_ACC; acc_host_info->try_acc_status = GET_PROTOCOL_VERSION; /* start the first acc try */ if(usb_device_try_accessory( acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE, usb_try_accessory_callback,acc_host_info,acc_host_info->try_acc_status) != USB_OK) { acc_host_info->adk_status = WATIING_TRY_ACC; printf("usb_device_try_accessory fail1\n"); break; } //acc_host_info->try_acc_status ++; _time_delay(5); } else if (app_event_value & USBH_AOA_INTERFACED_EVENT) { #ifdef USE_ACC_HID #ifdef CONNECT_TO_APK usb_device_hid_regist(acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE,usb_hid_callback, sizeof(hid_description)); usb_device_hid_set_report_descriptor(acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE,usb_hid_callback); #else usb_device_hid_regist(audio_host_info->audio_stream.DEV_HANDLE,audio_host_info->audio_stream.INTF_HANDLE,usb_hid_callback, sizeof(hid_description)); usb_device_hid_set_report_descriptor(audio_host_info->audio_stream.DEV_HANDLE,audio_host_info->audio_stream.INTF_HANDLE,usb_hid_callback); #endif #endif acc_host_info->adk_status = ADK_READING; #ifdef ADK_2012 // the apk is adk2012 readSettings(&acc_host_info->settings); acc_start_recv(acc_host_info,MAX_ADK_RECV_SIZE); #endif } else { /* fixme ,how to process */ acc_host_info->adk_status = WATIING_TRY_ACC; printf("Invalid event %d in WATIING_TRY_ACC\n",app_event_value); } } break; case TRYING_ACC: { if(app_event_value & USBH_TRY_AOA_CALLBACK_EVENT) { if(acc_host_info->try_acc_status != WAITING_ACCESSORY) { if(usb_device_try_accessory( acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE, usb_try_accessory_callback,acc_host_info,acc_host_info->try_acc_status)!= USB_OK) { acc_host_info->adk_status = WATIING_TRY_ACC; printf("usb_device_try_accessory fail\n"); break; } //acc_host_info->try_acc_status ++; _time_delay(5); } } else if (app_event_value & USBH_AOA_INTERFACED_EVENT) { #ifdef USE_ACC_HID #ifdef CONNECT_TO_APK usb_device_hid_regist(acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE,usb_hid_callback, sizeof(hid_description)); usb_device_hid_set_report_descriptor(acc_host_info->acc_device.DEV_HANDLE,acc_host_info->acc_device.INTF_HANDLE,usb_hid_callback); #else usb_device_hid_regist(audio_host_info->audio_stream.DEV_HANDLE,audio_host_info->audio_stream.INTF_HANDLE,usb_hid_callback, sizeof(hid_description)); usb_device_hid_set_report_descriptor(audio_host_info->audio_stream.DEV_HANDLE,audio_host_info->audio_stream.INTF_HANDLE,usb_hid_callback); #endif #endif acc_host_info->adk_status = ADK_READING; #ifdef ADK_2012 // the apk is adk2012 readSettings(&acc_host_info->settings); acc_start_recv(acc_host_info,MAX_ADK_RECV_SIZE); #endif } else { /* fixme */ acc_host_info->adk_status = WATIING_TRY_ACC; printf("Invalid event %d in TRYING_ACC\n",app_event_value); } } break; case ADK_READING: { #ifndef ADK_2012 _time_delay(10); break; #else if(app_event_value & USBH_AOA_RECV_COMP_EVENT) { if (acc_host_info->received_size >= 4) { uint16_t replylen; uint8_t cmd = acc_host_info->receiveBuf[0]; uint8_t seq = acc_host_info->receiveBuf[1]; uint16_t size = acc_host_info->receiveBuf[2] | acc_host_info->receiveBuf[3] << 8; if (size + 4 > acc_host_info->received_size) { // short packet //return; printf("short packet\n"); } else { replylen = adkProcessCommand(acc_host_info,cmd, acc_host_info->receiveBuf + 4, size, 0, acc_host_info->reply + 4, MAX_PACKET_SZ - 4); if (replylen > 0) { acc_host_info->reply[0] = cmd | CMD_MASK_REPLY; acc_host_info->reply[1] = seq; acc_host_info->reply[2] = replylen; acc_host_info->reply[3] = replylen >> 8; replylen += 4; pr_debug("ADK: USB: sending %d bytes\n", replylen); _time_delay(1); /* add for ISO workaround */ acc_host_info->adk_status = ADK_WRITING; acc_start_send(acc_host_info,MAX_ADK_RECV_SIZE); } } } } else if(app_event_value & USBH_AOA_RECV_FAIL_EVENT) { _time_delay(1); //printf("USBH_AOA_RECV_FAIL_EVENT,retry\n"); readSettings(&acc_host_info->settings); acc_host_info->adk_status = ADK_READING; acc_start_recv(acc_host_info,MAX_ADK_RECV_SIZE); } else { printf("Invalid event %d in ADK_READING\n",app_event_value); } #endif }
/*! * \brief This function receives a message from the specified endpoint if one is available. * The data will be copied from the receive buffer into the user supplied buffer. * * This is the "receive with copy" version of the MCC receive function. This version is simple * to use but it requires copying data from shared memory into the user space buffer. * The user has no obligation or burden to manage the shared memory buffers. * * \param[in] endpoint Pointer to the receiving endpoint to receive from. * \param[in] buffer Pointer to the user-app. buffer where data will be copied into. * \param[in] buffer_size The maximum number of bytes to copy. * \param[out] recv_size Pointer to an MCC_MEM_SIZE that will contain the number of bytes actually copied into the buffer. * \param[in] timeout_us Timeout, in microseconds, to wait for a free buffer. A value of 0 means don't wait (non-blocking call). A value of 0xffffffff means wait forever (blocking call). * * \return MCC_SUCCESS * \return MCC_ERR_ENDPOINT (the endpoint does not exist) * \return MCC_ERR_SEMAPHORE (semaphore handling error) * \return MCC_ERR_TIMEOUT (timeout exceeded before a new message came) * * \see mcc_send * \see mcc_recv_nocopy * \see MCC_ENDPOINT */ int mcc_recv_copy(MCC_ENDPOINT *endpoint, void *buffer, MCC_MEM_SIZE buffer_size, MCC_MEM_SIZE *recv_size, unsigned int timeout_us) { MCC_RECEIVE_LIST *list; MCC_RECEIVE_BUFFER * buf; MCC_SIGNAL affiliated_signal; MCC_ENDPOINT tmp_destination = {(MCC_CORE)0, (MCC_NODE)0, (MCC_PORT)0}; int return_value, i = 0; #if (MCC_OS_USED == MCC_MQX) unsigned int time_us_tmp; unsigned int lwevent_index = endpoint->port / MCC_MQX_LWEVENT_GROUP_SIZE; unsigned int lwevent_group_index = endpoint->port % MCC_MQX_LWEVENT_GROUP_SIZE; MQX_TICK_STRUCT tick_time; #endif /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Get list of buffers kept by the particular endpoint */ list = mcc_get_endpoint_list(*endpoint); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* The endpoint is not valid */ if(list == null) { return MCC_ERR_ENDPOINT; } if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Non-blocking call */ if(timeout_us == 0) { return MCC_ERR_TIMEOUT; } /* Blocking call */ else { #if (MCC_OS_USED == MCC_MQX) if(timeout_us == 0xFFFFFFFF) { _lwevent_wait_ticks(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, 0); } /* timeout_us > 0 */ else { _time_get_ticks(&tick_time); _time_add_usec_to_ticks(&tick_time, timeout_us); _lwevent_wait_until(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index, TRUE, &tick_time); } #endif MCC_DCACHE_INVALIDATE_MLINES((void*)list, sizeof(MCC_RECEIVE_LIST*)); } } /* Clear event bit specified for the particular endpoint in the lwevent_buffer_queued lwevent group */ _lwevent_clear(&lwevent_buffer_queued[lwevent_index], 1<<lwevent_group_index); if(list->head == (MCC_RECEIVE_BUFFER*)0) { /* Buffer not dequeued before the timeout */ return MCC_ERR_TIMEOUT; } /* Copy the message from the MCC receive buffer into the user-app. buffer */ MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data_len, sizeof(MCC_MEM_SIZE)); if (list->head->data_len > buffer_size) { list->head->data_len = buffer_size; } *recv_size = (MCC_MEM_SIZE)(list->head->data_len); MCC_DCACHE_INVALIDATE_MLINES((void*)&list->head->data, list->head->data_len); mcc_memcpy((void*)list->head->data, buffer, list->head->data_len); /* Semaphore-protected section start */ return_value = mcc_get_semaphore(); if(return_value != MCC_SUCCESS) return return_value; /* Dequeue the buffer from the endpoint list */ buf = mcc_dequeue_buffer(list); /* Enqueue the buffer into the free list */ MCC_DCACHE_INVALIDATE_MLINES((void*)&bookeeping_data->free_list, sizeof(MCC_RECEIVE_LIST*)); mcc_queue_buffer(&bookeeping_data->free_list, buf); /* Notify all cores (except of itself) via CPU-to-CPU interrupt that a buffer has been freed */ affiliated_signal.type = BUFFER_FREED; affiliated_signal.destination = tmp_destination; for (i=0; i<MCC_NUM_CORES; i++) { if(i != MCC_CORE_NUMBER) { mcc_queue_signal(i, affiliated_signal); } } mcc_generate_cpu_to_cpu_interrupt(); /* Semaphore-protected section end */ return_value = mcc_release_semaphore(); if(return_value != MCC_SUCCESS) return return_value; return return_value; }
/*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"); } } }
/*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 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 */
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"); } }
void sd_file_search_task(uint_32 para) { lp_param_t * lpp_param = (lp_param_t *)para; char * path = (char *)lpp_param->path; set_file_filter((char **) ext_wantted); while (1) { _lwevent_wait_ticks( &player_event, PLAYER_EVENT_MSK_NEXT_BTN_PRESSED | PLAYER_EVENT_MSK_PREV_BTN_PRESSED | PLAYER_EVENT_MSK_SD_FS_MOUNTED |PLAYER_EVENT_MSK_SEARCH_TASK_QUIT, FALSE, 0); full_path[0] = '\0'; if (player_event.VALUE & PLAYER_EVENT_MSK_SEARCH_TASK_QUIT) { //printf("search task %d exit\n",lpp_param->lp_type); _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SEARCH_TASK_QUIT); goto exit_search; } printf("search lock umount at %d\n",lpp_param->lp_type); _lwsem_wait(lpp_param->mfs_io_sem); if (player_event.VALUE & PLAYER_EVENT_MSK_NEXT_BTN_PRESSED) { //get_next_file_name("a:\\", full_path); get_next_file_name(path, full_path); _lwevent_clear(&player_event, PLAYER_EVENT_MSK_NEXT_BTN_PRESSED); //printf("search id1\n"); } else if (player_event.VALUE & PLAYER_EVENT_MSK_PREV_BTN_PRESSED) { //get_prev_file_name("a:\\", full_path); get_prev_file_name(path, full_path); _lwevent_clear(&player_event, PLAYER_EVENT_MSK_PREV_BTN_PRESSED); //printf("search id2\n"); } else if (player_event.VALUE & PLAYER_EVENT_MSK_SD_FS_MOUNTED) { //get_next_file_name("a:\\", full_path); get_next_file_name(path, full_path); _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SD_FS_MOUNTED); //printf("MOUNTED! 1: %s\n", full_path); } printf("search unlock umount at %d\n",lpp_param->lp_type); _lwsem_post(lpp_param->mfs_io_sem); /* If found*/ if (full_path[0] != '\0') {_lwevent_set(&player_event, PLAYER_EVENT_MSK_SONG_READY); printf("search y\n"); } else printf("search n\n"); } exit_search: fs_walker_clear(); printf("sd_file_search_task exit.\n"); //printf("__guoyifang__: sd_file_search_task %d set SEARCH_TASK_KILLED.\n",lpp_param->lp_type); _lwevent_set(&player_event, PLAYER_EVENT_MSK_SEARCH_TASK_KILLED); //_task_block(); //wait for being destroyed }