void usb_host_cdc_acm_event
(
/* [IN] pointer to device instance */
_usb_device_instance_handle dev_handle,
/* [IN] pointer to interface descriptor */
_usb_interface_descriptor_handle intf_handle,
/* [IN] code number for event causing callback */
uint_32 event_code
)
{ /* Body */
INTERFACE_DESCRIPTOR_PTR intf_ptr = (INTERFACE_DESCRIPTOR_PTR)intf_handle;
fflush(stdout);
switch (event_code) {
case USB_CONFIG_EVENT:
/* Drop through into attach, same processing */
case USB_ATTACH_EVENT: {
USB_CDC_DESC_ACM_PTR acm_desc = NULL;
USB_CDC_DESC_CM_PTR cm_desc = NULL;
USB_CDC_DESC_HEADER_PTR header_desc = NULL;
USB_CDC_DESC_UNION_PTR union_desc = NULL;
/* finds all the descriptors in the configuration */
if (USB_OK != usb_class_cdc_get_acm_descriptors(dev_handle,
intf_handle,
&acm_desc,
&cm_desc,
&header_desc,
&union_desc))
break;
/* initialize new interface members and select this interface */
if (USB_OK != _usb_hostdev_select_interface(dev_handle,
intf_handle, (pointer)&acm_device.CLASS_INTF))
{
break;
}
/* set all info got from descriptors to the class interface struct */
usb_class_cdc_set_acm_descriptors((pointer)&acm_device.CLASS_INTF,
acm_desc, cm_desc, header_desc, union_desc);
/* link all already registered data interfaces to this ACM control, if needed */
if (USB_OK != usb_class_cdc_bind_data_interfaces(dev_handle, (pointer)&acm_device.CLASS_INTF)) {
break;
}
printf("----- CDC control interface attach Event -----\n");
fflush(stdout);
printf("State = attached");
printf(" Class = %d", intf_ptr->bInterfaceClass);
printf(" SubClass = %d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
break;
}
case USB_INTF_EVENT:
{
CLASS_CALL_STRUCT_PTR acm_parser;
USB_STATUS status;
if (NULL == (acm_parser = usb_class_cdc_get_ctrl_interface(intf_handle)))
break;
if (MQX_OK != usb_class_cdc_acm_use_lwevent(acm_parser, &acm_device.acm_event))
break;
status = usb_class_cdc_init_ipipe(acm_parser);
if ((status != USB_OK) && (status != USBERR_OPEN_PIPE_FAILED))
break;
printf("----- CDC control interface selected -----\n");
break;
}
case USB_DETACH_EVENT:
{
CLASS_CALL_STRUCT_PTR acm_parser;
if (NULL == (acm_parser = usb_class_cdc_get_ctrl_interface(intf_handle)))
break;
/* Allow tasks waiting for acm to be finished...
** We will not wait here - in the interrupt context.
** For simplification, we dont use any semaphore to indicate that
** all tasks have finished its job with device. Instead, we are just
** informed them that device is detached and we rely on USB stack layer
** that its check of the available device returns false.
** The code that would synchronize tasks to be finished would look like:
**
** _lwsem_wait(tasks_using_device_semaphore);
**
** where the semaphore would be signalled from this interrupt.
*/
usb_class_cdc_unbind_data_interfaces(acm_parser);
/* Use only the interface with desired protocol */
printf("----- CDC control interface detach event -----\n");
fflush(stdout);
printf("State = detached");
printf(" Class = %d", intf_ptr->bInterfaceClass);
printf(" SubClass = %d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
break;
}
default:
printf("CDC device: unknown control event\n");
fflush(stdout);
break;
} /* EndSwitch */
} /* Endbody */
void usb_host_cdc_data_event
(
/* [IN] pointer to device instance */
_usb_device_instance_handle dev_handle,
/* [IN] pointer to interface descriptor */
_usb_interface_descriptor_handle intf_handle,
/* [IN] code number for event causing callback */
uint_32 event_code
)
{ /* Body */
INTERFACE_DESCRIPTOR_PTR intf_ptr =
(INTERFACE_DESCRIPTOR_PTR)intf_handle;
fflush(stdout);
switch (event_code) {
case USB_CONFIG_EVENT:
/* Drop through into attach, same processing */
case USB_ATTACH_EVENT: {
/* This data interface could be controlled by some control interface,
* which could be already initialized (or not). We have to find
* that interface. Then we need to bind this interface with
* found control interface. */
INTERFACE_DESCRIPTOR_PTR if_desc;
if (USB_OK != usb_class_cdc_get_ctrl_descriptor(dev_handle,
intf_handle,
&if_desc))
break;
/* initializes interface members and selects it */
if (USB_OK != _usb_hostdev_select_interface(dev_handle,
intf_handle, (pointer)&data_device.CLASS_INTF))
{
break;
}
/* binds this data interface with its control interface, if possible */
if (USB_OK != usb_class_cdc_bind_acm_interface((pointer)&data_device.CLASS_INTF,
if_desc))
{
break;
}
printf("----- CDC data interface attach event -----\n");
fflush(stdout);
printf("State = attached");
printf(" Class = %d", intf_ptr->bInterfaceClass);
printf(" SubClass = %d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
break;
}
case USB_INTF_EVENT:
{
CLASS_CALL_STRUCT_PTR data_parser;
fflush(stdout);
if (NULL == (data_parser = usb_class_cdc_get_data_interface(intf_handle)))
break;
if (MQX_OK != usb_class_cdc_data_use_lwevent(data_parser, &data_device.data_event))
break;
if (USB_OK == usb_class_cdc_install_driver(data_parser, device_name))
{
if (((USB_DATA_CLASS_INTF_STRUCT_PTR) (data_parser->class_intf_handle))->BOUND_CONTROL_INTERFACE != NULL) {
if (reg_device == 0) {
reg_device = dev_handle;
_lwevent_set(device_registered, 0x01);
}
}
printf("----- Device installed -----\n");
}
printf("----- CDC data interface selected -----\n");
break;
}
case USB_DETACH_EVENT:
{
CLASS_CALL_STRUCT_PTR data_parser;
if (NULL == (data_parser = usb_class_cdc_get_data_interface(intf_handle)))
break;
/* Allow tasks waiting for data to be finished...
** This does have sense only if this task will not be active
** or scheduler switches to another task.
** For simplification, we dont use any semaphore to indicate that
** all tasks have finished its job with device. Instead, we have just
** informed them that device is detached and we rely on USB stack layer
** that it checking if the device is available returns false.
** The code that would synchronize tasks to be finished would look like:
**
** _lwsem_wait(if_ptr->device_using_tasks);
*/
/* unbind data interface */
if (USB_OK != usb_class_cdc_unbind_acm_interface(data_parser))
break;
if (USB_OK != usb_class_cdc_uninstall_driver(data_parser))
break;
if (reg_device == dev_handle) {
reg_device = 0;
_lwevent_clear(device_registered, 0x01);
}
printf("----- CDC data interface detach Event -----\n");
fflush(stdout);
printf("State = detached");
printf(" Class = %d", intf_ptr->bInterfaceClass);
printf(" SubClass = %d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
break;
}
default:
printf("CDC device: unknown data event\n");
fflush(stdout);
break;
} /* EndSwitch */
} /* Endbody */
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);
}
}
}
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_host_hub_device_event
* Returned Value : None
* Comments :
* called when a hub has been attached, detached, etc.
*END*--------------------------------------------------------------------*/
void usb_host_hub_device_event
(
/* [IN] pointer to device instance */
_usb_device_instance_handle dev_handle,
/* [IN] pointer to interface descriptor */
_usb_interface_descriptor_handle intf_handle,
/* [IN] code number for event causing callback */
uint_32 event_code
)
{
HUB_DEVICE_STRUCT_PTR hub_instance;
switch (event_code) {
case USB_CONFIG_EVENT:
/* Drop through into attach, same processing */
case USB_ATTACH_EVENT:
/* Create 'unsafe' application struct */
if (NULL != (hub_instance = USB_mem_alloc_zero(sizeof(HUB_DEVICE_STRUCT)))) {
_usb_hostdev_select_interface(dev_handle, intf_handle, (pointer)&hub_instance->CCS);
}
break;
case USB_INTF_EVENT:
if (USB_OK != usb_class_hub_get_app(dev_handle, intf_handle, (CLASS_CALL_STRUCT_PTR *) &hub_instance))
break;
/* set we are in process of getting hub descriptor */
hub_instance->STATE = HUB_GET_DESCRIPTOR_TINY_PROCESS;
/* here, we should retrieve information from the hub */
usb_class_hub_get_descriptor(&hub_instance->CCS, (tr_callback) usb_host_hub_device_sm, (pointer) hub_instance, 7);
break;
case USB_DETACH_EVENT: {
DEV_INSTANCE_PTR dev_ptr;
_mqx_int i;
if (USB_OK != usb_class_hub_get_app(dev_handle, intf_handle, (CLASS_CALL_STRUCT_PTR *) &hub_instance))
break;
dev_ptr = (DEV_INSTANCE_PTR) dev_handle;
/* detach all the devices connected to all the ports of found hub */
for (i = 0; i < hub_instance->HUB_PORT_NR; i++) {
if ((hub_instance->HUB_PORTS + i)->APP_STATUS & HUB_PORT_ATTACHED)
/* We will access dev_ptr without validation process (usb_hostdev_validate), because
** USB_DETACH_EVENT is synced call, so we can do that. dev_ptr is still valid pointer to device.
*/
usb_dev_list_detach_device(dev_ptr->host, dev_ptr->address, i + 1);
}
if (hub_instance->HUB_PORTS != NULL)
USB_mem_free(hub_instance->HUB_PORTS);
}
break;
default:
break;
} /* EndSwitch */
} /* Enbbody */
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 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 param )
{ /* Body */
USB_STATUS status = USB_OK;
_int_disable();
_int_install_unexpected_isr();
status = _usb_host_driver_install(HOST_CONTROLLER_NUMBER, (pointer)&_bsp_usb_host_callback_table);
if (status) {
_int_enable();
printf("ERROR: %ls", status);
exit(1);
} /* Endif */
status = _usb_host_init
(HOST_CONTROLLER_NUMBER, /* Use value in header file */
MAX_FRAME_SIZE, /* Frame size per USB spec */
&host_handle); /* Returned pointer */
if (status != USB_OK) {
_int_enable();
printf("\nUSB Host Initialization failed. STATUS: %x", status);
fflush(stdout);
goto Error_Cleanup;
} /* Endif */
/*
** 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) {
_int_enable();
printf("\nDriver Registration failed. STATUS: %x", status);
fflush(stdout);
goto Error_Cleanup;
}
_int_enable();
pCmd = (COMMAND_OBJECT_PTR) USB_mem_alloc_zero(sizeof(COMMAND_OBJECT_STRUCT));
if (pCmd == NULL)
{
printf ("\nUnable to allocate Command Object");
fflush (stdout);
goto Error_Cleanup;
}
pCmd->CBW_PTR = (CBW_STRUCT_PTR) USB_mem_alloc_zero(sizeof(CBW_STRUCT));
if (pCmd->CBW_PTR == NULL)
{
printf ("\nUnable to allocate Command Block Wrapper");
fflush (stdout);
goto Error_Cleanup;
}
pCmd->CSW_PTR = (CSW_STRUCT_PTR) USB_mem_alloc_zero(sizeof(CSW_STRUCT));
if (pCmd->CSW_PTR == NULL)
{
printf ("\nUnable to allocate Command Status Wrapper");
fflush (stdout);
goto Error_Cleanup;
}
buff_in = (uchar_ptr)USB_mem_alloc_uncached(0x400C);
if (buff_in == NULL)
{
printf ("\nUnable to allocate Input Buffer");
fflush (stdout);
goto Error_Cleanup;
}
_mem_zero(buff_in, 0x400C);
buff_out = (uchar_ptr) USB_mem_alloc_uncached(0x0F);
if (buff_out == NULL)
{
printf ("\nUnable to allocate Output Buffer");
fflush (stdout);
goto Error_Cleanup;
}
_mem_zero(buff_out, 0x0F);
printf("\nPlease insert Mass Storage Device.\n");
/*----------------------------------------------------**
** Infinite loop, waiting for events requiring action **
**----------------------------------------------------*/
for ( ; ; ) {
switch ( mass_device.dev_state ) {
case USB_DEVICE_IDLE:
break ;
case USB_DEVICE_ATTACHED:
printf( "Mass Storage Device Attached\n" );
fflush(stdout);
mass_device.dev_state = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(mass_device.dev_handle,
mass_device.intf_handle, (pointer)&mass_device.class_intf);
break ;
case USB_DEVICE_SET_INTERFACE_STARTED:
break;
case USB_DEVICE_INTERFACED:
usb_host_mass_test_storage();
mass_device.dev_state = USB_DEVICE_OTHER;
break ;
case USB_DEVICE_DETACHED:
printf ( "\nMass Storage Device Detached\n" );
fflush(stdout);
mass_device.dev_state = USB_DEVICE_IDLE;
break;
case USB_DEVICE_OTHER:
break ;
default:
printf ( "Unknown Mass Storage Device State = %d\n",\
mass_device.dev_state );
fflush(stdout);
break ;
} /* Endswitch */
} /* Endfor */
Error_Cleanup:
{
if (pCmd != NULL)
{
if (pCmd->CSW_PTR != NULL)
{
USB_mem_free(pCmd->CSW_PTR);
}
if (pCmd->CBW_PTR != NULL)
{
USB_mem_free(pCmd->CBW_PTR);
}
USB_mem_free(pCmd);
}
if (buff_in != NULL)
{
USB_mem_free(buff_in);
}
if (buff_out != NULL)
{
USB_mem_free(buff_out);
}
if (host_handle != NULL)
{
_usb_host_shutdown (host_handle);
}
}
} /* Endbody */
void Mouse_Task ( uchar *buffer, HID_COMMAND_PTR hid_com )
{
USB_STATUS status = USB_OK;
static _usb_pipe_handle pipe;
static uint_32 check = 0, usb_event_flag = 1;
static TR_INIT_PARAM_STRUCT tr;
uint_32 result, test_buffer[4];
// Wait for insertion or removal event
//result = _usb_event_wait_ticks(&USB_Event, USB_EVENT_CTRL, FALSE, 0);
//if (USB_EVENT_NOT_SET == result) return;
switch ( hid_device.DEV_STATE ) {
case USB_DEVICE_IDLE:
break;
case USB_DEVICE_ATTACHED:
printf("\nMouse device attached");
//fflush(stdout);
hid_device.DEV_STATE = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(hid_device.DEV_HANDLE, hid_device.INTF_HANDLE, (pointer2)&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 */
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;
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:
if(0 == check){
check = 1;
pipe = _usb_hostdev_find_pipe_handle(hid_device.DEV_HANDLE, hid_device.INTF_HANDLE, USB_INTERRUPT_PIPE, USB_RECV);
if(pipe){
printf("Mouse device ready, try to move the mouse\n");
}
}
/******************************************************************
Initiate a transfer request on the interrupt pipe
******************************************************************/
if (usb_event_flag == 1){
usb_hostdev_tr_init(&tr, usb_host_hid_recv_callback, NULL);
tr.RX_BUFFER = buffer;
tr.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. */
if(_usb_event_wait_ticks(&USB_Event,USB_EVENT_CTRL | USB_EVENT_DATA, FALSE, 0) == USB_EVENT_SET){
usb_event_flag = 1;
_usb_event_clear(&USB_Event, USB_EVENT_CTRL | USB_EVENT_DATA);
} else {
usb_event_flag = 0;
}
/* if not detached in the meanwhile */
if((hid_device.DEV_STATE == USB_DEVICE_INUSE) && (usb_event_flag == 1)) {
// if((hid_device.DEV_STATE == USB_DEVICE_INUSE)) {
process_mouse_buffer((uchar *)buffer);
//_usb_event_clear(&USB_Event, USB_EVENT_CTRL | USB_EVENT_DATA);
}
//else {
// /* kick the outer loop again to handle the CTRL event */
// _usb_event_set(&USB_Event, USB_EVENT_CTRL);
// break;
//}
break;
case USB_DEVICE_DETACHED:
check = 0;
printf("Going to idle state\n");
hid_device.DEV_STATE = USB_DEVICE_IDLE;
break;
case USB_DEVICE_OTHER:
break;
default:
printf("Unknown Mouse Device State = %d\n", hid_device.DEV_STATE);
//fflush(stdout);
break;
} /* Endswitch */
} /* Endbody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : Keyboard_Task
* Returned Value : none
* Comments :
* Execution starts here
*
*END*--------------------------------------------------------------------*/
void Printer_Task(uchar *buffer)
{
USB_STATUS status = USB_OK;
switch (printer_device.DEV_STATE)
{
case USB_DEVICE_IDLE:
break;
case USB_DEVICE_ATTACHED:
printer_device.DEV_STATE = USB_DEVICE_SET_INTERFACE_STARTED;
status = _usb_hostdev_select_interface(printer_device.DEV_HANDLE, printer_device.INTF_HANDLE, (pointer) & printer_device.CLASS_INTF);
if(status != USB_OK)
{
printf("\nError in _usb_hostdev_select_interface! STATUS: 0x%x",(unsigned int) status);
fflush(stdout);
exit(1);
}
break;
case USB_DEVICE_SET_INTERFACE_STARTED:
break;
case USB_DEVICE_INTERFACED:
/* Get string ID */
status = usb_printer_get_device_ID((pointer)&printer_device.CLASS_INTF,
usb_host_printer_ctrl_callback,
NULL,
USB_PRINTER_DEVICE_ID_MAX_SIZE,
string_id_buffer);
if(status != USB_STATUS_TRANSFER_QUEUED)
{
printf("\nError in usb_printer_get_device_ID! STATUS: 0x%x", status);
fflush(stdout);
}
break;
case USB_DEVICE_INUSE:
if(FALSE == get_string_ID_complete)
{
get_string_ID_complete = TRUE;
usb_host_show_info_device();
b_language = usb_host_get_language_printer();
}
if(TRUE == b_language)
{
/* Main Menu */
usb_host_menu_main();
}
else
{
printf("\nThe printer device language is not supported ! \n");
printf("Can't print !\n");
printer_device.DEV_STATE = USB_DEVICE_IDLE;
}
break;
case USB_DEVICE_DETACHED:
get_string_ID_complete = FALSE;
printf("Going to idle state\n");
printer_device.DEV_STATE = USB_DEVICE_IDLE;
break;
default:
printf ( "Unknown Printer Device State = %d\n",\
(int)printer_device.DEV_STATE );
break;
}
}
void usb_host_cdc_acm_event
(
/* [IN] pointer to device instance */
_usb_device_instance_handle dev_handle,
/* [IN] pointer to interface descriptor */
_usb_interface_descriptor_handle intf_handle,
/* [IN] code number for event causing callback */
uint_32 event_code
)
{ /* Body */
INTERFACE_DESCRIPTOR_PTR intf_ptr = (INTERFACE_DESCRIPTOR_PTR)intf_handle;
ACM_DEVICE_STRUCT_PTR acm_device;
#if 0 /* << EST */
fflush(stdout);
#endif
switch (event_code)
{
case USB_CONFIG_EVENT:
/* Drop through into attach, same processing */
case USB_ATTACH_EVENT:
{
USB_CDC_DESC_ACM_PTR acm_desc = NULL;
USB_CDC_DESC_CM_PTR cm_desc = NULL;
USB_CDC_DESC_HEADER_PTR header_desc = NULL;
USB_CDC_DESC_UNION_PTR union_desc = NULL;
int_32 external_data = 0;
/* finds all the descriptors in the configuration */
if (USB_OK != usb_class_cdc_get_acm_descriptors(dev_handle,
intf_handle,
&acm_desc,
&cm_desc,
&header_desc,
&union_desc))
break;
/* we can allocate new acm device */
if (NULL == (acm_device = USB_mem_alloc_zero(sizeof(ACM_DEVICE_STRUCT))))
break;
/* initialize new interface members and select this interface */
if (USB_OK != _usb_hostdev_select_interface(dev_handle,
intf_handle, (pointer)&acm_device->CLASS_INTF))
{
free(acm_device);
break;
}
/* set all info got from descriptors to the class interface struct */
usb_class_cdc_set_acm_descriptors((pointer)&acm_device->CLASS_INTF,
acm_desc, cm_desc, header_desc, union_desc);
/* link all already registered data interfaces to this ACM control, if needed */
if (USB_OK != usb_class_cdc_bind_data_interfaces(dev_handle, (pointer)&acm_device->CLASS_INTF))
{
free(acm_device);
break;
}
#if 0 /* << EST */
printf("----- CDC control interface attach Event -----\n");
fflush(stdout);
printf("State = attached");
printf(" Class = %%d", intf_ptr->bInterfaceClass);
printf(" SubClass = %%d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %%d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
#endif
check_open = 0;
break;
}
case USB_INTF_EVENT:
{
CLASS_CALL_STRUCT_PTR acm_parser;
USB_STATUS status;
if (NULL == (acm_parser = usb_class_cdc_get_ctrl_interface(intf_handle)))
break;
status = usb_class_cdc_init_ipipe(acm_parser);
if ((status != USB_OK) && (status != USBERR_OPEN_PIPE_FAILED))
break;
#if 0 /* << EST */
printf("----- CDC control interface selected -----\n");
#endif
break;
}
case USB_DETACH_EVENT:
{
CLASS_CALL_STRUCT_PTR acm_parser;
USB_ACM_CLASS_INTF_STRUCT_PTR if_ptr;
if (NULL == (acm_parser = usb_class_cdc_get_ctrl_interface(intf_handle)))
break;
if_ptr = (USB_ACM_CLASS_INTF_STRUCT_PTR) acm_parser->class_intf_handle;
_usb_event_set(&if_ptr->acm_event, USB_ACM_DETACH); /* mark we are not using input pipe */
/* Allow tasks waiting for acm to be finished...
** This does have sense only if this task will not be active
** or scheduler switches to another task.
** For simplification, we dont use any semaphore to indicate that
** all tasks have finished its job with device. Instead, we have just
** informed them that device is detached and we rely on USB stack layer
** that it checking if the device is available returns false.
** The code that would synchronize tasks to be finished would look like:
**
** _lwsem_wait(if_ptr->device_using_tasks);
*/
usb_class_cdc_unbind_data_interfaces(acm_parser);
USB_unlock();
free(acm_parser);
/* Use only the interface with desired protocol */
#if 0 /* << EST */
printf("----- CDC control interface detach event -----\n");
fflush(stdout);
printf("State = detached");
printf(" Class = %%d", intf_ptr->bInterfaceClass);
printf(" SubClass = %%d", intf_ptr->bInterfaceSubClass);
printf(" Protocol = %%d\n", intf_ptr->bInterfaceProtocol);
fflush(stdout);
#endif
break;
}
break;
default:
#if 0 /* << EST */
printf("CDC device: unknown control event\n");
fflush(stdout);
#endif
break;
} /* EndSwitch */
} /* Endbody */
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;
}
}
}
