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"); } }
/*! * \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, 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"); } } }
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 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 }