void USBH_HID_EventCallback(USBH_HandleTypeDef *phost) {
if (USBH_HID_GetDeviceType(&hUSBHost) == HID_MOUSE) {
HID_MOUSE_Info_TypeDef *m_pinfo_mouse;
m_pinfo_mouse = USBH_HID_GetMouseInfo(phost);
if (m_pinfo_mouse) {
// USBH_DbgLog("btns:%u%u%u", m_pinfo_mouse->buttons[0],m_pinfo_mouse->buttons[1],m_pinfo_mouse->buttons[2]);
hid_buttons[0] = m_pinfo_mouse->buttons[0];
hid_buttons[1] = m_pinfo_mouse->buttons[1];
hid_buttons[2] = m_pinfo_mouse->buttons[2];
hid_mouse_x += m_pinfo_mouse->x;
hid_mouse_y += m_pinfo_mouse->y;
} else {
hid_buttons[0] = 0;
hid_buttons[1] = 0;
hid_buttons[2] = 0;
}
USBH_DbgLog("btns:%u%u%u", hid_buttons[0],hid_buttons[1],hid_buttons[2]);
}
else if (USBH_HID_GetDeviceType(&hUSBHost) == HID_KEYBOARD) {
HID_KEYBD_Info_TypeDef *m_pinfo_keyb;
m_pinfo_keyb = USBH_HID_GetKeybdInfo(phost);
if (m_pinfo_keyb) {
if (m_pinfo_keyb->lshift) {
USBH_DbgLog("ls");
}
if (m_pinfo_keyb->rshift) {
USBH_DbgLog("rs");
}
}
}
}
/**
* @brief USBH_CDC_InterfaceInit
* The function init the CDC class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_CDC_InterfaceInit (USBH_HandleTypeDef *phost)
{
USBH_StatusTypeDef status = USBH_FAIL ;
uint8_t interface;
CDC_HandleTypeDef *CDC_Handle;
interface = USBH_FindInterface(phost,
COMMUNICATION_INTERFACE_CLASS_CODE,
ABSTRACT_CONTROL_MODEL,
COMMON_AT_COMMAND);
if(interface == 0xFF) /* No Valid Interface */
{
USBH_DbgLog ("Cannot Find the interface for Communication Interface Class.", phost->pActiveClass->Name);
}
else
{
USBH_SelectInterface (phost, interface);
phost->pActiveClass->pData = (CDC_HandleTypeDef *)USBH_malloc (sizeof(CDC_HandleTypeDef));
CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
/*Collect the notification endpoint address and length*/
if(phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].bEndpointAddress & 0x80)
{
CDC_Handle->CommItf.NotifEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].bEndpointAddress;
CDC_Handle->CommItf.NotifEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].wMaxPacketSize;
}
/*Allocate the length for host channel number in*/
CDC_Handle->CommItf.NotifPipe = USBH_AllocPipe(phost, CDC_Handle->CommItf.NotifEp);
/* Open pipe for Notification endpoint */
USBH_OpenPipe (phost,
CDC_Handle->CommItf.NotifPipe,
CDC_Handle->CommItf.NotifEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_INTR,
CDC_Handle->CommItf.NotifEpSize);
USBH_LL_SetToggle (phost, CDC_Handle->CommItf.NotifPipe, 0);
interface = USBH_FindInterface(phost,
DATA_INTERFACE_CLASS_CODE,
RESERVED,
NO_CLASS_SPECIFIC_PROTOCOL_CODE);
if(interface == 0xFF) /* No Valid Interface */
{
USBH_DbgLog ("Cannot Find the interface for Data Interface Class.", phost->pActiveClass->Name);
}
else
{
/*Collect the class specific endpoint address and length*/
if(phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].bEndpointAddress & 0x80)
{
CDC_Handle->DataItf.InEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].bEndpointAddress;
CDC_Handle->DataItf.InEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].wMaxPacketSize;
}
else
{
CDC_Handle->DataItf.OutEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].bEndpointAddress;
CDC_Handle->DataItf.OutEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[0].wMaxPacketSize;
}
if(phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[1].bEndpointAddress & 0x80)
{
CDC_Handle->DataItf.InEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[1].bEndpointAddress;
CDC_Handle->DataItf.InEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[1].wMaxPacketSize;
}
else
{
CDC_Handle->DataItf.OutEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[1].bEndpointAddress;
CDC_Handle->DataItf.OutEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[1].wMaxPacketSize;
}
/*Allocate the length for host channel number out*/
CDC_Handle->DataItf.OutPipe = USBH_AllocPipe(phost, CDC_Handle->DataItf.OutEp);
/*Allocate the length for host channel number in*/
CDC_Handle->DataItf.InPipe = USBH_AllocPipe(phost, CDC_Handle->DataItf.InEp);
/* Open channel for OUT endpoint */
USBH_OpenPipe (phost,
CDC_Handle->DataItf.OutPipe,
CDC_Handle->DataItf.OutEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
CDC_Handle->DataItf.OutEpSize);
/* Open channel for IN endpoint */
USBH_OpenPipe (phost,
CDC_Handle->DataItf.InPipe,
CDC_Handle->DataItf.InEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
CDC_Handle->DataItf.InEpSize);
CDC_Handle->state = CDC_IDLE_STATE;
USBH_LL_SetToggle (phost, CDC_Handle->DataItf.OutPipe,0);
USBH_LL_SetToggle (phost, CDC_Handle->DataItf.InPipe,0);
status = USBH_OK;
}
}
return status;
}
/**
* @brief USBH_HID_InterfaceInit
* The function init the HID class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_HID_InterfaceInit (USBH_HandleTypeDef *phost)
{
uint8_t max_ep;
uint8_t num = 0;
uint8_t interface;
USBH_StatusTypeDef status = USBH_FAIL ;
HID_HandleTypeDef *HID_Handle;
interface = USBH_FindInterface(phost, phost->pActiveClass->ClassCode, HID_BOOT_CODE, 0xFF);
if(interface == 0xFF) /* No Valid Interface */
{
status = USBH_FAIL;
USBH_DbgLog ("Cannot Find the interface for %s class.", phost->pActiveClass->Name);
}
else
{
USBH_SelectInterface (phost, interface);
phost->pActiveClass->pData = (HID_HandleTypeDef *)USBH_malloc (sizeof(HID_HandleTypeDef));
HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData;
HID_Handle->state = HID_ERROR;
/*Decode Bootclass Protocol: Mouse or Keyboard*/
if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bInterfaceProtocol == HID_KEYBRD_BOOT_CODE)
{
USBH_UsrLog ("KeyBoard device found!");
HID_Handle->Init = USBH_HID_KeybdInit;
}
else if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bInterfaceProtocol == HID_MOUSE_BOOT_CODE)
{
USBH_UsrLog ("Mouse device found!");
HID_Handle->Init = USBH_HID_MouseInit;
}
else
{
USBH_UsrLog ("Protocol not supported.");
return USBH_FAIL;
}
HID_Handle->state = HID_INIT;
HID_Handle->ctl_state = HID_REQ_INIT;
HID_Handle->ep_addr = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress;
HID_Handle->length = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
HID_Handle->poll = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bInterval ;
if (HID_Handle->poll < HID_MIN_POLL)
{
HID_Handle->poll = HID_MIN_POLL;
}
/* Check fo available number of endpoints */
/* Find the number of EPs in the Interface Descriptor */
/* Choose the lower number in order not to overrun the buffer allocated */
max_ep = ( (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bNumEndpoints <= USBH_MAX_NUM_ENDPOINTS) ?
phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bNumEndpoints :
USBH_MAX_NUM_ENDPOINTS);
/* Decode endpoint IN and OUT address from interface descriptor */
for ( ;num < max_ep; num++)
{
if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress & 0x80)
{
HID_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress);
HID_Handle->InPipe =\
USBH_AllocPipe(phost, HID_Handle->InEp);
/* Open pipe for IN endpoint */
USBH_OpenPipe (phost,
HID_Handle->InPipe,
HID_Handle->InEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_INTR,
HID_Handle->length);
USBH_LL_SetToggle (phost, HID_Handle->InPipe, 0);
}
else
{
HID_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress);
HID_Handle->OutPipe =\
USBH_AllocPipe(phost, HID_Handle->OutEp);
/* Open pipe for OUT endpoint */
USBH_OpenPipe (phost,
HID_Handle->OutPipe,
HID_Handle->OutEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_INTR,
HID_Handle->length);
USBH_LL_SetToggle (phost, HID_Handle->OutPipe, 0);
}
}
status = USBH_OK;
}
return status;
}
//TODO: need incoming port number
void MIDI_CB(uint8_t a,uint8_t b,uint8_t c,uint8_t d){
USBH_DbgLog("M %x - %x %x %x\r\n",a,b,c,d);
// a= pkt header 0xF0 = cable number 0x0F=CIN
MidiInMsgHandler(MIDI_DEVICE_USB_HOST, ((a & 0xF0) >> 4)+ 1 ,b,c,d);
}
/**
* @brief MTP_DecodeEvent
* Decode device event sent by responder
* @param phost: Host handle
* @retval None
*/
static void MTP_DecodeEvent (USBH_HandleTypeDef *phost)
{
MTP_HandleTypeDef *MTP_Handle = phost->pActiveClass->pData;
uint16_t code;
uint32_t param1;
/* Process the event */
code = MTP_Handle->events.container.code;
param1 = MTP_Handle->events.container.param1;
switch(code)
{
case PTP_EC_Undefined:
USBH_DbgLog("EVT: PTP_EC_Undefined in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_CancelTransaction:
USBH_DbgLog("EVT: PTP_EC_CancelTransaction in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_ObjectAdded:
USBH_DbgLog("EVT: PTP_EC_ObjectAdded in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_ObjectRemoved:
USBH_DbgLog("EVT: PTP_EC_ObjectRemoved in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_StoreAdded:
USBH_DbgLog("EVT: PTP_EC_StoreAdded in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_StoreRemoved:
USBH_DbgLog("EVT: PTP_EC_StoreRemoved in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_DevicePropChanged:
USBH_DbgLog("EVT: PTP_EC_DevicePropChanged in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_ObjectInfoChanged:
USBH_DbgLog("EVT: PTP_EC_ObjectInfoChanged in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_DeviceInfoChanged:
USBH_DbgLog("EVT: PTP_EC_DeviceInfoChanged in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_RequestObjectTransfer:
USBH_DbgLog("EVT: PTP_EC_RequestObjectTransfer in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_StoreFull:
USBH_DbgLog("EVT: PTP_EC_StoreFull in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_DeviceReset:
USBH_DbgLog("EVT: PTP_EC_DeviceReset in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_StorageInfoChanged :
USBH_DbgLog( "EVT: PTP_EC_StorageInfoChanged in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_CaptureComplete :
USBH_DbgLog( "EVT: PTP_EC_CaptureComplete in session %u", MTP_Handle->ptp.session_id);
break;
case PTP_EC_UnreportedStatus :
USBH_DbgLog( "EVT: PTP_EC_UnreportedStatus in session %u", MTP_Handle->ptp.session_id);
break;
default :
USBH_DbgLog( "Received unknown event in session %u", MTP_Handle->ptp.session_id);
break;
}
USBH_MTP_EventsCallback(phost, code, param1);
}
/**
* @brief USBH_MTP_Process
* The function is for managing state machine for MTP data transfers
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_MTP_Process (USBH_HandleTypeDef *phost)
{
USBH_StatusTypeDef status = USBH_BUSY;
MTP_HandleTypeDef *MTP_Handle = phost->pActiveClass->pData;
uint32_t idx = 0;
switch(MTP_Handle->state)
{
case MTP_OPENSESSION:
status = USBH_PTP_OpenSession (phost, 1); /* Session '0' is not valid */
if(status == USBH_OK)
{
USBH_UsrLog("MTP Session #0 Opened");
MTP_Handle->state = MTP_GETDEVICEINFO;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
}
break;
case MTP_GETDEVICEINFO:
status = USBH_PTP_GetDeviceInfo (phost, &(MTP_Handle->info.devinfo));
if(status == USBH_OK)
{
USBH_DbgLog(">>>>> MTP Device Information");
USBH_DbgLog("Standard version : %x", MTP_Handle->info.devinfo.StandardVersion);
USBH_DbgLog("Vendor ExtID : %s", (MTP_Handle->info.devinfo.VendorExtensionID == 6)?"MTP": "NOT SUPPORTED");
USBH_DbgLog("Functional mode : %s", (MTP_Handle->info.devinfo.FunctionalMode == 0) ? "Standard" : "Vendor");
USBH_DbgLog("Number of Supported Operation(s) : %d", MTP_Handle->info.devinfo.OperationsSupported_len);
USBH_DbgLog("Number of Supported Events(s) : %d", MTP_Handle->info.devinfo.EventsSupported_len);
USBH_DbgLog("Number of Supported Proprieties : %d", MTP_Handle->info.devinfo.DevicePropertiesSupported_len);
USBH_DbgLog("Manufacturer : %s", MTP_Handle->info.devinfo.Manufacturer);
USBH_DbgLog("Model : %s", MTP_Handle->info.devinfo.Model);
USBH_DbgLog("Device version : %s", MTP_Handle->info.devinfo.DeviceVersion);
USBH_DbgLog("Serial number : %s", MTP_Handle->info.devinfo.SerialNumber);
MTP_Handle->state = MTP_GETSTORAGEIDS;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
}
break;
case MTP_GETSTORAGEIDS:
status = USBH_PTP_GetStorageIds (phost, &(MTP_Handle->info.storids));
if(status == USBH_OK)
{
USBH_DbgLog("Number of storage ID items : %d", MTP_Handle->info.storids.n);
for (idx = 0; idx < MTP_Handle->info.storids.n; idx ++)
{
USBH_DbgLog("storage#%d ID : %x", idx, MTP_Handle->info.storids.Storage[idx]);
}
MTP_Handle->current_storage_unit = 0;
MTP_Handle->state = MTP_GETSTORAGEINFO;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
}
break;
case MTP_GETSTORAGEINFO:
status = USBH_PTP_GetStorageInfo (phost,
MTP_Handle->info.storids.Storage[MTP_Handle->current_storage_unit],
&((MTP_Handle->info.storinfo)[MTP_Handle->current_storage_unit]));
if(status == USBH_OK)
{
USBH_UsrLog("Volume#%lu: %s [%s]", MTP_Handle->current_storage_unit,
MTP_Handle->info.storinfo[MTP_Handle->current_storage_unit].StorageDescription,
MTP_Handle->info.storinfo[MTP_Handle->current_storage_unit].VolumeLabel);
if(++MTP_Handle->current_storage_unit >= MTP_Handle->info.storids.n)
{
MTP_Handle->state = MTP_IDLE;
MTP_Handle->is_ready = 1;
MTP_Handle->current_storage_unit = 0;
MTP_Handle->params.CurrentStorageId = MTP_Handle->info.storids.Storage[0];
USBH_UsrLog( "MTP Class initialized.");
USBH_UsrLog("%s is default storage unit", MTP_Handle->info.storinfo[0].StorageDescription);
phost->pUser(phost, HOST_USER_CLASS_ACTIVE);
}
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
}
break;
case MTP_IDLE:
USBH_MTP_Events(phost);
#if (USBH_USE_OS == 1)
osDelay(10);
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
default:
status = USBH_OK;
break;
}
return status;
}
/**
* @brief USBH_MTP_InterfaceInit
* The function init the MTP class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_MTP_InterfaceInit (USBH_HandleTypeDef *phost)
{
USBH_StatusTypeDef status = USBH_OK ;
uint8_t interface, endpoint;
MTP_HandleTypeDef *MTP_Handle;
interface = USBH_FindInterface(phost,
USB_MTP_CLASS,
1,
1);
if(interface == 0xFF) /* No Valid Interface */
{
status = USBH_FAIL;
USBH_DbgLog ("Cannot Find the interface for Still Image Class.");
}
else
{
USBH_SelectInterface (phost, interface);
endpoint = MTP_FindCtlEndpoint(phost);
phost->pActiveClass->pData = (MTP_HandleTypeDef *)USBH_malloc (sizeof(MTP_HandleTypeDef));
MTP_Handle = phost->pActiveClass->pData;
if( MTP_Handle == NULL)
{
status = USBH_FAIL;
USBH_DbgLog ("Cannot allocate RAM for MTP Handle");
}
/*Collect the control endpoint address and length*/
MTP_Handle->NotificationEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].bEndpointAddress;
MTP_Handle->NotificationEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].wMaxPacketSize;
MTP_Handle->NotificationPipe = USBH_AllocPipe(phost, MTP_Handle->NotificationEp);
MTP_Handle->events.poll = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].bInterval;
/* Open pipe for Notification endpoint */
USBH_OpenPipe (phost,
MTP_Handle->NotificationPipe,
MTP_Handle->NotificationEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_INTR,
MTP_Handle->NotificationEpSize);
USBH_LL_SetToggle (phost, MTP_Handle->NotificationPipe, 0);
endpoint = MTP_FindDataInEndpoint(phost);
/*Collect the control endpoint address and length*/
MTP_Handle->DataInEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].bEndpointAddress;
MTP_Handle->DataInEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].wMaxPacketSize;
MTP_Handle->DataInPipe = USBH_AllocPipe(phost, MTP_Handle->DataInEp);
/* Open pipe for DATA IN endpoint */
USBH_OpenPipe (phost,
MTP_Handle->DataInPipe,
MTP_Handle->DataInEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
MTP_Handle->DataInEpSize);
USBH_LL_SetToggle (phost, MTP_Handle->DataInPipe, 0);
endpoint = MTP_FindDataOutEndpoint(phost);
/*Collect the DATA OUT endpoint address and length*/
MTP_Handle->DataOutEp = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].bEndpointAddress;
MTP_Handle->DataOutEpSize = phost->device.CfgDesc.Itf_Desc[interface].Ep_Desc[endpoint].wMaxPacketSize;
MTP_Handle->DataOutPipe = USBH_AllocPipe(phost, MTP_Handle->DataOutEp);
/* Open pipe for DATA OUT endpoint */
USBH_OpenPipe (phost,
MTP_Handle->DataOutPipe,
MTP_Handle->DataOutEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
MTP_Handle->DataOutEpSize);
USBH_LL_SetToggle (phost, MTP_Handle->DataOutPipe, 0);
MTP_Handle->state = MTP_OPENSESSION;
MTP_Handle->is_ready = 0;
MTP_Handle->events.state = MTP_EVENTS_INIT;
return USBH_PTP_Init(phost);
}
return status;
}
/**
* @brief USBH_MSC_InterfaceInit
* The function init the MSC class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_MSC_InterfaceInit (USBH_HandleTypeDef *phost)
{
uint8_t interface = 0;
USBH_StatusTypeDef status = USBH_FAIL ;
MSC_HandleTypeDef *MSC_Handle;
interface = USBH_FindInterface(phost, phost->pActiveClass->ClassCode, MSC_TRANSPARENT, MSC_BOT);
if(interface == 0xFF) /* Not Valid Interface */
{
USBH_DbgLog ("Cannot Find the interface for %s class.", phost->pActiveClass->Name);
status = USBH_FAIL;
}
else
{
USBH_SelectInterface (phost, interface);
phost->pActiveClass->pData = (MSC_HandleTypeDef *)USBH_malloc (sizeof(MSC_HandleTypeDef));
MSC_Handle = (MSC_HandleTypeDef *) phost->pActiveClass->pData;
if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress & 0x80)
{
MSC_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress);
MSC_Handle->InEpSize = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
}
else
{
MSC_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress);
MSC_Handle->OutEpSize = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
}
if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress & 0x80)
{
MSC_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress);
MSC_Handle->InEpSize = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].wMaxPacketSize;
}
else
{
MSC_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress);
MSC_Handle->OutEpSize = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].wMaxPacketSize;
}
MSC_Handle->current_lun = 0;
MSC_Handle->rw_lun = 0;
MSC_Handle->state = MSC_INIT;
MSC_Handle->error = MSC_OK;
MSC_Handle->req_state = MSC_REQ_IDLE;
MSC_Handle->OutPipe = USBH_AllocPipe(phost, MSC_Handle->OutEp);
MSC_Handle->InPipe = USBH_AllocPipe(phost, MSC_Handle->InEp);
USBH_MSC_BOT_Init(phost);
/* De-Initialize LUNs information */
USBH_memset(MSC_Handle->unit, 0, sizeof(MSC_Handle->unit));
/* Open the new channels */
USBH_OpenPipe (phost,
MSC_Handle->OutPipe,
MSC_Handle->OutEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
MSC_Handle->OutEpSize);
USBH_OpenPipe (phost,
MSC_Handle->InPipe,
MSC_Handle->InEp,
phost->device.address,
phost->device.speed,
USB_EP_TYPE_BULK,
MSC_Handle->InEpSize);
USBH_LL_SetToggle (phost, MSC_Handle->InPipe,0);
USBH_LL_SetToggle (phost, MSC_Handle->OutPipe,0);
status = USBH_OK;
}
return status;
}
