/* * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc. * Copyright 2016 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ #include "usb_device_config.h" #include "usb.h" #include "usb_device.h" #include "usb_device_dci.h" #include "usb_device_class.h" #include "usb_device_ch9.h" #if ((defined(USB_DEVICE_CONFIG_NUM)) && (USB_DEVICE_CONFIG_NUM > 0U)) /******************************************************************************* * Definitions ******************************************************************************/ /*! * @brief Standard request callback function typedef. * * This function is used to handle the standard request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @return A USB error code or kStatus_USB_Success. */ typedef usb_status_t (*usb_standard_request_callback_t)(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); /******************************************************************************* * Prototypes ******************************************************************************/ static usb_status_t USB_DeviceCh9GetStatus(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9SetClearFeature(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9SetAddress(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9GetDescriptor(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9GetConfiguration(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9SetConfiguration(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9GetInterface(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9SetInterface(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); static usb_status_t USB_DeviceCh9SynchFrame(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length); /******************************************************************************* * Variables ******************************************************************************/ /* The function list to handle the standard request. */ static const usb_standard_request_callback_t s_UsbDeviceStandardRequest[] = { USB_DeviceCh9GetStatus, USB_DeviceCh9SetClearFeature, (usb_standard_request_callback_t)NULL, USB_DeviceCh9SetClearFeature, (usb_standard_request_callback_t)NULL, USB_DeviceCh9SetAddress, USB_DeviceCh9GetDescriptor, (usb_standard_request_callback_t)NULL, USB_DeviceCh9GetConfiguration, USB_DeviceCh9SetConfiguration, USB_DeviceCh9GetInterface, USB_DeviceCh9SetInterface, USB_DeviceCh9SynchFrame, }; /******************************************************************************* * Code ******************************************************************************/ /*! * @brief Handle get status request. * * This function is used to handle get status request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9GetStatus(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_IN) || (setup->wValue != 0U) || (setup->wLength != 2U)) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddress != state) && ((uint8_t)kUSB_DeviceStateConfigured != state)) { return error; } if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) { #if (defined(USB_DEVICE_CONFIG_OTG) && (USB_DEVICE_CONFIG_OTG)) if (setup->wIndex == USB_REQUEST_STANDARD_GET_STATUS_OTG_STATUS_SELECTOR) { error = USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusOtg, &classHandle->standardTranscationBuffer); classHandle->standardTranscationBuffer = USB_SHORT_TO_LITTLE_ENDIAN(classHandle->standardTranscationBuffer); /* The device status length must be USB_DEVICE_STATUS_SIZE. */ *length = 1; } else /* Get the device status */ { #endif error = USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDevice, &classHandle->standardTranscationBuffer); classHandle->standardTranscationBuffer = classHandle->standardTranscationBuffer & USB_GET_STATUS_DEVICE_MASK; classHandle->standardTranscationBuffer = USB_SHORT_TO_LITTLE_ENDIAN(classHandle->standardTranscationBuffer); /* The device status length must be USB_DEVICE_STATUS_SIZE. */ *length = USB_DEVICE_STATUS_SIZE; #if (defined(USB_DEVICE_CONFIG_OTG) && (USB_DEVICE_CONFIG_OTG)) } #endif } else if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_INTERFACE) { #if ((defined(USB_DEVICE_CONFIG_ROOT2_TEST)) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) if (((uint8_t)kUSB_DeviceStateAddress == state) || (((uint8_t)kUSB_DeviceStateConfigured == state) && (0U == setup->wIndex))) { /* In valid address state, device must stall the status stage for get status (interface) request. In configured state, device must stall the status stage for get status (interface 0) request */ return error; } #endif /* Get the interface status */ error = kStatus_USB_Success; classHandle->standardTranscationBuffer = 0U; /* The interface status length must be USB_INTERFACE_STATUS_SIZE. */ *length = USB_INTERFACE_STATUS_SIZE; } else if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_ENDPOINT) { #if ((defined(USB_DEVICE_CONFIG_ROOT2_TEST)) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) if ((USB_CONTROL_ENDPOINT != (setup->wIndex & USB_ENDPOINT_NUMBER_MASK)) && ((uint8_t)kUSB_DeviceStateAddress == state)) { /* In valid address, device must stall the status stage for get status (EP) request for no-control endpoint */ return error; } #endif /* Get the endpoint status */ usb_device_endpoint_status_struct_t endpointStatus; endpointStatus.endpointAddress = (uint8_t)setup->wIndex; endpointStatus.endpointStatus = (uint16_t)kUSB_DeviceEndpointStateIdle; error = USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusEndpoint, &endpointStatus); classHandle->standardTranscationBuffer = endpointStatus.endpointStatus & USB_GET_STATUS_ENDPOINT_MASK; classHandle->standardTranscationBuffer = USB_SHORT_TO_LITTLE_ENDIAN(classHandle->standardTranscationBuffer); /* The endpoint status length must be USB_INTERFACE_STATUS_SIZE. */ *length = USB_ENDPOINT_STATUS_SIZE; } else { /*no action*/ } *buffer = (uint8_t *)&classHandle->standardTranscationBuffer; return error; } /*! * @brief Handle set or clear device feature request. * * This function is used to handle set or clear device feature request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9SetClearFeature(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; uint8_t isSet = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_OUT) || (setup->wLength != 0U)) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddress != state) && ((uint8_t)kUSB_DeviceStateConfigured != state)) { return error; } /* Identify the request is set or clear the feature. */ if (USB_REQUEST_STANDARD_SET_FEATURE == setup->bRequest) { isSet = 1U; } if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) { /* Set or Clear the device feature. */ if (USB_REQUEST_STANDARD_FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP == setup->wValue) { #if ((defined(USB_DEVICE_CONFIG_REMOTE_WAKEUP)) && (USB_DEVICE_CONFIG_REMOTE_WAKEUP > 0U)) USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusRemoteWakeup, &isSet); #endif /* Set or Clear the device remote wakeup feature. */ error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventSetRemoteWakeup, &isSet); } #if ((defined(USB_DEVICE_CONFIG_EHCI) && (USB_DEVICE_CONFIG_EHCI > 0U)) || \ (defined(USB_DEVICE_CONFIG_LPCIP3511HS) && (USB_DEVICE_CONFIG_LPCIP3511HS > 0U))) && \ (defined(USB_DEVICE_CONFIG_USB20_TEST_MODE) && (USB_DEVICE_CONFIG_USB20_TEST_MODE > 0U)) else if (USB_REQUEST_STANDARD_FEATURE_SELECTOR_DEVICE_TEST_MODE == setup->wValue) { state = kUSB_DeviceStateTestMode; error = USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); } #endif #if (defined(USB_DEVICE_CONFIG_OTG) && (USB_DEVICE_CONFIG_OTG)) else if (USB_REQUEST_STANDARD_FEATURE_SELECTOR_B_HNP_ENABLE == setup->wValue) { error = USB_DeviceClassCallback(classHandle->handle, kUSB_DeviceEventSetBHNPEnable, &isSet); } #endif else { } } else if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_ENDPOINT) { /* Set or Clear the endpoint feature. */ if (USB_REQUEST_STANDARD_FEATURE_SELECTOR_ENDPOINT_HALT == setup->wValue) { #if ((defined(USB_DEVICE_CONFIG_ROOT2_TEST)) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) if ((USB_CONTROL_ENDPOINT != (setup->wIndex & USB_ENDPOINT_NUMBER_MASK)) && (kUSB_DeviceStateConfigured != state)) { /* In no-configured state, device must stall the status stage for clear/set feature halt requests for * no-control endpoint */ return error; } else { /* In configured state, device must stall the status stage for clear/set feature halt for no-initialized EP. For contol EP, device must accept status stage of Set Feature Halt (Endpoint 80) in Addressed State */ usb_device_endpoint_status_struct_t endpointStatus; endpointStatus.endpointAddress = (uint8_t)setup->wIndex; error = USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusEndpoint, &endpointStatus); if (kStatus_USB_Success != error) { return error; } } #else if (USB_CONTROL_ENDPOINT == (setup->wIndex & USB_ENDPOINT_NUMBER_MASK)) { /* Set or Clear the control endpoint status(halt or not). */ if (0U != isSet) { #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceStallEndpoint(classHandle->handle, (uint8_t)setup->wIndex)) { return kStatus_USB_Error; } #else (void)USB_DeviceStallEndpoint(classHandle->handle, (uint8_t)setup->wIndex); #endif } else { #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceUnstallEndpoint(classHandle->handle, (uint8_t)setup->wIndex)) { return kStatus_USB_Error; } #else (void)USB_DeviceUnstallEndpoint(classHandle->handle, (uint8_t)setup->wIndex); #endif } } #endif /* Set or Clear the endpoint status feature. */ if (0U != isSet) { error = USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventSetEndpointHalt, &setup->wIndex); } else { error = USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventClearEndpointHalt, &setup->wIndex); } } else { /*no action*/ } } else { /*no action*/ } return error; } /*! * @brief Handle set address request. * * This function is used to handle set address request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state. */ static usb_status_t USB_DeviceCh9SetAddress(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_OUT) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_DEVICE) || (setup->wIndex != 0U) || (setup->wLength != 0U)) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddressing != state) && ((uint8_t)kUSB_DeviceStateAddress != state) && ((uint8_t)kUSB_DeviceStateDefault != state) #if ((defined(USB_DEVICE_CONFIG_ROOT2_TEST)) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) #else && ((uint8_t)kUSB_DeviceStateConfigured != state) #endif ) { return error; } if ((uint8_t)kUSB_DeviceStateAddressing != state) { /* If the device address is not setting, pass the address and the device state will change to * kUSB_DeviceStateAddressing internally. */ state = (uint8_t)(setup->wValue & 0xFFU); #if ((defined(USB_DEVICE_CONFIG_ROOT2_TEST)) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) /* Setting the address to 128 or above should not be allowed. */ if (state >= 0x80U) { return error; } #endif error = USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusAddress, &state); } else { /* If the device address is setting, set device address and the address will be write into the controller * internally. */ error = USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusAddress, NULL); /* And then change the device state to kUSB_DeviceStateAddress. */ if (kStatus_USB_Success == error) { state = (uint8_t)kUSB_DeviceStateAddress; error = USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); } } return error; } /*! * @brief Handle get descriptor request. * * This function is used to handle get descriptor request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9GetDescriptor(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_device_get_descriptor_common_union_t commonDescriptor; usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; uint8_t descriptorType = (uint8_t)((setup->wValue & 0xFF00U) >> 8U); uint8_t descriptorIndex = (uint8_t)((setup->wValue & 0x00FFU)); if ((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_IN) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddress != state) && ((uint8_t)kUSB_DeviceStateConfigured != state) && ((uint8_t)kUSB_DeviceStateDefault != state)) { return error; } commonDescriptor.commonDescriptor.length = setup->wLength; if (USB_DESCRIPTOR_TYPE_DEVICE == descriptorType) { /* Get the device descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) && (descriptorIndex == 0U) && (setup->wIndex == 0U)) { error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetDeviceDescriptor, &commonDescriptor.deviceDescriptor); } } else if (USB_DESCRIPTOR_TYPE_CONFIGURE == descriptorType) { /* Get the configuration descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) && (setup->wIndex == 0U)) { commonDescriptor.configurationDescriptor.configuration = descriptorIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetConfigurationDescriptor, &commonDescriptor.configurationDescriptor); } } else if (USB_DESCRIPTOR_TYPE_STRING == descriptorType) { /* Get the string descriptor */ if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) { commonDescriptor.stringDescriptor.stringIndex = descriptorIndex; commonDescriptor.stringDescriptor.languageId = setup->wIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetStringDescriptor, &commonDescriptor.stringDescriptor); } } #if (defined(USB_DEVICE_CONFIG_HID) && (USB_DEVICE_CONFIG_HID > 0U)) else if (USB_DESCRIPTOR_TYPE_HID == descriptorType) { /* Get the hid descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_INTERFACE) && (descriptorIndex == 0U)) { commonDescriptor.hidDescriptor.interfaceNumber = (uint8_t)setup->wIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetHidDescriptor, &commonDescriptor.hidDescriptor); } } else if (USB_DESCRIPTOR_TYPE_HID_REPORT == descriptorType) { /* Get the hid report descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_INTERFACE) && (descriptorIndex == 0U)) { commonDescriptor.hidReportDescriptor.interfaceNumber = (uint8_t)setup->wIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetHidReportDescriptor, &commonDescriptor.hidReportDescriptor); } } else if (USB_DESCRIPTOR_TYPE_HID_PHYSICAL == descriptorType) { /* Get the hid physical descriptor */ if ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_INTERFACE) { commonDescriptor.hidPhysicalDescriptor.index = descriptorIndex; commonDescriptor.hidPhysicalDescriptor.interfaceNumber = (uint8_t)setup->wIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetHidPhysicalDescriptor, &commonDescriptor.hidPhysicalDescriptor); } } #endif #if (defined(USB_DEVICE_CONFIG_CV_TEST) && (USB_DEVICE_CONFIG_CV_TEST > 0U)) else if (USB_DESCRIPTOR_TYPE_DEVICE_QUALITIER == descriptorType) { /* Get the device descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) && (descriptorIndex == 0U) && (setup->wIndex == 0U)) { error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetDeviceQualifierDescriptor, &commonDescriptor.deviceDescriptor); } } #endif #if (defined(USB_DEVICE_CONFIG_LPM_L1) && (USB_DEVICE_CONFIG_LPM_L1 > 0U)) else if (USB_DESCRIPTOR_TYPE_BOS == descriptorType) { /* Get the configuration descriptor */ if (((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) == USB_REQUEST_TYPE_RECIPIENT_DEVICE) && (setup->wIndex == 0U)) { commonDescriptor.configurationDescriptor.configuration = descriptorIndex; error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetBOSDescriptor, &commonDescriptor.configurationDescriptor); } } #endif else { } *buffer = commonDescriptor.commonDescriptor.buffer; *length = commonDescriptor.commonDescriptor.length; return error; } /*! * @brief Handle get current configuration request. * * This function is used to handle get current configuration request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9GetConfiguration(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { uint8_t state = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_IN) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_DEVICE) || (setup->wValue != 0U) || (setup->wIndex != 0U) || (setup->wLength != 1U)) { return kStatus_USB_InvalidRequest; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddress != state) && (((uint8_t)kUSB_DeviceStateConfigured != state))) { return kStatus_USB_InvalidRequest; } *length = USB_CONFIGURE_SIZE; *buffer = (uint8_t *)&classHandle->standardTranscationBuffer; return USB_DeviceClassCallback(classHandle->handle, (uint8_t)kUSB_DeviceEventGetConfiguration, &classHandle->standardTranscationBuffer); } /*! * @brief Handle set current configuration request. * * This function is used to handle set current configuration request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9SetConfiguration(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { uint8_t state = 0U; #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) usb_status_t error = kStatus_USB_InvalidRequest; #endif if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_OUT) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_DEVICE) || (setup->wIndex != 0U) || (setup->wLength != 0U)) { return kStatus_USB_InvalidRequest; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (((uint8_t)kUSB_DeviceStateAddress != state) && ((uint8_t)kUSB_DeviceStateConfigured != state)) { return kStatus_USB_InvalidRequest; } /* The device state is changed to kUSB_DeviceStateConfigured */ state = (uint8_t)kUSB_DeviceStateConfigured; #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (0U == setup->wValue) { /* If the new configuration is zero, the device state is changed to kUSB_DeviceStateAddress */ state = (uint8_t)kUSB_DeviceStateAddress; #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceSetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif } /* Notify the class layer the configuration is changed */ #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) error = USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventSetConfiguration, &setup->wValue); if (kStatus_USB_Success != error) { return error; } #else (void)USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventSetConfiguration, &setup->wValue); #endif /* Notify the application the configuration is changed */ return USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventSetConfiguration, &setup->wValue); } /*! * @brief Handle get the alternate setting of a interface request. * * This function is used to handle get the alternate setting of a interface request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9GetInterface(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_IN) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_INTERFACE) || (setup->wValue != 0U) || (setup->wLength != 1U)) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (state != (uint8_t)kUSB_DeviceStateConfigured) { return error; } *length = USB_INTERFACE_SIZE; *buffer = (uint8_t *)&classHandle->standardTranscationBuffer; classHandle->standardTranscationBuffer = (uint16_t)(((uint32_t)setup->wIndex & 0xFFU) << 8U); /* The Bit[15~8] is used to save the interface index, and the alternate setting will be saved in Bit[7~0] by * application. */ error = USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventGetInterface, &classHandle->standardTranscationBuffer); classHandle->standardTranscationBuffer = USB_SHORT_TO_LITTLE_ENDIAN(classHandle->standardTranscationBuffer); return error; } /*! * @brief Handle set the alternate setting of a interface request. * * This function is used to handle set the alternate setting of a interface request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9SetInterface(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { uint8_t state = 0U; #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) usb_status_t error = kStatus_USB_InvalidRequest; #endif if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_OUT) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_INTERFACE) || (setup->wLength != 0U)) { return kStatus_USB_InvalidRequest; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (state != (uint8_t)kUSB_DeviceStateConfigured) { return kStatus_USB_InvalidRequest; } classHandle->standardTranscationBuffer = ((setup->wIndex & 0xFFU) << 8U) | (setup->wValue & 0xFFU); /* Notify the class driver the alternate setting of the interface is changed. */ /* The Bit[15~8] is used to save the interface index, and the alternate setting is saved in Bit[7~0]. */ #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) error = USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventSetInterface, &classHandle->standardTranscationBuffer); if (kStatus_USB_Success != error) { return error; } #else (void)USB_DeviceClassEvent(classHandle->handle, kUSB_DeviceClassEventSetInterface, &classHandle->standardTranscationBuffer); #endif /* Notify the application the alternate setting of the interface is changed. */ /* The Bit[15~8] is used to save the interface index, and the alternate setting will is saved in Bit[7~0]. */ return USB_DeviceClassCallback(classHandle->handle, (uint32_t)kUSB_DeviceEventSetInterface, &classHandle->standardTranscationBuffer); } /*! * @brief Handle get sync frame request. * * This function is used to handle get sync frame request. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @retval kStatus_USB_Success The request is handled successfully. * @retval kStatus_USB_InvalidRequest The request can not be handle in current device state, * or, the request is unsupported. */ static usb_status_t USB_DeviceCh9SynchFrame(usb_device_common_class_struct_t *classHandle, usb_setup_struct_t *setup, uint8_t **buffer, uint32_t *length) { usb_status_t error = kStatus_USB_InvalidRequest; uint8_t state = 0U; if (((setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) != USB_REQUEST_TYPE_DIR_IN) || ((setup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) != USB_REQUEST_TYPE_RECIPIENT_ENDPOINT) || (setup->wValue != 0U) || (setup->wLength != 2U)) { return error; } #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusDeviceState, &state); #endif if (state != (uint8_t)kUSB_DeviceStateConfigured) { return error; } /* Synch frame is not implemented by any MS devices. Expected response from device will be STALL until a device exists that supports this command. At that time this script will need to be updated to support a response other than STALL */ #if (defined(USB_DEVICE_CONFIG_ROOT2_TEST) && (USB_DEVICE_CONFIG_ROOT2_TEST > 0U)) return error; #else classHandle->standardTranscationBuffer = USB_SHORT_FROM_LITTLE_ENDIAN(setup->wIndex); /* Get the sync frame value */ error = USB_DeviceGetStatus(classHandle->handle, kUSB_DeviceStatusSynchFrame, &classHandle->standardTranscationBuffer); *buffer = (uint8_t *)&classHandle->standardTranscationBuffer; *length = sizeof(classHandle->standardTranscationBuffer); return error; #endif } /*! * @brief Send the response to the host. * * This function is used to send the response to the host. * * There are two cases this function will be called. * Case one when a setup packet is received in control endpoint callback function: * 1. If there is not data phase in the setup transfer, the function will prime an IN transfer with the data * length is zero for status phase. * 2. If there is an IN data phase, the function will prime an OUT transfer with the actual length to need to * send for data phase. And then prime an IN transfer with the data length is zero for status phase. * 3. If there is an OUT data phase, the function will prime an IN transfer with the actual length to want to * receive for data phase. * * Case two when is not a setup packet received in control endpoint callback function: * 1. The function will prime an IN transfer with data length is zero for status phase. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param setup The pointer of the setup packet. * @param error The error code returned from the standard request function. * @param stage The stage of the control transfer. * @param buffer It is an out parameter, is used to save the buffer address to response the host's request. * @param length It is an out parameter, the data length. * * @return A USB error code or kStatus_USB_Success. */ static usb_status_t USB_DeviceControlCallbackFeedback(usb_device_handle handle, usb_setup_struct_t *setup, usb_status_t error, usb_device_control_read_write_sequence_t stage, uint8_t **buffer, uint32_t *length) { usb_status_t status; if (kStatus_USB_InvalidRequest == error) { /* Stall the control pipe when the request is unsupported. */ status = USB_DeviceStallEndpoint(handle, (uint8_t)USB_CONTROL_ENDPOINT); } else { if (*length > setup->wLength) { *length = setup->wLength; } if (kStatus_USB_Success == error) { status = USB_DeviceSendRequest(handle, (USB_CONTROL_ENDPOINT), *buffer, *length); } else { status = USB_DeviceSendRequest(handle, (USB_CONTROL_ENDPOINT), (uint8_t *)NULL, 0U); } if ((kStatus_USB_Success == status) && (USB_REQUEST_TYPE_DIR_IN == (setup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK))) { status = USB_DeviceRecvRequest(handle, (USB_CONTROL_ENDPOINT), (uint8_t *)NULL, 0U); } } return status; } /*! * @brief Control endpoint callback function. * * This callback function is used to notify uplayer the transfser result of a transfer. * This callback pointer is passed when a specified endpoint initialized by calling API USB_DeviceInitEndpoint. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param message The result of a transfer, includes transfer buffer, transfer length and whether is in setup * phase for control pipe. * @param callbackParam The parameter for this callback. It is same with * usb_device_endpoint_callback_struct_t::callbackParam. * * @return A USB error code or kStatus_USB_Success. */ static usb_status_t USB_DeviceControlCallback(usb_device_handle handle, usb_device_endpoint_callback_message_struct_t *message, void *callbackParam) { usb_setup_struct_t *deviceSetup, *setup; usb_device_common_class_struct_t *classHandle; uint8_t *buffer = (uint8_t *)NULL; uint32_t length = 0U; void *temp; usb_status_t status = kStatus_USB_InvalidRequest; uint8_t state = 0U; /* endpoint callback length is USB_CANCELLED_TRANSFER_LENGTH (0xFFFFFFFFU) when transfer is canceled */ if (USB_CANCELLED_TRANSFER_LENGTH == message->length) { return kStatus_USB_Success; } if (NULL == callbackParam) { return status; } classHandle = (usb_device_common_class_struct_t *)callbackParam; temp = (void *)&classHandle->setupBuffer[0]; deviceSetup = (usb_setup_struct_t *)temp; #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceGetStatus(handle, kUSB_DeviceStatusDeviceState, &state)) { return kStatus_USB_Error; } #else (void)USB_DeviceGetStatus(handle, kUSB_DeviceStatusDeviceState, &state); #endif if (0U != message->isSetup) { if ((USB_SETUP_PACKET_SIZE != message->length) || (NULL == message->buffer)) { /* If a invalid setup is received, the control pipes should be de-init and init again. * Due to the IP can not meet this require, it is reserved for feature. */ /* USB_DeviceDeinitEndpoint(handle, USB_CONTROL_ENDPOINT | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT)); USB_DeviceDeinitEndpoint(handle, USB_CONTROL_ENDPOINT | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT)); USB_DeviceControlPipeInit(handle, callbackParam); */ return status; } /* Receive a setup request */ temp = (void *)(message->buffer); setup = (usb_setup_struct_t *)temp; /* Copy the setup packet to the application buffer */ deviceSetup->wValue = USB_SHORT_FROM_LITTLE_ENDIAN(setup->wValue); deviceSetup->wIndex = USB_SHORT_FROM_LITTLE_ENDIAN(setup->wIndex); deviceSetup->wLength = USB_SHORT_FROM_LITTLE_ENDIAN(setup->wLength); deviceSetup->bRequest = setup->bRequest; deviceSetup->bmRequestType = setup->bmRequestType; /* Check the invalid value */ if ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_RECIPIENT_MASK) > USB_REQUEST_TYPE_RECIPIENT_OTHER) { #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) status = USB_DeviceControlCallbackFeedback(handle, deviceSetup, kStatus_USB_InvalidRequest, kUSB_DeviceControlPipeSetupStage, NULL, NULL); return kStatus_USB_InvalidRequest; #else (void)USB_DeviceControlCallbackFeedback(handle, deviceSetup, kStatus_USB_InvalidRequest, kUSB_DeviceControlPipeSetupStage, NULL, NULL); return status; #endif } if ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_STANDARD) { /* Handle the standard request, only handle the request in request array. */ if (deviceSetup->bRequest < (sizeof(s_UsbDeviceStandardRequest) / 4U)) { if (s_UsbDeviceStandardRequest[deviceSetup->bRequest] != (usb_standard_request_callback_t)NULL) { status = s_UsbDeviceStandardRequest[deviceSetup->bRequest](classHandle, deviceSetup, &buffer, &length); } } } else { if ((0U != deviceSetup->wLength) && ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) == USB_REQUEST_TYPE_DIR_OUT)) { /* Class or vendor request with the OUT data phase. */ if ((0U != deviceSetup->wLength) && ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_CLASS)) { /* Get data buffer to receive the data from the host. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = (uint8_t *)NULL; controlRequest.isSetup = 1U; controlRequest.setup = deviceSetup; controlRequest.length = deviceSetup->wLength; status = USB_DeviceClassEvent(handle, kUSB_DeviceClassEventClassRequest, &controlRequest); length = controlRequest.length; buffer = controlRequest.buffer; } else if ((0U != deviceSetup->wLength) && ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_VENDOR)) { /* Get data buffer to receive the data from the host. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = (uint8_t *)NULL; controlRequest.isSetup = 1U; controlRequest.setup = deviceSetup; controlRequest.length = deviceSetup->wLength; status = USB_DeviceClassCallback(handle, (uint32_t)kUSB_DeviceEventVendorRequest, &controlRequest); length = controlRequest.length; buffer = controlRequest.buffer; } else { /*no action*/ } if (kStatus_USB_Success == status) { /* Prime an OUT transfer */ if (length > deviceSetup->wLength) { length = deviceSetup->wLength; } status = USB_DeviceRecvRequest(handle, USB_CONTROL_ENDPOINT, buffer, length); return status; } else { /* Other error codes, will stall control endpoint */ status = kStatus_USB_InvalidRequest; } } else { /* Class or vendor request with the IN data phase. */ if (((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_CLASS)) { /* Get data buffer to response the host. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = (uint8_t *)NULL; controlRequest.isSetup = 1U; controlRequest.setup = deviceSetup; controlRequest.length = deviceSetup->wLength; status = USB_DeviceClassEvent(handle, kUSB_DeviceClassEventClassRequest, &controlRequest); length = controlRequest.length; buffer = controlRequest.buffer; } else if (((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_VENDOR)) { /* Get data buffer to response the host. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = (uint8_t *)NULL; controlRequest.isSetup = 1U; controlRequest.setup = deviceSetup; controlRequest.length = deviceSetup->wLength; status = USB_DeviceClassCallback(handle, (uint32_t)kUSB_DeviceEventVendorRequest, &controlRequest); length = controlRequest.length; buffer = controlRequest.buffer; } else { /*no action*/ } } } /* Buffer that is equal to NULL means the application or classs driver does not prepare a buffer for sending or receiving the data, so control endpoint will be stalled here. */ if ((0U != length) && (NULL == buffer)) { status = kStatus_USB_InvalidRequest; } /* Send the response to the host. */ status = USB_DeviceControlCallbackFeedback(handle, deviceSetup, status, kUSB_DeviceControlPipeSetupStage, &buffer, &length); } else if ((uint8_t)kUSB_DeviceStateAddressing == state) { if (USB_REQUEST_STANDARD_SET_ADDRESS == deviceSetup->bRequest) { /* Set the device address to controller. */ status = s_UsbDeviceStandardRequest[deviceSetup->bRequest](classHandle, deviceSetup, &buffer, &length); } } #if ((defined(USB_DEVICE_CONFIG_EHCI) && (USB_DEVICE_CONFIG_EHCI > 0U)) || \ (defined(USB_DEVICE_CONFIG_LPCIP3511HS) && (USB_DEVICE_CONFIG_LPCIP3511HS > 0U))) && \ (defined(USB_DEVICE_CONFIG_USB20_TEST_MODE) && (USB_DEVICE_CONFIG_USB20_TEST_MODE > 0U)) else if ((uint8_t)kUSB_DeviceStateTestMode == state) { uint8_t portTestControl = (uint8_t)(deviceSetup->wIndex >> 8); /* Set the controller.into test mode. */ status = USB_DeviceSetStatus(handle, kUSB_DeviceStatusTestMode, &portTestControl); } #endif else if ((0U != message->length) && (0U != deviceSetup->wLength) && ((deviceSetup->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) == USB_REQUEST_TYPE_DIR_OUT)) { if (((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_CLASS)) { /* Data received in OUT phase, and notify the class driver. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = message->buffer; controlRequest.isSetup = 0U; controlRequest.setup = deviceSetup; controlRequest.length = message->length; status = USB_DeviceClassEvent(handle, kUSB_DeviceClassEventClassRequest, &controlRequest); } else if (((deviceSetup->bmRequestType & USB_REQUEST_TYPE_TYPE_MASK) == USB_REQUEST_TYPE_TYPE_VENDOR)) { /* Data received in OUT phase, and notify the application. */ usb_device_control_request_struct_t controlRequest; controlRequest.buffer = message->buffer; controlRequest.isSetup = 0U; controlRequest.setup = deviceSetup; controlRequest.length = message->length; status = USB_DeviceClassCallback(handle, (uint32_t)kUSB_DeviceEventVendorRequest, &controlRequest); } else { /*no action*/ } /* Send the response to the host. */ status = USB_DeviceControlCallbackFeedback(handle, deviceSetup, status, kUSB_DeviceControlPipeDataStage, &buffer, &length); } else { /*no action*/ } return status; } /*! * @brief Control endpoint initialization function. * * This callback function is used to initialize the control pipes. * * @param handle The device handle. It equals the value returned from USB_DeviceInit. * @param param The up layer handle. * * @return A USB error code or kStatus_USB_Success. */ usb_status_t USB_DeviceControlPipeInit(usb_device_handle handle, void *param) { usb_device_endpoint_init_struct_t epInitStruct; usb_device_endpoint_callback_struct_t epCallback; usb_status_t status; epCallback.callbackFn = USB_DeviceControlCallback; epCallback.callbackParam = param; epInitStruct.zlt = 1U; epInitStruct.transferType = USB_ENDPOINT_CONTROL; epInitStruct.interval = 0; epInitStruct.endpointAddress = USB_CONTROL_ENDPOINT | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT); epInitStruct.maxPacketSize = USB_CONTROL_MAX_PACKET_SIZE; /* Initialize the control IN pipe */ status = USB_DeviceInitEndpoint(handle, &epInitStruct, &epCallback); if (kStatus_USB_Success != status) { return status; } epInitStruct.endpointAddress = USB_CONTROL_ENDPOINT | (USB_OUT << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT); /* Initialize the control OUT pipe */ status = USB_DeviceInitEndpoint(handle, &epInitStruct, &epCallback); if (kStatus_USB_Success != status) { #if (defined(USB_DEVICE_CONFIG_RETURN_VALUE_CHECK) && (USB_DEVICE_CONFIG_RETURN_VALUE_CHECK > 0U)) if (kStatus_USB_Success != USB_DeviceDeinitEndpoint( handle, USB_CONTROL_ENDPOINT | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT))) { return kStatus_USB_Error; } #else (void)USB_DeviceDeinitEndpoint( handle, USB_CONTROL_ENDPOINT | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT)); #endif return status; } return kStatus_USB_Success; } #endif /* USB_DEVICE_CONFIG_NUM */