/*FUNCTION*------------------------------------------------------------- * * Function Name : _usb_host_close_all_pipes * Returned Value : None * Comments : * _usb_host_close_all_pipes routine removes the pipe from the open pipe list * *END*-----------------------------------------------------------------*/ void _usb_host_close_all_pipes ( /* [IN] the USB Host state structure */ _usb_host_handle handle ) { /* Body */ USB_HOST_STATE_STRUCT_PTR usb_host_ptr; PIPE_STRUCT_PTR pipe_ptr, pipe_bkp_ptr; TR_STRUCT_PTR tr_ptr, tr_ptr_next; usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_all_pipes"); #endif USB_lock(); for (pipe_ptr = usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR; pipe_ptr != NULL; pipe_ptr = pipe_ptr->NEXT) { if (pipe_ptr->OPEN) { /* Call the low-level routine to free the controller specific resources for this pipe */ _usb_host_close_pipe_call_interface (handle, pipe_ptr); /* before cleaning pipe_ptr struct we need to deallocate structures in the circullar list */ if (pipe_ptr->tr_list_ptr != NULL) { tr_ptr = pipe_ptr->tr_list_ptr; do { tr_ptr_next = tr_ptr->NEXT; /* free transaction belonging to this pipe */ USB_mem_free(tr_ptr); tr_ptr = tr_ptr_next; } while (tr_ptr != pipe_ptr->tr_list_ptr); //pipe_ptr->tr_list_ptr = NULL; //this will be done later by zeroing pipe_ptr } /* de-initialise the pipe descriptor, but prevent the chain */ pipe_bkp_ptr = pipe_ptr->NEXT; USB_mem_zero(pipe_ptr, sizeof(PIPE_STRUCT)); /* restore the chain */ pipe_ptr->NEXT = pipe_bkp_ptr; } /* Endif */ } /* Endfor */ USB_unlock(); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_all_pipes SUCCESSFUL"); #endif } /* Endbody */
/*FUNCTION*------------------------------------------------------------- * * Function Name : _usb_dev_driver_install * Returned Value : None * Comments : * Installs the device *END*-----------------------------------------------------------------*/ uint_8 _usb_dev_driver_install ( /* [IN] device number */ uint_32 device_number, /* [IN] address if the callback functions structure */ pointer callback_struct_ptr ) { /* Body */ pointer callback_struct_table_ptr; callback_struct_table_ptr = _mqx_get_io_component_handle(IO_USB_COMPONENT); if (!callback_struct_table_ptr) { callback_struct_table_ptr = USB_mem_alloc_zero((BSP_MAX_USB_DRIVERS * sizeof(USB_DEV_CALLBACK_FUNCTIONS_STRUCT))); if (!callback_struct_table_ptr) { #if _DEBUG printf("memalloc failed in _usb_driver_install\n"); #endif return USBERR_DRIVER_INSTALL_FAILED; } /* Endif */ USB_mem_zero((uint_8_ptr)callback_struct_table_ptr, sizeof(callback_struct_table_ptr)); _mqx_set_io_component_handle(IO_USB_COMPONENT, callback_struct_table_ptr); } /* Endif */ *((USB_DEV_CALLBACK_FUNCTIONS_STRUCT_PTR)\ (((USB_DEV_CALLBACK_FUNCTIONS_STRUCT_PTR)callback_struct_table_ptr) + device_number)) = *((USB_DEV_CALLBACK_FUNCTIONS_STRUCT_PTR)callback_struct_ptr); return USB_OK; } /* EndBody */
/*FUNCTION*---------------------------------------------------------------- * * Function Name : usb_dev_list_attach_device * Returned Value : * Comments : * This function will be called when attach interrupt happens, to * add onto the device list and do common initialization. * *END*--------------------------------------------------------------------*/ USB_STATUS usb_dev_list_attach_device ( _usb_host_handle handle, uint_8 speed, uint_8 hub_no, uint_8 port_no ) { /* Body */ USB_STATUS status; DEV_INSTANCE_PTR new_instance_ptr, dev_instance_ptr, dev_instance_prev_ptr; PIPE_INIT_PARAM_STRUCT ctrl_pipe_init_params; USB_HOST_STATE_STRUCT_PTR usb_host_ptr; DEV_INSTANCE_PTR device_root = NULL; #ifdef __USB_OTG__ uint_32 state; #endif #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device attach device"); #endif usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle; /* Allocate new device instance */ new_instance_ptr = (DEV_INSTANCE_PTR) USB_mem_alloc_uncached(sizeof(DEV_INSTANCE)); if (new_instance_ptr == NULL) { #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device failed to malloc device handle"); #endif return USB_log_error(__FILE__,__LINE__, USBERR_GET_MEMORY_FAILED); } /* EndIf */ _mem_set_type(new_instance_ptr, MEM_TYPE_USB_HOST_STATE_STRUCT); USB_mem_zero(new_instance_ptr, sizeof(DEV_INSTANCE)); new_instance_ptr->host = handle; new_instance_ptr->speed = speed; new_instance_ptr->hub_no = hub_no; new_instance_ptr->port_no = port_no; new_instance_ptr->cfg_value = 0; /* We don't know yet what the device's default configuration is */ USB_lock(); /* Find unused address from 1 - 127 for this host */ dev_instance_ptr = usb_host_ptr->DEVICE_LIST_PTR; if ((dev_instance_ptr == NULL) || (dev_instance_ptr->address != 1)) { /* Insert at the beginning of list */ new_instance_ptr->address = 1; new_instance_ptr->next = dev_instance_ptr; usb_host_ptr->DEVICE_LIST_PTR = new_instance_ptr; } else { dev_instance_prev_ptr = dev_instance_ptr; /* Searching for a 'hole' in devices instance adresses */ while (dev_instance_ptr->address <= (dev_instance_prev_ptr->address + 1)) { new_instance_ptr->address = dev_instance_ptr->address; dev_instance_prev_ptr = dev_instance_ptr; dev_instance_ptr = dev_instance_ptr->next; if (dev_instance_ptr == NULL) break; } /* EndWhile */ if (new_instance_ptr->address >= 127) { /* If all 127 addresses used up, delete instance & bail out */ USB_unlock(); USB_mem_free((pointer)new_instance_ptr); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device out of addresses"); #endif return USB_log_error(__FILE__,__LINE__, USBERR_ADDRESS_ALLOC_FAILED); } /* EndIf */ new_instance_ptr->address++; new_instance_ptr->next = dev_instance_ptr; dev_instance_prev_ptr->next = new_instance_ptr; }; USB_unlock(); /*-----------------------------------------------------------** ** Open control pipe, get first 8 bytes of device descriptor ** ** The host_ch9 routine internally sets the callback to ** ** usb_host_cntrl_transaction_done (in usb_host_ch9.c) ** ** where the action resumes on completion of the get. ** **-----------------------------------------------------------*/ ctrl_pipe_init_params = pipe_init_params_prototype; ctrl_pipe_init_params.G.DEV_INSTANCE = new_instance_ptr; ctrl_pipe_init_params.G.PIPETYPE = USB_CONTROL_PIPE; ctrl_pipe_init_params.G.SPEED = new_instance_ptr->speed; ctrl_pipe_init_params.G.HUB_DEVICE_ADDR = hub_no; ctrl_pipe_init_params.G.HUB_PORT_NUM = port_no; #ifdef __USB_OTG__ _usb_otg_get_status((pointer)usb_otg_state_struct_ptr, USB_OTG_STATE, &state); if (state < B_IDLE) { _usb_otg_set_status((pointer)usb_otg_state_struct_ptr, USB_OTG_A_BUS_REQ, TRUE); _usb_otg_set_status((pointer)usb_otg_state_struct_ptr, USB_OTG_B_CONN, TRUE); } else { _usb_otg_set_status((pointer)usb_otg_state_struct_ptr, USB_OTG_A_CONN, TRUE); } /* Endif */ #endif if (USB_OK != _usb_host_open_pipe(new_instance_ptr->host, &ctrl_pipe_init_params, &new_instance_ptr->control_pipe)) { USB_mem_free((pointer)new_instance_ptr); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device open pipe failed"); #endif return USB_log_error(__FILE__,__LINE__, USBERR_PIPE_OPENED_FAILED); } /* Endif */ /* Set state to enter after transaction completion */ new_instance_ptr->state = DEVSTATE_DEVDESC8; status = _usb_host_ch9_get_descriptor((_usb_device_instance_handle)new_instance_ptr, USB_DESC_TYPE_DEV << 8, 0, 8, (uchar_ptr)&new_instance_ptr->dev_descriptor); if (status != USB_STATUS_TRANSFER_QUEUED) { new_instance_ptr->state = DEVSTATE_INITIAL; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device FAILED"); #endif return USB_log_error(__FILE__,__LINE__, USBERR_NO_DESCRIPTOR); } #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_dev_list_attach_device SUCCESSFUL"); #endif return USB_OK; } /* EndBody */
void usb_printer_init ( /* [IN] device/descriptor/pipe handles */ PIPE_BUNDLE_STRUCT_PTR pbs_ptr, /* [IN] class-interface data pointer + key */ CLASS_CALL_STRUCT_PTR prt_call_ptr ) { /* Body */ PRINTER_INTERFACE_STRUCT_PTR prt_intf; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_printer_init"); #endif /* Pointer validity-checking, clear memory, init header */ prt_intf = prt_call_ptr->class_intf_handle; if (USB_OK != usb_host_class_intf_init (pbs_ptr, (pointer)prt_intf, (pointer)&prt_anchor, NULL)) { #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_printer_init, error class init"); #endif return; } USB_lock(); prt_call_ptr->code_key = 0; prt_call_ptr->code_key = usb_host_class_intf_validate(prt_call_ptr); if (NULL == (prt_intf->control_pipe = usb_hostdev_get_pipe_handle (pbs_ptr, USB_CONTROL_PIPE, 0) )) goto Bad_Exit; if (NULL == (prt_intf->bulk_out_pipe = usb_hostdev_get_pipe_handle (pbs_ptr, USB_BULK_PIPE, USB_SEND) )) goto Bad_Exit; /* Uni-directional printers don't have a bulk-in pipe */ if (((INTERFACE_DESCRIPTOR_PTR)prt_intf->intf_handle)-> bInterfaceSubClass > USB_PROTOCOL_PRT_UNIDIR) { if (NULL == (prt_intf->bulk_in_pipe = usb_hostdev_get_pipe_handle (pbs_ptr, USB_BULK_PIPE, USB_RECV) )) goto Bad_Exit; } /* EndIf */ USB_unlock (); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_printer_init, SUCCESSFUL"); #endif return; /* Good exit, interface struct initialized */ Bad_Exit: USB_mem_zero (prt_intf,sizeof(PRINTER_INTERFACE_STRUCT_PTR)); prt_call_ptr->class_intf_handle = NULL; prt_call_ptr->code_key = 0; USB_unlock (); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_printer_init, bad exit"); #endif } /* Endbody */
/*FUNCTION*---------------------------------------------------------------- * * Function Name : Main_Task * Returned Value : None * Comments : * First function called. This function is the entry for * the PHDC Application * *END*--------------------------------------------------------------------*/ void Main_Task(uint_32 param) { /* Initialize Global Variable Structure */ PHDC_CONFIG_STRUCT phdc_config; phdc_config.phdc_callback.callback = USB_App_Callback; phdc_config.phdc_callback.arg = (void*)&g_bridge.handle; phdc_config.vendor_callback.callback = NULL; phdc_config.vendor_callback.arg = NULL; phdc_config.desc_callback_ptr = &desc_callback; phdc_config.info = &usb_desc_ep; USB_mem_zero(&g_bridge, sizeof(BRIDGE_GLOBAL_VARIABLE_STRUCT)); if (_lwevent_create(&lwevent,0) != MQX_OK) { #if _DEBUG printf("\nMake event failed : Main_Task"); #endif _task_block(); } g_usb_rx_buff_ptr = USB_mem_alloc_zero(PHDC_BULK_OUT_EP_SIZE); if(g_usb_rx_buff_ptr == NULL) { #if _DEBUG printf("g_usb_rx_buff_ptr malloc failed\n"); #endif } g_bridge_rx_buff_ptr = USB_mem_alloc_zero(PHDC_BULK_IN_EP_SIZE); if(g_bridge_rx_buff_ptr == NULL) { #if _DEBUG printf("g_bridge_rx_buff_ptr malloc failed\n"); #endif } _int_disable(); g_bridge.handle = USB_Class_PHDC_Init(&phdc_config); Bridge_Interface_Init(Bridge_Callback); _int_enable(); while(TRUE) { /* Block the task untill USB Enumeration is completed */ if(_lwevent_wait_for(&lwevent,USB_ENUM_COMPLETED,FALSE,NULL) != MQX_OK) { #if _DEBUG printf("USB_ENUM_COMPLETEDEvent Wait failed\n"); #endif _task_block(); } if(_lwevent_clear(&lwevent,USB_ENUM_COMPLETED) != MQX_OK) { #if _DEBUG printf("Enum Event Clear failed\n"); #endif _task_block(); } Bridge_Interface_Open(param); } }
static void usb_host_mass_test_storage ( void ) { /* Body */ USB_STATUS status = USB_OK; uint_8 bLun = 0; INQUIRY_DATA_FORMAT inquiry; CAPACITY_LIST capacity_list; #if 0 MODE_SELECT_PARAMETER_LIST md_list; #endif MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO read_capacity; REQ_SENSE_DATA_FORMAT req_sense; FORMAT_UNIT_PARAMETER_BLOCK formatunit = { 0}; _mqx_int block_len; DEVICE_DESCRIPTOR_PTR pdd; CBW_STRUCT_PTR cbw_ptr = pCmd->CBW_PTR; CSW_STRUCT_PTR csw_ptr = pCmd->CSW_PTR; USB_mem_zero(buff_out,0x0F); USB_mem_zero(buff_in,0x400C); USB_mem_zero(pCmd->CSW_PTR,sizeof(CSW_STRUCT)); USB_mem_zero(pCmd->CBW_PTR,sizeof(CBW_STRUCT)); USB_mem_zero(pCmd,sizeof(COMMAND_OBJECT_STRUCT)); pCmd->CBW_PTR = cbw_ptr; pCmd->CSW_PTR = csw_ptr; pCmd->LUN = bLun; pCmd->CALL_PTR = (pointer)&mass_device.class_intf; pCmd->CALLBACK = usb_host_mass_bulk_callback; printf("\n =============START OF A NEW SESSION=================="); if (USB_OK != _usb_hostdev_get_descriptor( mass_device.dev_handle, NULL, USB_DESC_TYPE_DEV, 0, 0, (pointer *) &pdd)) { printf ("\nCould not retrieve device descriptor."); return; } else printf("\nVID = 0x%04x, PID = 0x%04x", SHORT_LE_TO_HOST(*(uint_16*)pdd->idVendor), SHORT_LE_TO_HOST(*(uint_16*)pdd->idProduct)); /* Test the GET MAX LUN command */ printf("\nTesting: GET MAX LUN Command"); fflush(stdout); bCallBack = FALSE; status = usb_class_mass_getmaxlun_bulkonly( (pointer)&mass_device.class_intf, &bLun, usb_host_mass_ctrl_callback); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack) {;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the TEST UNIT READY command */ printf("Testing: TEST UNIT READY Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_test_unit_ready(pCmd); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the INQUIRY command */ printf("Testing: INQUIRY Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_inquiry(pCmd, (uchar_ptr) &inquiry, sizeof(INQUIRY_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the READ FORMAT CAPACITY command */ printf("Testing: READ FORMAT CAPACITIES Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_format_capacity(pCmd, (uchar_ptr)&capacity_list, sizeof(CAPACITY_LIST)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the READ CAPACITY command */ printf("Testing: READ CAPACITY Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_read_capacity(pCmd, (uchar_ptr)&read_capacity, sizeof(MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } block_len = HOST_TO_BE_LONG(* (uint_32 *) &read_capacity.BLENGTH); #if 0 /* Test the MODE SELECT command */ printf("Testing: MODE SELECT Command"); fflush(stdout); bCallBack = FALSE; //md_list. Fill parameters here USB_mem_zero (&md_list, sizeof (MODE_SELECT_PARAMETER_LIST)); md_list.MODE_PARAM_HEADER.BLENGTH[1] = 0x06; status = usb_mass_ufi_mode_select(pCmd, &md_list, 8); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } #endif /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the READ(10) command */ printf("Testing: READ(10) Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_read_10(pCmd, 0, buff_in, block_len, 1); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the MODE SENSE command */ printf("Testing: MODE SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_mode_sense(pCmd, 2, //PC 0x3F, //page code buff_in, (uint_32)0x08); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the PREVENT ALLOW command */ printf("Testing: PREVENT-ALLOW MEDIUM REMOVAL Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_prevent_allow_medium_removal( pCmd, 1 // prevent ); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the VERIFY command */ printf("Testing: VERIFY Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_verify( pCmd, 0x400, // block address 1 //length to be verified ); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the WRITE(10) command */ printf("Testing: WRITE(10) Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_write_10(pCmd, 8, buff_out, block_len, 1); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the REQUEST SENSE command */ printf("Testing: REQUEST SENSE Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_request_sense(pCmd, &req_sense, sizeof(REQ_SENSE_DATA_FORMAT)); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } /* Test the START-STOP UNIT command */ printf("Testing: START-STOP UNIT Command"); fflush(stdout); bCallBack = FALSE; status = usb_mass_ufi_start_stop(pCmd, 0, 1); if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED)) { printf ("\n...ERROR"); return; } else { /* Wait till command comes back */ while (!bCallBack){;} if (!bStatus) { printf("...OK\n"); } else { printf("...Unsupported by device (bStatus=0x%x)\n", bStatus); } } printf("\nTest done!"); fflush(stdout); } /* Endbody */
/**************************************************************************//*! * * @name USB_Class_CDC_Init * * @brief The funtion initializes the Device and Controller layer * * @param *cdc_config_ptr[IN]: This structure contians configuration parameter * send by APP to configure CDC class. * * @return status * USB_OK : When Successfull * Others : Errors ****************************************************************************** * *This function initializes the CDC Class layer and layers it is dependednt on * *****************************************************************************/ uint_32 USB_Class_CDC_Init ( CDC_CONFIG_STRUCT_PTR cdc_config_ptr ) { #if IMPLEMENT_QUEUING uint_8 index; #endif uint_8 error; CDC_HANDLE cdc_handle; CDC_DEVICE_STRUCT_PTR devicePtr = NULL; USB_ENDPOINTS *usb_ep_data; if (NULL == (void *)cdc_config_ptr) return USBERR_ERROR; devicePtr = (CDC_DEVICE_STRUCT_PTR)USB_mem_alloc_zero(sizeof(CDC_DEVICE_STRUCT)); if (NULL == devicePtr) { #if _DEBUG printf("memalloc failed in USB_Class_CDC_Init\n"); #endif return USBERR_ALLOC; } cdc_handle = USB_Cdc_Allocate_Handle(); if (USBERR_DEVICE_BUSY == cdc_handle) { USB_mem_free(devicePtr); devicePtr = NULL; return USBERR_INIT_FAILED; } /* initialize the Global Variable Structure */ USB_mem_zero(devicePtr, sizeof(CDC_DEVICE_STRUCT)); devicePtr->ep = cdc_config_ptr->ep; usb_ep_data = cdc_config_ptr->usb_ep_data; devicePtr->max_supported_interfaces = cdc_config_ptr->max_supported_interfaces; #if RNDIS_SUPPORT USB_mem_copy(cdc_config_ptr->mac_address, devicePtr->mac_address, sizeof(_enet_address)); devicePtr->ip_address = cdc_config_ptr->ip_address; devicePtr->rndis_max_frame_size = cdc_config_ptr->rndis_max_frame_size; #endif /* Initialize the device layer*/ error = _usb_device_init(USBCFG_DEFAULT_DEVICE_CONTROLLER, &devicePtr->controller_handle, (uint_8)(usb_ep_data->count+1)); /* +1 is for Control Endpoint */ if(error != USB_OK) { goto error1; } cdc_config_ptr->desc_callback_ptr->handle = cdc_handle; /* Initialize the generic class functions */ devicePtr->class_handle = USB_Class_Init(devicePtr->controller_handle, USB_Class_CDC_Event,USB_CDC_Other_Requests,(void *)devicePtr, cdc_config_ptr->desc_callback_ptr); /* Initialize the generic class functions */ #if PSTN_SUBCLASS_NOTIF_SUPPORT /* Initialize the pstn subclass functions */ error = USB_Pstn_Init(devicePtr,&cdc_config_ptr->param_callback); if(error != USB_OK) { goto error2; } #endif devicePtr->usb_ep_data = usb_ep_data; #if IMPLEMENT_QUEUING for(index = 0; index < usb_ep_data->count; index++) { devicePtr->ep[index].endpoint = usb_ep_data->ep[index].ep_num; devicePtr->ep[index].type = usb_ep_data->ep[index].type; devicePtr->ep[index].bin_consumer = 0x00; devicePtr->ep[index].bin_producer = 0x00; } #endif /* save the callback pointer */ devicePtr->cdc_class_cb.callback = cdc_config_ptr->cdc_class_cb.callback; devicePtr->cdc_class_cb.arg = cdc_config_ptr->cdc_class_cb.arg; /* save the callback pointer */ devicePtr->vendor_req_callback.callback = cdc_config_ptr->vendor_req_callback.callback; devicePtr->vendor_req_callback.arg = cdc_config_ptr->vendor_req_callback.arg; /* save the callback pointer */ devicePtr->param_callback.callback = cdc_config_ptr->param_callback.callback; devicePtr->param_callback.arg = cdc_config_ptr->param_callback.arg; devicePtr->comm_feature_data_size = cdc_config_ptr->comm_feature_data_size; devicePtr->cic_send_endpoint = cdc_config_ptr->cic_send_endpoint; devicePtr->cic_recv_endpoint = USB_CONTROL_ENDPOINT; devicePtr->dic_send_endpoint = cdc_config_ptr->dic_send_endpoint; devicePtr->dic_recv_endpoint = cdc_config_ptr->dic_recv_endpoint; devicePtr->dic_recv_pkt_size = cdc_config_ptr->dic_recv_pkt_size; devicePtr->dic_send_pkt_size = cdc_config_ptr->dic_send_pkt_size; devicePtr->cic_send_pkt_size = cdc_config_ptr->cic_send_pkt_size; devicePtr->cdc_handle = cdc_handle; cdc_device_array[cdc_handle] = devicePtr; return cdc_handle; error2: /* Implement Denit class and invoke here*/ error1: USB_Cdc_Free_Handle(cdc_handle); USB_mem_free(devicePtr); devicePtr = NULL; return error; }
void usb_class_mass_init ( /* [IN] structure with USB pipe information on the interface */ PIPE_BUNDLE_STRUCT_PTR pbs_ptr, /* [IN] printer call struct pointer */ CLASS_CALL_STRUCT_PTR ccs_ptr ) { /* Body */ USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr = ccs_ptr->class_intf_handle; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_mass_init"); #endif /* Pointer validity-checking, clear memory, init header of intf_ptr */ if (usb_host_class_intf_init(pbs_ptr, intf_ptr, &mass_anchor)) { #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_mass_init"); #endif return; } USB_lock(); ccs_ptr->code_key = 0; ccs_ptr->code_key = usb_host_class_intf_validate( ccs_ptr ); if (ccs_ptr->code_key == 0) goto Bad_Exit; /* Start filling up the members of interface handle (general class already filled) */ intf_ptr->CONTROL_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr, USB_CONTROL_PIPE, 0); intf_ptr->BULK_IN_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr, USB_BULK_PIPE, USB_RECV); intf_ptr->BULK_OUT_PIPE = usb_hostdev_get_pipe_handle(pbs_ptr, USB_BULK_PIPE, USB_SEND); if (intf_ptr->CONTROL_PIPE && intf_ptr->BULK_IN_PIPE && intf_ptr->BULK_OUT_PIPE) { /* Initialize the queue for storing the local copy of interface handles */ usb_class_mass_q_init(intf_ptr); /* Store application handle */ intf_ptr->APP = ccs_ptr; USB_unlock(); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_mass_init, SUCCESSFULL"); #endif return; } /* Endif */ Bad_Exit: #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_mass_init, bad exit"); #endif USB_mem_zero(intf_ptr, sizeof(USB_MASS_CLASS_INTF_STRUCT_PTR)); ccs_ptr->class_intf_handle = NULL; ccs_ptr->code_key = 0; USB_unlock(); } /* Endbody */
/*FUNCTION*------------------------------------------------------------- * * Function Name : _usb_host_close_pipe * Returned Value : None * Comments : * _usb_host_close_pipe routine removes the pipe from the open pipe list * *END*-----------------------------------------------------------------*/ USB_STATUS _usb_host_close_pipe ( /* [IN] the USB Host state structure */ _usb_host_handle handle, /* [IN] the pipe (handle) to close */ _usb_pipe_handle pipe_handle ) { /* Body */ USB_STATUS error; USB_HOST_STATE_STRUCT_PTR usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle; PIPE_STRUCT_PTR pipe_ptr = (PIPE_STRUCT_PTR)pipe_handle; PIPE_STRUCT_PTR pipe_bkp_ptr; TR_STRUCT_PTR tr_ptr, tr_ptr_next; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_pipe"); #endif if (pipe_ptr->PIPE_ID > USBCFG_MAX_PIPES) { #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_pipe invalid pipe"); #endif return USB_log_error(__FILE__,__LINE__,USBERR_INVALID_PIPE_HANDLE); } /* Endif */ USB_lock(); /* Call the low-level routine to free the controller specific resources */ error = _usb_host_close_pipe_call_interface (handle, pipe_ptr); if (error != USB_OK) { USB_unlock(); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_pipe FAILED"); #endif return USB_log_error(__FILE__,__LINE__,error); } /* Before cleaning pipe_ptr struct we have to make sure that structures in the circullar list are really deallocated */ /* Before deallocating structures in the list call the callback about failed pending transaction */ if (pipe_ptr->tr_list_ptr != NULL) { tr_ptr = pipe_ptr->tr_list_ptr; do { tr_ptr_next = tr_ptr->NEXT; if (tr_ptr->TR_INDEX !=0 && tr_ptr->CALLBACK != NULL) { if (tr_ptr->RX_BUFFER != NULL) { tr_ptr->CALLBACK((void *)pipe_ptr, tr_ptr->CALLBACK_PARAM, tr_ptr->RX_BUFFER, 0, USBERR_PIPE_CLOSED); } else { tr_ptr->CALLBACK((void *)pipe_ptr, tr_ptr->CALLBACK_PARAM, tr_ptr->TX_BUFFER, 0, USBERR_PIPE_CLOSED); } } /* free transaction belonging to this pipe */ USB_mem_free(tr_ptr); tr_ptr = tr_ptr_next; } while (tr_ptr != pipe_ptr->tr_list_ptr); //pipe_ptr->tr_list_ptr = NULL; //this will be done later by zeroing pipe_ptr } /* De-initialise the pipe descriptor, but preserve the chain */ pipe_bkp_ptr = pipe_ptr->NEXT; USB_mem_zero(pipe_ptr, usb_host_ptr->PIPE_SIZE); /* restore the chain */ pipe_ptr->NEXT = pipe_bkp_ptr; USB_unlock(); #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("_usb_host_close_pipe SUCCESSFUL"); #endif return USB_OK; } /* Endbody */