libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/imxrt/libraries/drivers/usb/host/usb_host_devices.c

1415 lines
53 KiB
C
Raw Normal View History

solve gcc build err
2019-12-26 14:10:06 +08:00
/*
* Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc.
* Copyright 2016 NXP
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* o Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <usb/include/usb_device_config.h>
#include "usb_host.h"
#include "usb_host_hci.h"
#include "usb_host_devices.h"
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
#include "usb_host_hub.h"
#endif /* USB_HOST_CONFIG_HUB */
/*******************************************************************************
* Definitions
******************************************************************************/
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief enumeration transfer callback function.
*
* @param param callback parameter.
* @param transfer the transfer.
* @param status transfer result status.
*/
static void USB_HostEnumerationTransferCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status);
/*!
* @brief process the new step state.
*
* @param deviceInstance device instance pointer.
*
* @return kStatus_USB_Success or error codes
*/
static usb_status_t USB_HostProcessState(usb_host_device_instance_t *deviceInstance);
/*!
* @brief process the previous step transfer result.
*
* @param deviceInstance device instance pointer.
*
* @return kStatus_USB_Success or error codes
*/
static usb_status_t USB_HostProcessCallback(usb_host_device_instance_t *deviceInstance);
/*!
* @brief notify the application event, the callback is registered when initializing host.
*
* @param deviceInstance device instance pointer.
* @param eventCode event code.
*
* @return kStatus_USB_Success or error codes
*/
static usb_status_t USB_HostNotifyDevice(usb_host_device_instance_t *deviceInstance, uint32_t eventCode);
/*!
* @brief allocate one address.
*
* @param hostInstance host instance pointer.
*
* @return address, 0 is invalid.
*/
static uint8_t USB_HostAllocateDeviceAddress(usb_host_instance_t *hostInstance);
/*!
* @brief release one address.
*
* @param hostInstance host instance pointer.
* @param address releasing address.
*/
static void USB_HostReleaseDeviceAddress(usb_host_instance_t *hostInstance, uint8_t address);
/*!
* @brief release device resource.
*
* @param hostInstance host instance pointer.
* @param deviceInstance device instance pointer.
*/
static void USB_HostReleaseDeviceResource(usb_host_instance_t *hostInstance,
usb_host_device_instance_t *deviceInstance);
/*!
* @brief parse device configuration descriptor.
*
* @param deviceHandle device handle.
*
* @return kStatus_USB_Success or error codes.
*/
static usb_status_t USB_HostParseDeviceConfigurationDescriptor(usb_device_handle deviceHandle);
/*!
* @brief remove device instance from host device list.
*
* @param hostHandle host instance handle.
* @param deviceHandle device handle.
*
* @return kStatus_USB_Success or error codes.
*/
static usb_status_t USB_HostRemoveDeviceInstance(usb_host_handle hostHandle, usb_device_handle deviceHandle);
/*!
* @brief control the bus.
*
* This function control the host bus.
*
* @param[in] hostHandle the host handle.
* @param[in] controlType the control code, please reference to bus_event_t.
*
* @retval kStatus_USB_Success control successfully.
* @retval kStatus_USB_InvalidHandle The hostHandle is a NULL pointer.
*/
static usb_status_t USB_HostControlBus(usb_host_handle hostHandle, uint8_t controlType);
extern usb_status_t USB_HostStandardSetGetDescriptor(usb_host_device_instance_t *deviceInstance,
usb_host_transfer_t *transfer,
void *param);
extern usb_status_t USB_HostStandardSetAddress(usb_host_device_instance_t *deviceInstance,
usb_host_transfer_t *transfer,
void *param);
extern usb_status_t USB_HostCh9RequestCommon(usb_host_device_instance_t *deviceInstance,
usb_host_transfer_t *transfer,
uint8_t *buffer,
uint32_t bufferLen);
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
extern usb_status_t USB_HostHubDeviceEvent(usb_host_handle hostHandle,
usb_device_handle deviceHandle,
usb_host_configuration_handle configurationHandle,
uint32_t eventCode);
extern uint32_t USB_HostHubGetHsHubNumber(usb_host_handle hostHandle, uint8_t parentHubNo);
extern uint32_t USB_HostHubGetHsHubPort(usb_host_handle hostHandle, uint8_t parentHubNo, uint8_t parentPortNo);
extern usb_status_t USB_HostHubRemovePort(usb_host_handle hostHandle, uint8_t hubNumber, uint8_t portNumber);
#endif
/*******************************************************************************
* Variables
******************************************************************************/
extern usb_host_instance_t g_UsbHostInstance[USB_HOST_CONFIG_MAX_HOST];
/*! @brief enumeration step process array */
static const usb_host_enum_process_entry_t s_EnumEntries[] = \
{
/* kStatus_dev_initial */
{
0, 0, NULL,
},
/* kStatus_DEV_GetDes8 */
{
kStatus_DEV_SetAddress, kStatus_DEV_GetDes8, USB_HostProcessCallback,
},
/* kStatus_DEV_SetAddress */
{
kStatus_DEV_GetDes, kStatus_DEV_SetAddress, USB_HostProcessCallback,
},
/* kStatus_DEV_GetDes */
{
kStatus_DEV_GetCfg9, kStatus_DEV_GetDes, NULL,
},
/* kStatus_DEV_GetCfg9 */
{
kStatus_DEV_GetCfg, kStatus_DEV_GetCfg9, USB_HostProcessCallback,
},
/* kStatus_DEV_GetCfg */
{
kStatus_DEV_SetCfg, kStatus_DEV_GetCfg9, USB_HostProcessCallback,
},
/* kStatus_DEV_SetCfg */
{
kStatus_DEV_EnumDone, kStatus_DEV_SetCfg, NULL,
},
};
/*******************************************************************************
* Code
******************************************************************************/
static void USB_HostEnumerationTransferCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status)
{
uint8_t nextStep = 0;
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)param;
USB_HostFreeTransfer(deviceInstance->hostHandle, transfer); /* free transfer */
if (status == kStatus_USB_Success)
{
nextStep = 1;
}
else if (status == kStatus_USB_TransferStall)
{
#if ((defined USB_HOST_CONFIG_COMPLIANCE_TEST) && (USB_HOST_CONFIG_COMPLIANCE_TEST))
usb_echo("no response from device\r\n");
#endif /* USB_HOST_CONFIG_COMPLIANCE_TEST */
if (deviceInstance->stallRetries > 0) /* retry same transfer when stall */
{
deviceInstance->stallRetries--;
}
else /* process next state when all retries stall */
{
nextStep = 1;
}
}
else if (status == kStatus_USB_TransferCancel)
{
return;
}
else
{
if (deviceInstance->enumRetries > 0) /* next whole retry */
{
deviceInstance->enumRetries--;
deviceInstance->stallRetries = USB_HOST_CONFIG_ENUMERATION_MAX_STALL_RETRIES;
deviceInstance->configurationValue = 0;
deviceInstance->state = kStatus_DEV_GetDes8;
}
else
{
#if ((defined USB_HOST_CONFIG_COMPLIANCE_TEST) && (USB_HOST_CONFIG_COMPLIANCE_TEST))
usb_echo("Device No Response\r\n");
#endif
return;
}
}
if (nextStep == 1)
{
deviceInstance->stallRetries = USB_HOST_CONFIG_ENUMERATION_MAX_STALL_RETRIES;
if (s_EnumEntries[deviceInstance->state - 1].process == NULL)
{
deviceInstance->state = s_EnumEntries[deviceInstance->state - 1].successState; /* next state */
}
else
{
status = s_EnumEntries[deviceInstance->state - 1].process(
deviceInstance); /* process the previous state result */
if (status == kStatus_USB_Success) /* process success */
{
deviceInstance->state = s_EnumEntries[deviceInstance->state - 1].successState;
}
else if (status == kStatus_USB_Retry) /* need retry */
{
deviceInstance->state = s_EnumEntries[deviceInstance->state - 1].retryState;
}
else if (status == kStatus_USB_NotSupported) /* device don't suport by the application */
{
return; /* unrecoverable fail */
}
else /* process error, next retry */
{
if (deviceInstance->enumRetries > 0) /* next whole retry */
{
deviceInstance->enumRetries--;
deviceInstance->stallRetries = USB_HOST_CONFIG_ENUMERATION_MAX_STALL_RETRIES;
deviceInstance->configurationValue = 0;
deviceInstance->state = kStatus_DEV_GetDes8;
}
else
{
#if ((defined USB_HOST_CONFIG_COMPLIANCE_TEST) && (USB_HOST_CONFIG_COMPLIANCE_TEST))
usb_echo("Device No Response\r\n");
#endif
return; /* unrecoverable fail */
}
}
}
}
if (USB_HostProcessState(deviceInstance) != kStatus_USB_Success) /* process the new state */
{
#ifdef HOST_ECHO
usb_echo("enumation setup error\r\n");
#endif
return;
}
}
static usb_status_t USB_HostProcessState(usb_host_device_instance_t *deviceInstance)
{
usb_status_t status = kStatus_USB_Success;
usb_host_process_descriptor_param_t getDescriptorParam;
usb_host_transfer_t *transfer;
/* malloc transfer */
if (deviceInstance->state != kStatus_DEV_EnumDone)
{
if (USB_HostMallocTransfer(deviceInstance->hostHandle, &transfer) != kStatus_USB_Success)
{
#ifdef HOST_ECHO
usb_echo("error to get transfer\r\n");
#endif
return kStatus_USB_Error;
}
transfer->callbackFn = USB_HostEnumerationTransferCallback;
transfer->callbackParam = deviceInstance;
/* reset transfer fields */
transfer->setupPacket->bmRequestType = 0x00;
transfer->setupPacket->wIndex = 0;
transfer->setupPacket->wLength = 0;
transfer->setupPacket->wValue = 0;
}
switch (deviceInstance->state)
{
case kStatus_DEV_GetDes8:
case kStatus_DEV_GetDes: /* get descriptor state */
getDescriptorParam.descriptorLength = sizeof(usb_descriptor_device_t);
if (deviceInstance->state == kStatus_DEV_GetDes8)
{
getDescriptorParam.descriptorLength = 8;
}
getDescriptorParam.descriptorBuffer = (uint8_t *)deviceInstance->deviceDescriptor;
getDescriptorParam.descriptorType = USB_DESCRIPTOR_TYPE_DEVICE;
getDescriptorParam.descriptorIndex = 0;
getDescriptorParam.languageId = 0;
transfer->setupPacket->bmRequestType |= USB_REQUEST_TYPE_DIR_IN;
transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_GET_DESCRIPTOR;
status = USB_HostStandardSetGetDescriptor(deviceInstance, transfer, &getDescriptorParam);
break;
case kStatus_DEV_SetAddress: /* set address state */
transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_SET_ADDRESS;
status = USB_HostStandardSetAddress(deviceInstance, transfer, &deviceInstance->allocatedAddress);
break;
case kStatus_DEV_GetCfg9: /* get 9 bytes configuration state */
getDescriptorParam.descriptorBuffer = deviceInstance->enumBuffer;
getDescriptorParam.descriptorType = USB_DESCRIPTOR_TYPE_CONFIGURE;
getDescriptorParam.descriptorIndex = deviceInstance->configurationValue;
getDescriptorParam.descriptorLength = 9;
getDescriptorParam.languageId = 0;
transfer->setupPacket->bmRequestType |= USB_REQUEST_TYPE_DIR_IN;
transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_GET_DESCRIPTOR;
status = USB_HostStandardSetGetDescriptor(deviceInstance, transfer, &getDescriptorParam);
break;
case kStatus_DEV_GetCfg: /* get configuration state */
getDescriptorParam.descriptorBuffer = deviceInstance->configurationDesc;
getDescriptorParam.descriptorType = USB_DESCRIPTOR_TYPE_CONFIGURE;
getDescriptorParam.descriptorIndex = deviceInstance->configurationValue;
getDescriptorParam.descriptorLength = deviceInstance->configurationLen;
getDescriptorParam.languageId = 0;
transfer->setupPacket->bmRequestType |= USB_REQUEST_TYPE_DIR_IN;
transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_GET_DESCRIPTOR;
status = USB_HostStandardSetGetDescriptor(deviceInstance, transfer, &getDescriptorParam);
break;
case kStatus_DEV_SetCfg: /* set configuration state */
transfer->setupPacket->wValue =
USB_SHORT_TO_LITTLE_ENDIAN(deviceInstance->configuration.configurationDesc->bConfigurationValue);
transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_SET_CONFIGURATION;
status = USB_HostCh9RequestCommon(deviceInstance, transfer, NULL, 0);
break;
case kStatus_DEV_EnumDone: /* enumeration done state */
status = USB_HostNotifyDevice(deviceInstance,
kUSB_HostEventEnumerationDone); /* notify device enumeration done */
if (status == kStatus_USB_Success)
{
deviceInstance->state = kStatus_DEV_AppUsed;
}
break;
default:
break;
}
return status;
}
static usb_status_t USB_HostProcessCallback(usb_host_device_instance_t *deviceInstance)
{
usb_host_pipe_t *pipe = (usb_host_pipe_t *)deviceInstance->controlPipe;
usb_status_t status = kStatus_USB_Success;
usb_descriptor_configuration_t *configureDesc;
usb_host_instance_t *hostInstance = (usb_host_instance_t *)deviceInstance->hostHandle;
switch (deviceInstance->state)
{
case kStatus_DEV_GetDes8: /* process get 8 bytes descriptor result */
pipe->maxPacketSize = deviceInstance->deviceDescriptor->bMaxPacketSize0;
hostInstance->controllerTable->controllerIoctl(
hostInstance->controllerHandle, kUSB_HostUpdateControlPacketSize, deviceInstance->controlPipe);
break;
case kStatus_DEV_SetAddress: /* process set address result */
deviceInstance->setAddress = deviceInstance->allocatedAddress;
hostInstance->controllerTable->controllerIoctl(
hostInstance->controllerHandle, kUSB_HostUpdateControlEndpointAddress, deviceInstance->controlPipe);
break;
case kStatus_DEV_GetDes: /* process set address result */
/* NULL */
break;
case kStatus_DEV_GetCfg9: /* process get 9 bytes configuration result */
configureDesc = (usb_descriptor_configuration_t *)&deviceInstance->enumBuffer[0];
deviceInstance->configurationLen = USB_SHORT_FROM_LITTLE_ENDIAN_ADDRESS(configureDesc->wTotalLength);
if (deviceInstance->configurationDesc != NULL)
{
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(deviceInstance->configurationDesc);
#else
USB_OsaMemoryFree(deviceInstance->configurationDesc);
#endif
deviceInstance->configurationDesc = NULL;
}
/* for KHCI, the start address and the length should be 4 byte align */
if ((deviceInstance->configurationLen & 0x03) != 0)
{
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
deviceInstance->configurationDesc =
(uint8_t *)SDK_Malloc((deviceInstance->configurationLen & 0xFFFFFFFCu) + 4, USB_CACHE_LINESIZE);
#else
deviceInstance->configurationDesc =
(uint8_t *)USB_OsaMemoryAllocate((deviceInstance->configurationLen & 0xFFFFFFFCu) + 4);
#endif
}
else
{
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
deviceInstance->configurationDesc =
(uint8_t *)SDK_Malloc(deviceInstance->configurationLen, USB_CACHE_LINESIZE);
#else
deviceInstance->configurationDesc = (uint8_t *)USB_OsaMemoryAllocate(deviceInstance->configurationLen);
#endif
}
if (deviceInstance->configurationDesc == NULL)
{
return kStatus_USB_Error;
}
break;
case kStatus_DEV_GetCfg: /* process get cofiguration result */
if (((usb_descriptor_configuration_t *)deviceInstance->configurationDesc)->bMaxPower >
USB_HOST_CONFIG_MAX_POWER)
{
return kStatus_USB_Error;
}
deviceInstance->configurationValue++;
if (USB_HostParseDeviceConfigurationDescriptor(deviceInstance) !=
kStatus_USB_Success) /* parse configuration descriptor */
{
return kStatus_USB_Error;
}
status = USB_HostNotifyDevice(deviceInstance, kUSB_HostEventAttach);
if (status != kStatus_USB_Success)
{
/* next configuration */
if (deviceInstance->configurationValue < deviceInstance->deviceDescriptor->bNumConfigurations)
{
return kStatus_USB_Retry;
}
else
{
USB_HostNotifyDevice(deviceInstance,
kUSB_HostEventNotSupported); /* notify application device is not supported */
return kStatus_USB_NotSupported;
}
}
break;
case kStatus_DEV_SetCfg:
/* NULL */
break;
default:
break;
}
return status;
}
static usb_status_t USB_HostNotifyDevice(usb_host_device_instance_t *deviceInstance, uint32_t eventCode)
{
usb_host_instance_t *hostInstance;
usb_status_t status1 = kStatus_USB_Error;
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
usb_status_t status2 = kStatus_USB_Error;
uint8_t haveHub;
uint8_t haveNoHub;
uint8_t interfaceIndex;
#endif /* USB_HOST_CONFIG_HUB */
if (deviceInstance == NULL)
{
return kStatus_USB_InvalidHandle;
}
hostInstance = (usb_host_instance_t *)deviceInstance->hostHandle;
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
haveHub = 0;
haveNoHub = 0;
for (interfaceIndex = 0; interfaceIndex < deviceInstance->configuration.interfaceCount; ++interfaceIndex)
{
if (((usb_descriptor_interface_t *)deviceInstance->configuration.interfaceList[interfaceIndex].interfaceDesc)
->bInterfaceClass == USB_HOST_HUB_CLASS_CODE)
{
haveHub = 1;
}
else
{
haveNoHub = 1;
}
}
if ((haveNoHub == 1) && (hostInstance->deviceCallback != NULL))
{
status1 = hostInstance->deviceCallback(deviceInstance, &deviceInstance->configuration,
eventCode); /* notify application event */
}
if (haveHub)
{
status2 = USB_HostHubDeviceEvent(hostInstance, deviceInstance, &deviceInstance->configuration,
eventCode); /* notify hub event */
}
if ((status1 == kStatus_USB_Success) || (status2 == kStatus_USB_Success)) /* the device is supported */
{
return kStatus_USB_Success;
}
else if (eventCode == kUSB_HostEventAttach) /* attach event */
{
status1 = kStatus_USB_NotSupported;
}
else
{
status1 = kStatus_USB_Error;
}
#else
if (hostInstance->deviceCallback != NULL)
{
status1 = hostInstance->deviceCallback(deviceInstance, &deviceInstance->configuration,
eventCode); /* call host callback function */
}
#endif
return status1;
}
static uint8_t USB_HostAllocateDeviceAddress(usb_host_instance_t *hostInstance)
{
uint8_t address = 0;
uint8_t addressIndex;
uint8_t addressBitIndex;
for (addressIndex = 0; addressIndex < 8; ++addressIndex) /* find the idle address postion byte */
{
if (hostInstance->addressBitMap[addressIndex] != 0xFF)
{
break;
}
}
if (addressIndex < 8)
{
for (addressBitIndex = 0; addressBitIndex < 8; ++addressBitIndex) /* find the idle address position bit */
{
if (!(hostInstance->addressBitMap[addressIndex] & (0x01u << addressBitIndex)))
{
hostInstance->addressBitMap[addressIndex] |= (0x01u << addressBitIndex); /* set the allocated bit */
address = addressIndex * 8 + addressBitIndex + 1; /* the address minimum is 1 */
break;
}
}
}
return address;
}
static void USB_HostReleaseDeviceAddress(usb_host_instance_t *hostInstance, uint8_t address)
{
USB_HostLock();
hostInstance->addressBitMap[(uint32_t)(address - 1) >> 3] &=
(~(0x01u << (((uint32_t)address - 1) & 0x07U))); /* reset the allocated bit */
USB_HostUnlock();
}
static usb_status_t USB_HostRemoveDeviceInstance(usb_host_handle hostHandle, usb_device_handle deviceHandle)
{
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
usb_host_device_instance_t *currentInstance;
usb_host_device_instance_t *prevInstance;
if ((hostHandle == NULL) || (deviceHandle == NULL))
{
return kStatus_USB_InvalidHandle;
}
/* search and remove device instance */
prevInstance = (usb_host_device_instance_t *)hostInstance->deviceList;
if (prevInstance == deviceHandle)
{
hostInstance->deviceList = prevInstance->next;
return kStatus_USB_Success;
}
else
{
currentInstance = prevInstance->next;
}
while (currentInstance != NULL)
{
if (currentInstance == deviceHandle)
{
prevInstance->next = currentInstance->next;
return kStatus_USB_Success;
}
prevInstance = currentInstance;
currentInstance = currentInstance->next;
}
return kStatus_USB_Success;
}
static void USB_HostReleaseDeviceResource(usb_host_instance_t *hostInstance, usb_host_device_instance_t *deviceInstance)
{
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
uint8_t level = 0;
#endif
#if ((defined(USB_HOST_CONFIG_LOW_POWER_MODE)) && (USB_HOST_CONFIG_LOW_POWER_MODE > 0U))
if (deviceInstance == hostInstance->suspendedDevice)
{
hostInstance->suspendedDevice = NULL;
}
#endif
/* release device's address */
if (deviceInstance->setAddress != 0)
{
USB_HostReleaseDeviceAddress(hostInstance, deviceInstance->setAddress);
}
else
{
if (deviceInstance->allocatedAddress != 0)
{
USB_HostReleaseDeviceAddress(hostInstance, deviceInstance->allocatedAddress);
}
}
/* close control pipe */
if (deviceInstance->controlPipe != NULL)
{
USB_HostCancelTransfer(hostInstance, deviceInstance->controlPipe, NULL);
if (USB_HostClosePipe(hostInstance, deviceInstance->controlPipe) != kStatus_USB_Success)
{
#ifdef HOST_ECHO
usb_echo("error when close pipe\r\n");
#endif
}
deviceInstance->controlPipe = NULL;
}
/* free configuration buffer */
if (deviceInstance->configurationDesc != NULL)
{
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(deviceInstance->configurationDesc);
#else
USB_OsaMemoryFree(deviceInstance->configurationDesc);
#endif
}
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
level = deviceInstance->level;
#endif
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(deviceInstance->deviceDescriptor);
#else
USB_OsaMemoryFree(deviceInstance->deviceDescriptor);
#endif
/* free device instance buffer */
USB_OsaMemoryFree(deviceInstance);
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
/* enable controller attach if root hub */
if (level == 1)
{
USB_HostControlBus(hostInstance, kUSB_HostBusEnableAttach);
}
#else
/* enable controller attach */
USB_HostControlBus(hostInstance, kUSB_HostBusEnableAttach);
#endif
}
static usb_status_t USB_HostParseDeviceConfigurationDescriptor(usb_device_handle deviceHandle)
{
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)deviceHandle;
uint32_t endPos;
usb_descriptor_union_t *unionDes;
usb_host_interface_t *interfaceParse = NULL;
usb_host_ep_t *epParse;
uint8_t *buffer;
if (deviceHandle == NULL)
{
return kStatus_USB_InvalidParameter;
}
buffer = (uint8_t *)&deviceInstance->configuration;
/* clear the previous parse result, note: end_pos means buffer index here*/
for (endPos = 0; endPos < sizeof(usb_host_configuration_t); endPos++)
{
buffer[endPos] = 0;
}
for (endPos = 0; endPos < USB_HOST_CONFIG_CONFIGURATION_MAX_INTERFACE; ++endPos)
{
deviceInstance->interfaceStatus[endPos] = 0;
}
/* parse configuration descriptor */
unionDes = (usb_descriptor_union_t *)deviceInstance->configurationDesc;
endPos = (uint32_t)(deviceInstance->configurationDesc + deviceInstance->configurationLen);
if ((unionDes->common.bLength == USB_DESCRIPTOR_LENGTH_CONFIGURE) &&
(unionDes->common.bDescriptorType == USB_DESCRIPTOR_TYPE_CONFIGURE))
{
/* configuration descriptor */
deviceInstance->configuration.configurationDesc = (usb_descriptor_configuration_t *)unionDes;
deviceInstance->configuration.configurationExtensionLength = 0;
deviceInstance->configuration.configurationExtension = NULL;
deviceInstance->configuration.interfaceCount = 0;
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
while ((uint32_t)unionDes < endPos)
{
if (unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_INTERFACE)
{
if (deviceInstance->configuration.configurationExtension == NULL)
{
deviceInstance->configuration.configurationExtension = (uint8_t *)unionDes;
}
if ((unionDes->common.bDescriptorType == 0x00) ||
(unionDes->common.bLength == 0x00)) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
deviceInstance->configuration.configurationExtensionLength += unionDes->common.bLength;
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
}
else
{
break;
}
}
/* interface descriptor */
deviceInstance->configuration.interfaceCount = 0;
while ((uint32_t)unionDes < endPos)
{
if (unionDes->common.bDescriptorType == USB_DESCRIPTOR_TYPE_INTERFACE)
{
if (unionDes->interface.bAlternateSetting == 0x00)
{
if (deviceInstance->configuration.interfaceCount >= USB_HOST_CONFIG_CONFIGURATION_MAX_INTERFACE)
{
#ifdef HOST_ECHO
usb_echo(
"Unsupported Device attached\r\n too many interfaces in one configuration, please increase "
"the USB_HOST_CONFIG_CONFIGURATION_MAX_INTERFACE value\n");
#endif
return kStatus_USB_Error;
}
interfaceParse =
&deviceInstance->configuration.interfaceList[deviceInstance->configuration.interfaceCount];
deviceInstance->configuration.interfaceCount++;
interfaceParse->alternateSettingNumber = 0;
interfaceParse->epCount = 0;
interfaceParse->interfaceDesc = &unionDes->interface;
interfaceParse->interfaceExtensionLength = 0;
interfaceParse->interfaceExtension = NULL;
interfaceParse->interfaceIndex = unionDes->interface.bInterfaceNumber;
if (unionDes->common.bLength == 0x00) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
while ((uint32_t)unionDes < endPos)
{
if ((unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_INTERFACE) &&
(unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_ENDPOINT))
{
if (interfaceParse->interfaceExtension == NULL)
{
interfaceParse->interfaceExtension = (uint8_t *)unionDes;
}
if ((unionDes->common.bDescriptorType == 0x00) ||
(unionDes->common.bLength == 0x00)) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
interfaceParse->interfaceExtensionLength += unionDes->common.bLength;
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
}
else
{
break;
}
}
/* endpoint descriptor */
if (interfaceParse->interfaceDesc->bNumEndpoints != 0)
{
if ((unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_ENDPOINT) ||
(interfaceParse->interfaceDesc->bNumEndpoints > USB_HOST_CONFIG_INTERFACE_MAX_EP))
{
#ifdef HOST_ECHO
usb_echo("interface descriptor error\n");
#endif
return kStatus_USB_Error;
}
for (; interfaceParse->epCount < interfaceParse->interfaceDesc->bNumEndpoints;
(interfaceParse->epCount)++)
{
if (((uint32_t)unionDes >= endPos) ||
(unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_ENDPOINT))
{
#ifdef HOST_ECHO
usb_echo("endpoint descriptor error\n");
#endif
return kStatus_USB_Error;
}
epParse = (usb_host_ep_t *)&interfaceParse->epList[interfaceParse->epCount];
epParse->epDesc = (usb_descriptor_endpoint_t *)unionDes;
epParse->epExtensionLength = 0;
epParse->epExtension = NULL;
if (unionDes->common.bLength == 0x00) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
while ((uint32_t)unionDes < endPos)
{
if ((unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_ENDPOINT) &&
(unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_INTERFACE))
{
if (epParse->epExtension == NULL)
{
epParse->epExtension = (uint8_t *)unionDes;
}
if ((unionDes->common.bDescriptorType == 0x00) ||
(unionDes->common.bLength == 0x00)) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
epParse->epExtensionLength += unionDes->common.bLength;
unionDes =
(usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
}
else
{
break;
}
}
}
}
}
else
{
if (interfaceParse == NULL)
{
return kStatus_USB_Error; /* in normal situation this cannot reach */
}
interfaceParse->alternateSettingNumber++;
if (interfaceParse->interfaceExtension == NULL)
{
interfaceParse->interfaceExtension = (uint8_t *)unionDes;
}
if (unionDes->common.bLength == 0x00) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
interfaceParse->interfaceExtensionLength += unionDes->common.bLength;
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
while ((uint32_t)unionDes < endPos)
{
if (unionDes->common.bDescriptorType != USB_DESCRIPTOR_TYPE_INTERFACE)
{
if ((unionDes->common.bDescriptorType == 0x00) ||
(unionDes->common.bLength == 0x00)) /* the descriptor data is wrong */
{
return kStatus_USB_Error;
}
interfaceParse->interfaceExtensionLength += unionDes->common.bLength;
unionDes = (usb_descriptor_union_t *)((uint32_t)unionDes + unionDes->common.bLength);
}
else
{
break;
}
}
}
}
else
{
return kStatus_USB_Error;
}
}
}
for (endPos = 0; endPos < deviceInstance->configuration.interfaceCount; ++endPos)
{
deviceInstance->interfaceStatus[endPos] = kStatus_interface_Attached;
}
return kStatus_USB_Success;
}
usb_status_t USB_HostAttachDevice(usb_host_handle hostHandle,
uint8_t speed,
uint8_t hubNumber,
uint8_t portNumber,
uint8_t level,
usb_device_handle *deviceHandle)
{
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
usb_host_device_instance_t *newInstance;
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
usb_host_device_instance_t *currentInstance;
#endif
uint8_t address;
usb_host_pipe_init_t pipeInit;
if (hostHandle == NULL)
{
return kStatus_USB_InvalidHandle;
}
/* check whether is the device attached? */
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
currentInstance = (usb_host_device_instance_t *)hostInstance->deviceList;
while (currentInstance != NULL)
{
if ((currentInstance->hubNumber == hubNumber) && (currentInstance->portNumber == portNumber))
{
*deviceHandle = NULL;
#ifdef HOST_ECHO
usb_echo("device has attached\r\n");
#endif
return kStatus_USB_Busy;
}
else
{
currentInstance = currentInstance->next;
}
}
#else
if (hostInstance->deviceList != NULL)
{
*deviceHandle = NULL;
usb_echo("device has attached\r\n");
return kStatus_USB_Busy;
}
#endif
/* Allocate new device instance */
newInstance = (usb_host_device_instance_t *)USB_OsaMemoryAllocate(sizeof(usb_host_device_instance_t));
if (newInstance == NULL)
{
#ifdef HOST_ECHO
usb_echo("allocate dev instance fail\r\n");
#endif
return kStatus_USB_AllocFail;
}
/* new instance fields init */
newInstance->hostHandle = hostHandle;
newInstance->speed = speed;
newInstance->stallRetries = USB_HOST_CONFIG_ENUMERATION_MAX_STALL_RETRIES;
newInstance->enumRetries = USB_HOST_CONFIG_ENUMERATION_MAX_RETRIES;
newInstance->setAddress = 0;
newInstance->deviceAttachState = kStatus_device_Attached;
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
newInstance->deviceDescriptor =
(usb_descriptor_device_t *)SDK_Malloc(sizeof(usb_descriptor_device_t) + 9, USB_CACHE_LINESIZE);
#else
newInstance->deviceDescriptor =
(usb_descriptor_device_t *)USB_OsaMemoryAllocate(sizeof(usb_descriptor_device_t) + 9);
#endif
if (newInstance->deviceDescriptor == NULL)
{
#ifdef HOST_ECHO
usb_echo("allocate newInstance->deviceDescriptor fail\r\n");
#endif
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(newInstance->deviceDescriptor);
#else
USB_OsaMemoryFree(newInstance->deviceDescriptor);
#endif
USB_OsaMemoryFree(newInstance);
return kStatus_USB_AllocFail;
}
newInstance->enumBuffer = (uint8_t *)((uint8_t *)newInstance->deviceDescriptor + sizeof(usb_descriptor_device_t));
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
newInstance->hubNumber = hubNumber;
newInstance->portNumber = portNumber;
newInstance->level = level;
if ((speed != USB_SPEED_HIGH) && (level > 1))
{
newInstance->hsHubNumber = USB_HostHubGetHsHubNumber(hostHandle, hubNumber);
newInstance->hsHubPort = USB_HostHubGetHsHubPort(hostHandle, hubNumber, portNumber);
}
else
{
newInstance->hsHubNumber = hubNumber;
newInstance->hsHubPort = portNumber;
}
#endif /* USB_HOST_CONFIG_HUB */
USB_HostLock();
/* allocate address && insert to the dev list */
address = USB_HostAllocateDeviceAddress(hostInstance);
if (address == 0)
{
#ifdef HOST_ECHO
usb_echo("allocate address fail\r\n");
#endif
USB_HostUnlock();
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(newInstance->deviceDescriptor);
#else
USB_OsaMemoryFree(newInstance->deviceDescriptor);
#endif
USB_OsaMemoryFree(newInstance);
return kStatus_USB_Error;
}
newInstance->allocatedAddress = address;
newInstance->next = (usb_host_device_instance_t *)hostInstance->deviceList;
hostInstance->deviceList = newInstance;
newInstance->state = kStatus_DEV_Initial;
USB_HostUnlock();
/* open control pipe */
pipeInit.devInstance = newInstance;
pipeInit.pipeType = USB_ENDPOINT_CONTROL;
pipeInit.direction = 0;
pipeInit.endpointAddress = 0;
pipeInit.interval = 0;
pipeInit.maxPacketSize = 8;
pipeInit.numberPerUframe = 0;
pipeInit.nakCount = USB_HOST_CONFIG_MAX_NAK;
if (USB_HostOpenPipe(hostHandle, &newInstance->controlPipe, &pipeInit) != kStatus_USB_Success)
{
/* don't need release resource, resource is released when detach */
*deviceHandle = newInstance;
#if ((defined(USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE)) && (USB_HOST_CONFIG_BUFFER_PROPERTY_CACHEABLE > 0U))
SDK_Free(newInstance->deviceDescriptor);
#else
USB_OsaMemoryFree(newInstance->deviceDescriptor);
#endif
USB_OsaMemoryFree(newInstance);
return kStatus_USB_Error;
}
/* start enumeration */
newInstance->state = kStatus_DEV_GetDes8;
USB_HostProcessState(newInstance); /* process enumeration state machine */
*deviceHandle = newInstance;
return kStatus_USB_Success;
}
usb_status_t USB_HostDetachDevice(usb_host_handle hostHandle, uint8_t hubNumber, uint8_t portNumber)
{
usb_host_device_instance_t *deviceInstance;
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
if (hostHandle == NULL)
{
return kStatus_USB_InvalidHandle;
}
USB_HostLock();
/* search for device instance handle */
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
deviceInstance = (usb_host_device_instance_t *)hostInstance->deviceList;
while (deviceInstance != NULL)
{
if ((deviceInstance->hubNumber == hubNumber) && (deviceInstance->portNumber == portNumber))
{
break;
}
deviceInstance = deviceInstance->next;
}
#else
deviceInstance = (usb_host_device_instance_t *)hostInstance->deviceList;
#endif
USB_HostUnlock();
if (deviceInstance != NULL)
{
return USB_HostDetachDeviceInternal(hostHandle, deviceInstance); /* device instance detach */
}
return kStatus_USB_Success;
}
usb_status_t USB_HostDetachDeviceInternal(usb_host_handle hostHandle, usb_device_handle deviceHandle)
{
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)deviceHandle;
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
if ((hostHandle == NULL) || (deviceHandle == NULL))
{
return kStatus_USB_InvalidHandle;
}
deviceInstance->deviceAttachState = kStatus_device_Detached; /* mark the device is detached from host */
if (deviceInstance->state >= kStatus_DEV_Initial) /* device instance is valid */
{
/* detach internally */
if (deviceInstance->state < kStatus_DEV_AppUsed) /* enumeration is not done */
{
if (deviceInstance->controlPipe != NULL)
{
USB_HostCancelTransfer(hostInstance, deviceInstance->controlPipe, NULL);
}
/* remove device instance from host */
USB_HostRemoveDeviceInstance(hostInstance, deviceInstance);
USB_HostReleaseDeviceResource(hostInstance, deviceInstance);
}
else /* enumeration has be done and notifed application */
{
USB_HostNotifyDevice(deviceInstance, kUSB_HostEventDetach); /* notify application device detach */
}
}
return kStatus_USB_Success;
}
uint8_t USB_HostGetDeviceAttachState(usb_device_handle deviceHandle)
{
return deviceHandle ? ((usb_host_device_instance_t *)deviceHandle)->deviceAttachState : 0x0;
}
usb_status_t USB_HostValidateDevice(usb_host_handle hostHandle, usb_device_handle deviceHandle)
{
usb_host_device_instance_t *searchDev;
if (deviceHandle == NULL)
{
return kStatus_USB_InvalidParameter;
}
/* search for the device */
searchDev = (usb_host_device_instance_t *)((usb_host_instance_t *)hostHandle)->deviceList;
while ((searchDev != NULL) && ((usb_device_handle)searchDev != deviceHandle))
{
searchDev = searchDev->next;
}
if (searchDev)
{
return kStatus_USB_Success;
}
return kStatus_USB_Error;
}
static usb_status_t USB_HostControlBus(usb_host_handle hostHandle, uint8_t controlType)
{
usb_status_t status = kStatus_USB_Success;
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
if (hostHandle == NULL)
{
return kStatus_USB_InvalidHandle;
}
status = hostInstance->controllerTable->controllerIoctl(hostInstance->controllerHandle, kUSB_HostBusControl,
&controlType);
return status;
}
usb_status_t USB_HostOpenDeviceInterface(usb_device_handle deviceHandle, usb_host_interface_handle interfaceHandle)
{
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)deviceHandle;
usb_host_instance_t *hostInstance = NULL;
uint8_t interfaceIndex;
uint8_t index = 0;
if ((deviceHandle == NULL) || (interfaceHandle == NULL))
{
return kStatus_USB_InvalidHandle;
}
hostInstance = (usb_host_instance_t *)deviceInstance->hostHandle;
USB_HostLock();
/* check host_instance valid? */
for (; index < USB_HOST_CONFIG_MAX_HOST; ++index)
{
if ((g_UsbHostInstance[index].occupied == 1) &&
((usb_host_instance_t *)(&g_UsbHostInstance[index]) == (hostInstance)))
{
break;
}
}
if (index >= USB_HOST_CONFIG_MAX_HOST)
{
USB_HostUnlock();
return kStatus_USB_Error;
}
/* check deviceHandle valid? */
if (USB_HostValidateDevice(hostInstance, deviceHandle) != kStatus_USB_Success)
{
USB_HostUnlock();
return kStatus_USB_Error;
}
/* search interface and set the interface as opened */
for (interfaceIndex = 0; interfaceIndex < deviceInstance->configuration.interfaceCount; ++interfaceIndex)
{
if (&deviceInstance->configuration.interfaceList[interfaceIndex] == interfaceHandle)
{
deviceInstance->interfaceStatus[interfaceIndex] = kStatus_interface_Opened;
break;
}
}
USB_HostUnlock();
return kStatus_USB_Success;
}
usb_status_t USB_HostCloseDeviceInterface(usb_device_handle deviceHandle, usb_host_interface_handle interfaceHandle)
{
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)deviceHandle;
usb_host_instance_t *hostInstance = NULL;
uint8_t interfaceIndex;
uint8_t removeLabel = 1;
uint8_t index = 0;
if (deviceHandle == NULL)
{
return kStatus_USB_InvalidHandle;
}
hostInstance = (usb_host_instance_t *)deviceInstance->hostHandle;
USB_HostLock();
/* check host_instance valid? */
for (; index < USB_HOST_CONFIG_MAX_HOST; ++index)
{
if ((g_UsbHostInstance[index].occupied == 1) &&
((usb_host_instance_t *)(&g_UsbHostInstance[index]) == (hostInstance)))
{
break;
}
}
if (index >= USB_HOST_CONFIG_MAX_HOST)
{
USB_HostUnlock();
return kStatus_USB_Error;
}
/* check deviceHandle valid? */
if (USB_HostValidateDevice(hostInstance, deviceHandle) != kStatus_USB_Success)
{
USB_HostUnlock();
return kStatus_USB_Error;
}
if (interfaceHandle != NULL)
{
/* search interface and set the interface as detached */
for (interfaceIndex = 0; interfaceIndex < deviceInstance->configuration.interfaceCount; ++interfaceIndex)
{
if (&deviceInstance->configuration.interfaceList[interfaceIndex] == interfaceHandle)
{
deviceInstance->interfaceStatus[interfaceIndex] = kStatus_interface_Detached;
break;
}
}
}
if (deviceInstance->deviceAttachState == kStatus_device_Detached) /* device is removed from host */
{
removeLabel = 1;
/* check all the interfaces of the device are not opened */
for (interfaceIndex = 0; interfaceIndex < deviceInstance->configuration.interfaceCount; ++interfaceIndex)
{
if (deviceInstance->interfaceStatus[interfaceIndex] == kStatus_interface_Opened)
{
removeLabel = 0;
break;
}
}
if (removeLabel == 1)
{
/* remove device instance from host */
USB_HostRemoveDeviceInstance(hostInstance, deviceInstance);
}
USB_HostUnlock();
if (removeLabel == 1)
{
USB_HostReleaseDeviceResource((usb_host_instance_t *)deviceInstance->hostHandle,
deviceInstance); /* release device resource */
}
}
else
{
USB_HostUnlock();
}
return kStatus_USB_Success;
}
usb_status_t USB_HostRemoveDevice(usb_host_handle hostHandle, usb_device_handle deviceHandle)
{
usb_host_instance_t *hostInstance = (usb_host_instance_t *)hostHandle;
usb_host_device_instance_t *deviceInstance = (usb_host_device_instance_t *)deviceHandle;
uint8_t interfaceIndex = 0;
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
uint8_t level = 0;
uint8_t devHubNo;
uint8_t devPortNo;
#endif
if ((hostHandle == NULL) || (deviceHandle == NULL))
{
return kStatus_USB_InvalidHandle;
}
if (deviceInstance->hostHandle != hostHandle)
{
return kStatus_USB_InvalidParameter;
}
if (USB_HostValidateDevice(hostInstance, deviceInstance) == kStatus_USB_Success) /* device is valid */
{
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
devHubNo = deviceInstance->hubNumber;
devPortNo = deviceInstance->portNumber;
level = deviceInstance->level;
#endif
deviceInstance->deviceAttachState = kStatus_device_Detached;
if (deviceInstance->state >= kStatus_DEV_Initial) /* device is valid */
{
if (deviceInstance->state < kStatus_DEV_AppUsed) /* enumeraion is not done or application don't use */
{
/* detach internally */
USB_HostDetachDeviceInternal(hostHandle, deviceHandle);
}
else /* application use the device */
{
for (interfaceIndex = 0; interfaceIndex < deviceInstance->configuration.interfaceCount;
++interfaceIndex)
{
if (deviceInstance->interfaceStatus[interfaceIndex] == kStatus_interface_Opened)
{
#ifdef HOST_ECHO
usb_echo("error: there is class instance that is not deinited\r\n");
#endif
break;
}
}
/* remove device instance from host */
USB_HostRemoveDeviceInstance(hostInstance, deviceInstance);
USB_HostReleaseDeviceResource(hostInstance, deviceInstance); /* release resource */
}
}
#if ((defined USB_HOST_CONFIG_HUB) && (USB_HOST_CONFIG_HUB))
if (level == 1)
{
USB_HostControlBus(hostHandle, kUSB_HostBusReset); /* reset controller port */
USB_HostControlBus(hostHandle, kUSB_HostBusRestart); /* restart controller port */
}
else
{
USB_HostHubRemovePort(hostHandle, devHubNo, devPortNo); /* reset hub port */
}
#else
USB_HostControlBus(hostHandle, kUSB_HostBusReset); /* reset controller port */
USB_HostControlBus(hostHandle, kUSB_HostBusRestart); /* restart controller port */
#endif /* USB_HOST_CONFIG_HUB */
}
return kStatus_USB_Success;
}