/* * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc. * Copyright 2016,2019 - 2020 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ #include "usb_host_config.h" #if ((defined USB_HOST_CONFIG_AUDIO) && (USB_HOST_CONFIG_AUDIO)) #include "usb_host.h" #include "usb_host_audio.h" /******************************************************************************* * Definitions ******************************************************************************/ typedef union usb_audio_ctrl_common_fu_desc_t { usb_audio_ctrl_fu_desc_t fuDesc10; usb_audio_2_0_ctrl_fu_desc_t fuDesc20; } usb_audio_ctrl_common_fu_desc; /******************************************************************************* * Variables ******************************************************************************/ /* usb audio feature uint command request declaration */ static usb_audio_request_t s_usbAudioFuRequests[NUMBER_OF_FEATURE_COMMANDS] = { /* Mute command request */ {AUDIO_FU_MUTE_MASK, ITF_REQUEST, CUR_REQUEST, AUDIO_FU_MUTE, 1U}, /* Volume command request */ {AUDIO_FU_VOLUME_MASK, ITF_REQUEST, CUR_REQUEST, AUDIO_FU_VOLUME, 2U}, {AUDIO_FU_VOLUME_MASK, ITF_REQUEST, MIN_REQUEST, AUDIO_FU_VOLUME, 2U}, {AUDIO_FU_VOLUME_MASK, ITF_REQUEST, MAX_REQUEST, AUDIO_FU_VOLUME, 2U}, {AUDIO_FU_VOLUME_MASK, ITF_REQUEST, RES_REQUEST, AUDIO_FU_VOLUME, 2U}, }; /* USB audio endpoint command declaration */ static usb_audio_request_t s_usbAudioEpRequests[NUMBER_OF_ENDPOINT_COMMANDS] = { /* USB audio Pitch command request */ {AUDIO_PITCH_MASK, EP_REQUEST, CUR_REQUEST, AUDIO_PITCH_CONTROL, 1U}, /* USB audio Sampling frequency command request */ {AUDIO_SAMPLING_FREQ_MASK, EP_REQUEST, CUR_REQUEST, AUDIO_SAMPLING_FREQ_CONTROL, 3U}, {AUDIO_SAMPLING_FREQ_MASK, EP_REQUEST, MIN_REQUEST, AUDIO_SAMPLING_FREQ_CONTROL, 3U}, {AUDIO_SAMPLING_FREQ_MASK, EP_REQUEST, MAX_REQUEST, AUDIO_SAMPLING_FREQ_CONTROL, 3U}, {AUDIO_SAMPLING_FREQ_MASK, EP_REQUEST, RES_REQUEST, AUDIO_SAMPLING_FREQ_CONTROL, 3U}, }; /******************************************************************************* * Code ******************************************************************************/ /*! * @brief initialize the audio instance. * * This function allocate the resource for audio instance. * * @param deviceHandle The device handle. * @param classHandlePtr return class handle. * * @retval kStatus_USB_Success The device is initialized successfully. * @retval kStatus_USB_AllocFail Allocate memory fail. */ usb_status_t USB_HostAudioInit(usb_device_handle deviceHandle, usb_host_class_handle *classHandlePtr) { audio_instance_t *audioPtr = (audio_instance_t *)OSA_MemoryAllocate(sizeof(audio_instance_t)); uint32_t info_value; uint32_t *temp; if (audioPtr == NULL) { return kStatus_USB_AllocFail; } audioPtr->deviceHandle = deviceHandle; audioPtr->controlIntfHandle = NULL; audioPtr->streamIntfHandle = NULL; (void)USB_HostHelperGetPeripheralInformation(deviceHandle, (uint32_t)kUSB_HostGetHostHandle, &info_value); temp = (uint32_t *)info_value; audioPtr->hostHandle = (usb_host_handle)temp; (void)USB_HostHelperGetPeripheralInformation(deviceHandle, (uint32_t)kUSB_HostGetDeviceControlPipe, &info_value); temp = (uint32_t *)info_value; audioPtr->controlPipe = (usb_host_pipe_handle)temp; *classHandlePtr = audioPtr; return kStatus_USB_Success; } /*! * @brief de-initialize the audio instance. * * This function release the resource for audio instance. * * @param deviceHandle the device handle. * @param classHandle the class handle. * * @retval kStatus_USB_Success The device is de-initialized successfully. */ usb_status_t USB_HostAudioDeinit(usb_device_handle deviceHandle, usb_host_class_handle classHandle) { usb_status_t status = kStatus_USB_Success; audio_instance_t *audioPtr = (audio_instance_t *)classHandle; if (deviceHandle == NULL) { return kStatus_USB_InvalidHandle; } if (classHandle != NULL) { if (audioPtr->isoInPipe != NULL) { status = USB_HostCancelTransfer(audioPtr->hostHandle, audioPtr->isoInPipe, NULL); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when cancel pipe\r\n"); #endif } status = USB_HostClosePipe(audioPtr->hostHandle, audioPtr->isoInPipe); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when close pipe\r\n"); #endif } audioPtr->isoInPipe = NULL; } if (audioPtr->isoOutPipe != NULL) { status = USB_HostCancelTransfer(audioPtr->hostHandle, audioPtr->isoOutPipe, NULL); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when cancel pipe\r\n"); #endif } status = USB_HostClosePipe(audioPtr->hostHandle, audioPtr->isoOutPipe); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when close pipe\r\n"); #endif } audioPtr->isoOutPipe = NULL; } (void)USB_HostCloseDeviceInterface(deviceHandle, audioPtr->streamIntfHandle); if ((audioPtr->controlPipe != NULL) && (audioPtr->controlTransfer != NULL)) { status = USB_HostCancelTransfer(audioPtr->hostHandle, audioPtr->controlPipe, audioPtr->controlTransfer); } (void)USB_HostCloseDeviceInterface(deviceHandle, audioPtr->controlIntfHandle); OSA_MemoryFree(audioPtr); } else { (void)USB_HostCloseDeviceInterface(deviceHandle, NULL); } return status; } /*! * @brief audiostream iso in pipe transfer callback. * * @param param callback parameter. * @param transfer callback transfer. * @param status transfer status. */ static void _USB_HostAudioStreamIsoInPipeCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status) { audio_instance_t *audioPtr = (audio_instance_t *)param; if (audioPtr->inCallbackFn != NULL) { /* callback function is initialized in USB_HostAudioStreamRecv */ audioPtr->inCallbackFn(audioPtr->inCallbackParam, transfer->transferBuffer, transfer->transferSofar, status); } (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); } /*! * @brief audiostream iso out pipe transfer callback. * * @param param callback parameter. * @param transfer callback transfer. * @param status transfer status. */ static void _USB_HostAudioStreamIsoOutPipeCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status) { audio_instance_t *audioPtr = (audio_instance_t *)param; if (audioPtr->outCallbackFn != NULL) { /* callback function is initialized in USB_HostAudioStreamSend */ audioPtr->outCallbackFn(audioPtr->outCallbackParam, transfer->transferBuffer, transfer->transferSofar, status); } (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); } /*! * @brief audiocontrol pipe transfer callback. * * @param param callback parameter. * @param transfer callback transfer. * @param status transfer status. */ static void _USB_HostAudioControlCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status) { audio_instance_t *audioPtr = (audio_instance_t *)param; audioPtr->controlTransfer = NULL; if (audioPtr->controlCallbackFn != NULL) { /* callback to application, callback function is initialized in the _USB_HostAudioControl, USB_HostAudioStreamSetInterface or USB_HostAudioControlSetInterface, but is the same function */ audioPtr->controlCallbackFn(audioPtr->controlCallbackParam, transfer->transferBuffer, transfer->transferSofar, status); } (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); audioPtr->isSetup = 0U; } /*! * @brief hid send control transfer common code. * * @param classHandle the class handle. * @param typeRequest setup packet request type. * @param request setup packet request value. * @param wvalue setup packet wvalue value. * @param windex setup packet index value. * @param wlength setup packet wlength value. * @param data data buffer pointer will be transfer. * @param callbackFn this callback is called after this function completes. * @param callbackParam the first parameter in the callback function. * * @return An error code or kStatus_USB_Success. */ static usb_status_t _USB_HostAudioControl(usb_host_class_handle classHandle, uint8_t typeRequest, uint8_t request, uint16_t wvalue, uint16_t windex, uint16_t wlength, uint8_t *data, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_host_transfer_t *transfer; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if (USB_HostMallocTransfer(audioPtr->hostHandle, &transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error to get transfer\r\n"); #endif return kStatus_USB_Error; } audioPtr->controlCallbackFn = callbackFn; audioPtr->controlCallbackParam = callbackParam; transfer->transferBuffer = data; transfer->transferLength = wlength; transfer->callbackFn = _USB_HostAudioControlCallback; transfer->callbackParam = audioPtr; transfer->setupPacket->bmRequestType = typeRequest; transfer->setupPacket->bRequest = request; transfer->setupPacket->wValue = USB_SHORT_TO_LITTLE_ENDIAN(wvalue); transfer->setupPacket->wIndex = USB_SHORT_TO_LITTLE_ENDIAN(windex); transfer->setupPacket->wLength = USB_SHORT_TO_LITTLE_ENDIAN(wlength); audioPtr->isSetup = 1; if (USB_HostSendSetup(audioPtr->hostHandle, audioPtr->controlPipe, transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("failed for USB_HostSendSetup\r\n"); #endif (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); return kStatus_USB_Error; } audioPtr->controlTransfer = transfer; return kStatus_USB_Success; } static usb_status_t _USB_HostAudioInitEndpoint(audio_instance_t *audioPtr, usb_descriptor_endpoint_t *ep_desc) { usb_host_pipe_init_t pipe_init; usb_status_t status; pipe_init.devInstance = audioPtr->deviceHandle; pipe_init.pipeType = USB_ENDPOINT_ISOCHRONOUS; pipe_init.direction = ((ep_desc->bEndpointAddress & USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_MASK) >> USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT); pipe_init.endpointAddress = (ep_desc->bEndpointAddress & USB_DESCRIPTOR_ENDPOINT_ADDRESS_NUMBER_MASK); pipe_init.interval = ep_desc->bInterval; pipe_init.maxPacketSize = (uint16_t)((USB_SHORT_FROM_LITTLE_ENDIAN_ADDRESS(ep_desc->wMaxPacketSize) & USB_DESCRIPTOR_ENDPOINT_MAXPACKETSIZE_SIZE_MASK)); pipe_init.numberPerUframe = (uint8_t)((USB_SHORT_FROM_LITTLE_ENDIAN_ADDRESS(ep_desc->wMaxPacketSize) & USB_DESCRIPTOR_ENDPOINT_MAXPACKETSIZE_MULT_TRANSACTIONS_MASK)); pipe_init.nakCount = USB_HOST_CONFIG_MAX_NAK; if (pipe_init.direction == USB_IN) { audioPtr->inPacketSize = pipe_init.maxPacketSize; audioPtr->isoEpNum = pipe_init.endpointAddress; status = USB_HostOpenPipe(audioPtr->hostHandle, &audioPtr->isoInPipe, &pipe_init); } else { audioPtr->outPacketSize = pipe_init.maxPacketSize; audioPtr->isoEpNum = pipe_init.endpointAddress; status = USB_HostOpenPipe(audioPtr->hostHandle, &audioPtr->isoOutPipe, &pipe_init); } return status; } /*! * @brief audio open interface. * * @param audioPtr audio instance pointer. * * @return kStatus_USB_Success or error codes. */ static usb_status_t _USB_HostAudioOpenInterface(audio_instance_t *audioPtr) { usb_status_t status; uint8_t ep_index = 0U; usb_descriptor_endpoint_t *ep_desc = NULL; usb_host_interface_t *interface_ptr; if (audioPtr->isoInPipe != NULL) { status = USB_HostClosePipe(audioPtr->hostHandle, audioPtr->isoInPipe); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when close pipe\r\n"); #endif } audioPtr->isoInPipe = NULL; } if (audioPtr->isoOutPipe != NULL) { status = USB_HostClosePipe(audioPtr->hostHandle, audioPtr->isoOutPipe); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when close pipe\r\n"); #endif } audioPtr->isoOutPipe = NULL; } /* open interface pipes */ interface_ptr = (usb_host_interface_t *)audioPtr->streamIntfHandle; for (ep_index = 0U; ep_index < interface_ptr->epCount; ++ep_index) { ep_desc = interface_ptr->epList[ep_index].epDesc; if (((ep_desc->bEndpointAddress & USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_MASK) == USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_IN) && ((ep_desc->bmAttributes & USB_DESCRIPTOR_ENDPOINT_ATTRIBUTE_TYPE_MASK) == USB_ENDPOINT_ISOCHRONOUS)) { status = _USB_HostAudioInitEndpoint(audioPtr, ep_desc); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("usb_host_audio_stream_set_interface fail to open pipe\r\n"); #endif return kStatus_USB_Error; } } else if (((ep_desc->bEndpointAddress & USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_MASK) == USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_OUT) && ((ep_desc->bmAttributes & USB_DESCRIPTOR_ENDPOINT_ATTRIBUTE_TYPE_MASK) == USB_ENDPOINT_ISOCHRONOUS)) { status = _USB_HostAudioInitEndpoint(audioPtr, ep_desc); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("usb_host_audio_stream_set_interface fail to open pipe\r\n"); #endif return kStatus_USB_Error; } } else { } } return kStatus_USB_Success; } /*! * @brief audio set interface callback, open pipes. * * @param param callback parameter. * @param transfer callback transfer. * @param status transfer status. */ static void _USB_HostAudioSetInterfaceCallback(void *param, usb_host_transfer_t *transfer, usb_status_t status) { audio_instance_t *audioPtr = (audio_instance_t *)param; audioPtr->controlTransfer = NULL; if (status == kStatus_USB_Success) { status = _USB_HostAudioOpenInterface(audioPtr); } if (audioPtr->controlCallbackFn != NULL) { /* callback to application, callback function is initialized in the _USB_HostAudioControl, USB_HostAudioStreamSetInterface or USB_HostAudioControlSetInterface, but is the same function */ audioPtr->controlCallbackFn(audioPtr->controlCallbackParam, NULL, 0U, status); } (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); } /*! * @brief set audioclass stream interface. * * This function bind the interface with the audio instance. * * @param classHandle The class handle. * @param interfaceHandle The interface handle. * @param alternateSetting The alternate setting value. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success The device is initialized successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error send transfer fail, please reference to USB_HostSendSetup. * @retval kStatus_USB_Busy callback return status, there is no idle pipe. * @retval kStatus_USB_TransferStall callback return status, the transfer is stall by device. * @retval kStatus_USB_Error callback return status, open pipe fail, please reference to USB_HostOpenPipe. */ usb_status_t USB_HostAudioStreamSetInterface(usb_host_class_handle classHandle, usb_host_interface_handle interfaceHandle, uint8_t alternateSetting, transfer_callback_t callbackFn, void *callbackParam) { usb_status_t status; audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_host_interface_t *interface_ptr; usb_host_transfer_t *transfer; audio_descriptor_union_t ptr1; uint32_t length = 0U, ep = 0U; void *temp; usb_descriptor_endpoint_t *endpointDesc; if (classHandle == NULL) { return kStatus_USB_InvalidParameter; } audioPtr->streamIntfHandle = interfaceHandle; status = USB_HostOpenDeviceInterface(audioPtr->deviceHandle, interfaceHandle); if (status != kStatus_USB_Success) { return status; } if (audioPtr->isoInPipe != NULL) { status = USB_HostCancelTransfer(audioPtr->hostHandle, audioPtr->isoInPipe, NULL); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when cancel pipe\r\n"); #endif } } if (audioPtr->isoOutPipe != NULL) { status = USB_HostCancelTransfer(audioPtr->hostHandle, audioPtr->isoOutPipe, NULL); if (status != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error when cancel pipe\r\n"); #endif } } /* open interface pipes */ interface_ptr = (usb_host_interface_t *)interfaceHandle; ptr1.bufr = interface_ptr->interfaceExtension; length = 0U; while (length < interface_ptr->interfaceExtensionLength) { if ((ptr1.common->bDescriptorType == 0x04U) && (ptr1.interface->bAlternateSetting == alternateSetting)) { interface_ptr->epCount = ptr1.interface->bNumEndpoints; break; } ptr1.bufr += ptr1.common->bLength; length += ptr1.common->bLength; } while (ep < interface_ptr->epCount) { if (ptr1.common->bDescriptorType == 0x24U) { temp = (void *)ptr1.bufr; if (AUDIO_DEVICE_VERSION_01 == audioPtr->deviceAudioVersion) { if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_AS_GENERAL) { audioPtr->asIntfDesc = temp; } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_AS_FORMAT_TYPE) { audioPtr->formatTypeDesc = temp; } else { /*no action*/ } } else if (AUDIO_DEVICE_VERSION_02 == audioPtr->deviceAudioVersion) { if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_AS_GENERAL_20) { audioPtr->asIntfDesc = temp; } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_AS_FORMAT_TYPE_20) { audioPtr->formatTypeDesc = temp; } else { /*no action*/ } } else { /*no action*/ } } else { /*no action*/ } if (ptr1.common->bDescriptorType == 0x05U) { uint32_t descLength = 0; temp = (void *)ptr1.bufr; /*Bits 5..4: Usage Type, 00 = Data endpoint 01 = Feedback endpoint 10 = Implicit feedback Data endpoit, usb Spec 9.6*/ endpointDesc = (usb_descriptor_endpoint_t *)temp; if (0x00U == ((endpointDesc->bmAttributes >> 4U) & 0x3U)) { interface_ptr->epList[ep].epDesc = (usb_descriptor_endpoint_t *)temp; audioPtr->isoEndpDesc = (usb_descriptor_endpoint_t *)temp; } else if (0x01U == ((endpointDesc->bmAttributes >> 4U) & 0x3U)) { /*feedback endpoint*/ } else { /*TO DO*/ } descLength = ptr1.common->bLength; ptr1.bufr += ptr1.common->bLength; if ((0x25U == ptr1.common->bDescriptorType)) { interface_ptr->epList[ep].epExtension = ptr1.bufr; interface_ptr->epList[ep].epExtensionLength = ptr1.common->bLength; } else { ptr1.bufr -= descLength; } ep++; } ptr1.bufr += ptr1.common->bLength; } if (alternateSetting == 0U) { if (callbackFn != NULL) { status = _USB_HostAudioOpenInterface(audioPtr); callbackFn(callbackParam, NULL, 0U, kStatus_USB_Success); } } else { if (USB_HostMallocTransfer(audioPtr->hostHandle, &transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error to get transfer\r\n"); #endif return kStatus_USB_Error; } audioPtr->controlCallbackFn = callbackFn; audioPtr->controlCallbackParam = callbackParam; /* initialize transfer */ transfer->callbackFn = _USB_HostAudioSetInterfaceCallback; transfer->callbackParam = audioPtr; transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_SET_INTERFACE; transfer->setupPacket->bmRequestType = USB_REQUEST_TYPE_RECIPIENT_INTERFACE; transfer->setupPacket->wIndex = USB_SHORT_TO_LITTLE_ENDIAN( ((usb_host_interface_t *)audioPtr->streamIntfHandle)->interfaceDesc->bInterfaceNumber); transfer->setupPacket->wValue = USB_SHORT_TO_LITTLE_ENDIAN(alternateSetting); transfer->setupPacket->wLength = 0; transfer->transferBuffer = NULL; transfer->transferLength = 0; status = USB_HostSendSetup(audioPtr->hostHandle, audioPtr->controlPipe, transfer); if (status == kStatus_USB_Success) { audioPtr->controlTransfer = transfer; } else { (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); } } return status; } /*! * @brief set audioclass control interface. * * This function bind the interface with the audio instance. * * @param classHandle The class handle. * @param interfaceHandle The interface handle. * @param alternateSetting The alternate setting value. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success The device is initialized successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error send transfer fail, please reference to USB_HostSendSetup. * @retval kStatus_USB_Busy callback return status, there is no idle pipe. * @retval kStatus_USB_TransferStall callback return status, the transfer is stall by device. * @retval kStatus_USB_Error callback return status, open pipe fail, please reference to USB_HostOpenPipe. */ usb_status_t USB_HostAudioControlSetInterface(usb_host_class_handle classHandle, usb_host_interface_handle interfaceHandle, uint8_t alternateSetting, transfer_callback_t callbackFn, void *callbackParam) { usb_status_t status; audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_host_interface_t *interface_ptr; usb_host_transfer_t *transfer; audio_descriptor_union_t ptr1; void *temp; void *header; usb_audio_ctrl_common_header_desc_t *commonHeader; uint32_t length = 0U; if (classHandle == NULL) { return kStatus_USB_InvalidParameter; } audioPtr->controlIntfHandle = interfaceHandle; interface_ptr = (usb_host_interface_t *)interfaceHandle; status = USB_HostOpenDeviceInterface(audioPtr->deviceHandle, interfaceHandle); if (status != kStatus_USB_Success) { return status; } ptr1.bufr = interface_ptr->interfaceExtension; length = 0U; while (length < interface_ptr->interfaceExtensionLength) { if (((interface_ptr->interfaceDesc->bDescriptorType == 0x04U) && (interface_ptr->interfaceDesc->bAlternateSetting == alternateSetting)) || ((ptr1.common->bDescriptorType == 0x04U) && (ptr1.interface->bAlternateSetting == alternateSetting))) { break; } ptr1.bufr += ptr1.common->bLength; length += ptr1.common->bLength; } while (length < interface_ptr->interfaceExtensionLength) { if (ptr1.common->bDescriptorType == 0x24U) { temp = (void *)ptr1.bufr; if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_CS_HEADER) { audioPtr->headerDesc = (void *)temp; commonHeader = (usb_audio_ctrl_common_header_desc_t *)temp; header = (void *)&commonHeader->bcdcdc; audioPtr->deviceAudioVersion = USB_SHORT_FROM_LITTLE_ENDIAN_ADDRESS(((uint8_t *)header)); } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_CS_INPUT) { audioPtr->itDesc = (void *)temp; } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_CS_OUTPUT) { audioPtr->otDesc = (void *)temp; } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_CS_FEATURE) { audioPtr->fuDesc = (void *)temp; } else if (ptr1.common->bData[0] == USB_AUDIO_DESC_SUBTYPE_CS_CLOCK_SOURE) { audioPtr->clockSource = (void *)temp; } else { /*no action*/ } } ptr1.bufr += ptr1.common->bLength; length += ptr1.common->bLength; } if (alternateSetting == 0U) { if (callbackFn != NULL) { callbackFn(callbackParam, NULL, 0U, kStatus_USB_Success); } } else { if (USB_HostMallocTransfer(audioPtr->hostHandle, &transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error to get transfer\r\n"); #endif return kStatus_USB_Error; } audioPtr->controlCallbackFn = callbackFn; audioPtr->controlCallbackParam = callbackParam; /* initialize transfer */ transfer->callbackFn = _USB_HostAudioControlCallback; transfer->callbackParam = audioPtr; transfer->setupPacket->bRequest = USB_REQUEST_STANDARD_SET_INTERFACE; transfer->setupPacket->bmRequestType = USB_REQUEST_TYPE_RECIPIENT_INTERFACE; transfer->setupPacket->wIndex = USB_SHORT_TO_LITTLE_ENDIAN( ((usb_host_interface_t *)audioPtr->controlIntfHandle)->interfaceDesc->bInterfaceNumber); transfer->setupPacket->wValue = USB_SHORT_TO_LITTLE_ENDIAN(alternateSetting); transfer->setupPacket->wLength = 0; transfer->transferBuffer = NULL; transfer->transferLength = 0; status = USB_HostSendSetup(audioPtr->hostHandle, audioPtr->controlPipe, transfer); if (status == kStatus_USB_Success) { audioPtr->controlTransfer = transfer; } else { (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); } } return status; } /*! * @brief get pipe max packet size. * * @param classHandle the class handle. * @param pipeType It's value is USB_ENDPOINT_CONTROL, USB_ENDPOINT_ISOCHRONOUS, USB_ENDPOINT_BULK or * USB_ENDPOINT_INTERRUPT. * Please reference to usb_spec.h * @param direction pipe direction. * * @retval 0 The classHandle is NULL. * @retval max packet size. */ uint16_t USB_HostAudioPacketSize(usb_host_class_handle classHandle, uint8_t pipeType, uint8_t direction) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; if (classHandle == NULL) { return 0U; } if (pipeType == USB_ENDPOINT_ISOCHRONOUS) { if (direction == USB_IN) { return audioPtr->inPacketSize; } else { return audioPtr->outPacketSize; } } return 0U; } /*! * @brief audio stream receive data. * * This function implements audioreceiving data. * * @param classHandle The class handle. * @param buffer The buffer pointer. * @param bufferLen The buffer length. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Receive request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error pipe is not initialized. * Or, send transfer fail, please reference to USB_HostRecv. */ usb_status_t USB_HostAudioStreamRecv(usb_host_class_handle classHandle, uint8_t *buffer, uint32_t bufferLen, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_host_transfer_t *transfer; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if (audioPtr->isoInPipe == NULL) { return kStatus_USB_Error; } if (USB_HostMallocTransfer(audioPtr->hostHandle, &transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error to get transfer\r\n"); #endif return kStatus_USB_Error; } audioPtr->inCallbackFn = callbackFn; audioPtr->inCallbackParam = callbackParam; transfer->transferBuffer = buffer; transfer->transferLength = bufferLen; transfer->callbackFn = _USB_HostAudioStreamIsoInPipeCallback; transfer->callbackParam = audioPtr; if (USB_HostRecv(audioPtr->hostHandle, audioPtr->isoInPipe, transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("failed to USB_HostRecv\r\n"); #endif (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); return kStatus_USB_Error; } return kStatus_USB_Success; } /*! * @brief audio stream send data. * * This function implements audio sending data. * * @param classHandle The class handle. * @param buffer The buffer pointer. * @param bufferLen The buffer length. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Receive request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error pipe is not initialized. * Or, send transfer fail, please reference to USB_HostSend. */ usb_status_t USB_HostAudioStreamSend(usb_host_class_handle classHandle, uint8_t *buffer, uint32_t bufferLen, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_host_transfer_t *transfer; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if (audioPtr->isoOutPipe == NULL) { return kStatus_USB_Error; } if (USB_HostMallocTransfer(audioPtr->hostHandle, &transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("error to get transfer\r\n"); #endif return kStatus_USB_Error; } audioPtr->outCallbackFn = callbackFn; audioPtr->outCallbackParam = callbackParam; transfer->transferBuffer = buffer; transfer->transferLength = bufferLen; transfer->callbackFn = _USB_HostAudioStreamIsoOutPipeCallback; transfer->callbackParam = audioPtr; if (USB_HostSend(audioPtr->hostHandle, audioPtr->isoOutPipe, transfer) != kStatus_USB_Success) { #ifdef HOST_ECHO usb_echo("failed to USB_HostSend\r\n"); #endif (void)USB_HostFreeTransfer(audioPtr->hostHandle, transfer); return kStatus_USB_Error; } return kStatus_USB_Success; } /*! * @brief get audio control current altsetting descriptor. * * This function implements get audio stream current altsetting descriptor. * * @param classHandle The class handle. * @param DescriptorType The descriptor type. * @param DescriptorSubType The descriptor subtype, 0 for no subtype. * @param Descriptor The pointer of descriptor pointer. * * @retval kStatus_USB_Success Get audio stream current altsetting descriptor request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * */ usb_status_t USB_HostAudioControlGetCurrentAltsettingSpecificDescriptors( usb_host_class_handle classHandle, uint32_t DescriptorType, uint32_t DescriptorSubType, void **Descriptor) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_status_t status = kStatus_USB_Error; uint32_t **descriptorPointer = (uint32_t **)Descriptor; if ((classHandle == NULL) || NULL == Descriptor) { return kStatus_USB_InvalidParameter; } if (USB_AUDIO_DESCRIPTOR_TYPE_CS_INTERFACE == DescriptorType) { if (AUDIO_DEVICE_VERSION_01 == audioPtr->deviceAudioVersion) { if (USB_AUDIO_DESC_SUBTYPE_CS_EXTENSION <= DescriptorSubType) { /*descriptor type code bigger than EXTENSION is not support by audio 1.0*/ return kStatus_USB_InvalidParameter; } } switch (DescriptorSubType) { case USB_AUDIO_DESC_SUBTYPE_CS_HEADER: *descriptorPointer = (uint32_t *)audioPtr->headerDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_CS_INPUT: *descriptorPointer = (uint32_t *)audioPtr->itDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_CS_OUTPUT: *descriptorPointer = (uint32_t *)audioPtr->otDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_CS_FEATURE: *descriptorPointer = (uint32_t *)audioPtr->fuDesc; status = kStatus_USB_Success; break; default: /*no action*/ break; } } return status; } /*! * @brief get audio control current altsetting descriptor. * * This function implements get audio stream current altsetting descriptor. * * @param classHandle The class handle. * @param DescriptorType The descriptor type. * @param DescriptorSubType The descriptor subtype, default 0. * @param Descriptor The pointer of descriptor pointer. * * @retval kStatus_USB_Success Get audio stream current altsetting descriptor request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * */ usb_status_t USB_HostAudioStreamGetCurrentAltsettingSpecificDescriptors( usb_host_class_handle classHandle, uint32_t DescriptorType, uint32_t DescriptorSubType, void **Descriptor) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_status_t status = kStatus_USB_Error; uint32_t **descriptorPointer = (uint32_t **)Descriptor; void *temp; if ((classHandle == NULL) || NULL == Descriptor) { return kStatus_USB_InvalidParameter; } if (USB_AUDIO_DESCRIPTOR_TYPE_CS_INTERFACE == DescriptorType) { if (AUDIO_DEVICE_VERSION_01 == audioPtr->deviceAudioVersion) { switch (DescriptorSubType) { case USB_AUDIO_DESC_SUBTYPE_AS_GENERAL: *descriptorPointer = (uint32_t *)audioPtr->asIntfDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_AS_FORMAT_TYPE: *descriptorPointer = (uint32_t *)audioPtr->formatTypeDesc; status = kStatus_USB_Success; break; default: /*no action*/ break; } } else if (AUDIO_DEVICE_VERSION_02 == audioPtr->deviceAudioVersion) { switch (DescriptorSubType) { case USB_AUDIO_DESC_SUBTYPE_AS_GENERAL_20: *descriptorPointer = (uint32_t *)audioPtr->asIntfDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_AS_FORMAT_TYPE_20: *descriptorPointer = (uint32_t *)audioPtr->formatTypeDesc; status = kStatus_USB_Success; break; case USB_AUDIO_DESC_SUBTYPE_AS_FORMAT_ENCODER_20: /*no action*/ break; default: /*no action*/ break; } } else { /*To DO*/ } } else if (USB_DESCRIPTOR_TYPE_ENDPOINT == DescriptorType) { if (0x0U == DescriptorSubType) { /*iso data endpoint descriptor*/ temp = (void *)audioPtr->isoEndpDesc; *descriptorPointer = (uint32_t *)temp; status = kStatus_USB_Success; } else { /*TO DO*/ } } else { /*To DO*/ } return status; } /*! * @brief get audio stream current altsetting descriptor. * @deprecated Do not use this function. It has been superceded by @ref * USB_HostAudioStreamGetCurrentAltsettingSpecificDescriptors. * * This function implements get audio stream current altsetting descriptor. * * @param classHandle The class handle. * @param asIntfDesc The pointer of class specific AS interface descriptor. * @param formatTypeDesc The pointer of format type descriptor. * @param isoEndpDesc The pointer of specific iso endp descriptor. * * @retval kStatus_USB_Success Get audio stream current altsetting descriptor request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * */ usb_status_t USB_HostAudioStreamGetCurrentAltsettingDescriptors( usb_host_class_handle classHandle, usb_audio_stream_spepific_as_intf_desc_t **asIntfDesc, usb_audio_stream_format_type_desc_t **formatTypeDesc, usb_descriptor_endpoint_t **isoEndpDesc) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } *asIntfDesc = (usb_audio_stream_spepific_as_intf_desc_t *)audioPtr->asIntfDesc; *formatTypeDesc = (usb_audio_stream_format_type_desc_t *)audioPtr->formatTypeDesc; *isoEndpDesc = (usb_descriptor_endpoint_t *)audioPtr->isoEndpDesc; return kStatus_USB_Success; } /*! * @brief usb audio set/get feature unit request. * * This function implements usb audio feature unit request. * * @param classHandle The class handle. * @param csAndCn The CS and CN or MCN for wValue field in setup Request. * @param cmdCode The bRequest code in lower 8bit of lower word and get(1)/set(0) flag in higher 8bit of lower * word. * @param buf The feature unit request buffer pointer. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Feature unit request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error Send transfer fail, please reference to USB_HostSendSetup. * */ usb_status_t USB_HostAudioGetSetFeatureUnitRequest(usb_host_class_handle classHandle, uint32_t csAndCn, uint32_t cmdCode, void *buf, uint32_t bufLen, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *if_ptr; uint8_t *bmacontrols = NULL; usb_audio_ctrl_common_fu_desc *fuDesc; uint16_t windex; uint8_t request; uint8_t atribute_index; uint16_t length = 0U; uint8_t typeRequest; uint8_t controlSelector; usb_status_t status = kStatus_USB_Error; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if_ptr = (audio_instance_t *)classHandle; /* Check whether this attribute valid or not */ if (if_ptr->fuDesc == NULL) { return kStatus_USB_Error; } fuDesc = (usb_audio_ctrl_common_fu_desc *)if_ptr->fuDesc; if (AUDIO_DEVICE_VERSION_01 == if_ptr->deviceAudioVersion) { windex = (uint16_t)((uint16_t)((uint16_t)(fuDesc->fuDesc10.bunitid) << 8U) | (if_ptr->streamIfnum)); atribute_index = (uint8_t)(fuDesc->fuDesc10.bcontrolsize * ((uint16_t)csAndCn & 0xFFU)); /*Size of this descriptor, in bytes: 7+(ch+1)*n*/ if (atribute_index < (fuDesc->fuDesc10.blength - 7U)) { bmacontrols = &(fuDesc->fuDesc10.bcontrolsize); } } else if (AUDIO_DEVICE_VERSION_02 == if_ptr->deviceAudioVersion) { windex = (uint16_t)((uint16_t)((uint16_t)(fuDesc->fuDesc20.bunitid) << 8U) | (if_ptr->streamIfnum)); /*BmControl is 4byte, refer to *audio2.0 4.7.2.8 Size of this descriptor, in bytes: 6+(ch+1)*4*/ atribute_index = (uint8_t)(4U * ((uint16_t)csAndCn & 0xFFU)); if (atribute_index < (fuDesc->fuDesc20.blength - 6U)) { bmacontrols = &(fuDesc->fuDesc20.bmaControls0[0]); } } else { /*TO DO*/ } if (bmacontrols == NULL) { return kStatus_USB_Error; } request = (uint8_t)(((uint16_t)cmdCode & 0xFFU)); controlSelector = (uint8_t)((uint16_t)(csAndCn >> 8) & 0xFFU); if (AUDIO_DEVICE_VERSION_01 == if_ptr->deviceAudioVersion) { /*control selector */ switch (controlSelector) { /*note ,all the length is defined in audio1.0 Spec chapter 5.2.2.4.3*/ case AUDIO_FU_MUTE: status = kStatus_USB_Success; length = 1U; break; case AUDIO_FU_VOLUME: status = kStatus_USB_Success; length = 2U; break; case AUDIO_FU_BASS: /*TO DO*/ break; default: /*no action*/ break; } } else if (AUDIO_DEVICE_VERSION_02 == if_ptr->deviceAudioVersion) { if ((request != USB_AUDIO_CS_REQUEST_CODE_RANGE_20) && (request != USB_AUDIO_CS_REQUEST_CODE_CUR_20)) { return kStatus_USB_Error; } switch (controlSelector) { /*note ,all the length is defined in audio2.0 Spec chapter 5.2.5.7*/ case AUDIO_FU_MUTE: if (bufLen != 1U) { return kStatus_USB_Error; } status = kStatus_USB_Success; length = 1U; break; case AUDIO_FU_VOLUME: status = kStatus_USB_Success; if (USB_AUDIO_CS_REQUEST_CODE_RANGE_20 == request) { /*the len for volume is 2+6*n*/ if (bufLen < 8U) { return kStatus_USB_Error; } } else if (USB_AUDIO_CS_REQUEST_CODE_CUR_20 == request) { if (bufLen != 2U) { return kStatus_USB_Error; } } else { /*TO DO*/ } length = (uint16_t)bufLen; break; case AUDIO_FU_BASS: /*TO DO*/ break; default: /*no action*/ break; } } else { /*TO DO*/ } if (status != kStatus_USB_Success) { /*the request is not support*/ return kStatus_USB_Error; } if (0U == ((uint16_t)(cmdCode >> 8U) & 0xFFU)) { /*refer to audio Spec 2.0 chapter 5.2.2*/ typeRequest = 0x21U; } else { typeRequest = 0xA1U; } status = _USB_HostAudioControl(classHandle, typeRequest, request, (uint16_t)csAndCn, windex, length, (uint8_t *)buf, callbackFn, callbackParam); return status; } /*! * @brief usb audio set/get feature unit request. * * This function implements usb audio feature unit request. * * @param classHandle The class handle. * @param csAndCn The CS and CN or MCN for wValue field in setup Request. * @param cmdCode The bRequest code in lower 8bit of lower word and get(1)/set(0) flag in higher 8bit of lower word. * @param buf The feature unit request buffer pointer. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Feature unit request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error Send transfer fail, please reference to USB_HostSendSetup. * */ usb_status_t USB_HostAudioGetSetClockSourceRequest(usb_host_class_handle classHandle, uint32_t csAndCn, uint32_t cmdCode, void *buf, uint32_t bufLen, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *if_ptr; usb_audio_2_0_ctrl_clock_source_desc_t *clockDesc; uint16_t windex; uint16_t controlSelector; uint8_t length = 0U; uint8_t typeRequest; uint8_t request; usb_status_t status = kStatus_USB_Error; if (classHandle == NULL) { return kStatus_USB_InvalidParameter; } if_ptr = (audio_instance_t *)classHandle; if (AUDIO_DEVICE_VERSION_02 == if_ptr->deviceAudioVersion) { clockDesc = (usb_audio_2_0_ctrl_clock_source_desc_t *)if_ptr->clockSource; windex = (uint16_t)((uint16_t)((uint16_t)(clockDesc->bClockID) << 8U) | (if_ptr->streamIfnum)); } else { return kStatus_USB_Error; } request = (uint8_t)(((uint16_t)cmdCode & 0xFFU)); controlSelector = (uint8_t)((uint16_t)(csAndCn >> 8U) & 0xFFU); if (USB_AUDIO_CS_SAM_FREQ_CONTROL_20 == controlSelector) { /*note ,all the length is defined in audio2.0 Spec chapter 5.2.5.1.1*/ if (USB_AUDIO_CS_REQUEST_CODE_RANGE_20 == request) { /*the len for volume is 2+6*n*/ if (bufLen < 12U) { return kStatus_USB_Error; } else { length = (uint8_t)bufLen; } } else if (USB_AUDIO_CS_REQUEST_CODE_CUR_20 == request) { if (bufLen != 4U) { return kStatus_USB_Error; } length = (uint8_t)bufLen; } else { return kStatus_USB_Error; } status = kStatus_USB_Success; } else if (USB_AUDIO_CS_CLOCK_VALID_CONTROL_20 == controlSelector) { status = kStatus_USB_Success; if (bufLen < 1U) { return kStatus_USB_Error; } length = 1U; } else { /**TO DO*/ } if (status != kStatus_USB_Success) { /*the request is not support*/ return kStatus_USB_Error; } if (0U == ((uint16_t)(cmdCode >> 8U) & 0xFFU)) { /*refer to audio Spec 2.0 chapter 5.2.2*/ typeRequest = 0x21U; } else { typeRequest = 0xA1U; } status = _USB_HostAudioControl(classHandle, typeRequest, request, (uint16_t)csAndCn, windex, length, (uint8_t *)buf, callbackFn, callbackParam); return status; } /*! * @brief usb audio feature unit request. * @deprecated Do not use this function. It has been superceded by @ref USB_HostAudioGetSetFeatureUnitRequest. * * This function implements usb audio feature unit request. * * @param classHandle The class handle. * @param channelNo The channel number of audio feature unit. * @param buf The feature unit request buffer pointer. * @param cmdCode The feature unit command code, for example USB_AUDIO_GET_CUR_MUTE etc. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Feature unit request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error Send transfer fail, please reference to USB_HostSendSetup. * */ usb_status_t USB_HostAudioFeatureUnitRequest(usb_host_class_handle classHandle, uint8_t channelNo, void *buf, uint32_t cmdCode, transfer_callback_t callbackFn, void *callbackParam) { /* Body */ uint16_t windex; uint16_t request_value; audio_instance_t *if_ptr; usb_audio_request_t *p_feature_request; usb_audio_ctrl_fu_desc_t *fuDesc; uint8_t *bmacontrols = NULL; uint8_t atribute_index; usb_status_t status; if ((classHandle == NULL)) { return kStatus_USB_InvalidHandle; } if_ptr = (audio_instance_t *)classHandle; if (AUDIO_DEVICE_VERSION_01 != if_ptr->deviceAudioVersion) { return kStatus_USB_Error; } /* pointer to command */ p_feature_request = &(s_usbAudioFuRequests[(uint8_t)cmdCode & 0xfU]); /* get request value */ request_value = (uint16_t)((uint16_t)((uint16_t)p_feature_request->requestValue << 8U) | channelNo); /* Check whether this attribute valid or not */ if (if_ptr->fuDesc == NULL) { return kStatus_USB_Error; } fuDesc = (usb_audio_ctrl_fu_desc_t *)if_ptr->fuDesc; windex = (uint16_t)((uint16_t)((uint16_t)(fuDesc->bunitid) << 8U) | (if_ptr->streamIfnum)); atribute_index = fuDesc->bcontrolsize * channelNo; if (atribute_index < (fuDesc->blength - 7U)) { bmacontrols = &(fuDesc->bcontrolsize); } if (bmacontrols == NULL) { return kStatus_USB_Error; } status = _USB_HostAudioControl(classHandle, (p_feature_request->typeRequest | ((uint8_t)cmdCode & 0x80U)), (p_feature_request->codeRequest | ((uint8_t)cmdCode & 0x80U)), request_value, windex, p_feature_request->length, (uint8_t *)buf, callbackFn, callbackParam); return status; } /*! * @brief usb audio set/get endp unit request. * * This function implements usb audio feature unit request. * * @param classHandle The class handle. * @param csAndCn The CS for wValue field in setup Request. * @param cmdCode The bRequest code in lower 8bit of lower word and get(1)/set(0) flag in higher 8bit of lower word. * @param buf The feature unit request buffer pointer. * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Feature unit request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error Send transfer fail, please reference to USB_HostSendSetup. * */ usb_status_t USB_HostAudioGetSetEndpointRequest(usb_host_class_handle classHandle, uint32_t csAndCn, uint32_t cmdCode, void *buf, uint32_t bufLen, transfer_callback_t callbackFn, void *callbackParam) { audio_instance_t *if_ptr; uint16_t windex; uint8_t request; uint8_t length = 0U; uint8_t typeRequest; uint8_t controlSelector; usb_status_t status = kStatus_USB_Error; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if_ptr = (audio_instance_t *)classHandle; if (AUDIO_DEVICE_VERSION_01 == if_ptr->deviceAudioVersion) { if ((NULL == if_ptr->isoInPipe) && (NULL == if_ptr->isoOutPipe)) { return kStatus_USB_InvalidParameter; } else if (NULL != if_ptr->isoInPipe) { windex = (((uint16_t)if_ptr->isoEpNum) | 0x80U); } else { windex = if_ptr->isoEpNum; } } else if (AUDIO_DEVICE_VERSION_02 == if_ptr->deviceAudioVersion) { /*TO DO*/ } else { /*TO DO*/ } request = (uint8_t)(((uint16_t)cmdCode & 0xFFU)); controlSelector = (uint8_t)((uint16_t)(csAndCn >> 8U) & 0xFFU); if (AUDIO_DEVICE_VERSION_01 == if_ptr->deviceAudioVersion) { /*control selector */ /*note ,all the length is defined in audio1.0 Spec chapter 5.2.3.2.3*/ if (USB_AUDIO_EP_CS_SAMPING_FREQ_CONTROL == controlSelector) { if (bufLen > 3U) { /*fixed length*/ length = 3U; status = kStatus_USB_Success; } else { /*TO DO*/ } } else if (USB_AUDIO_EP_CS_PINTCH_CONTROL == controlSelector) { /*TO DO*/ } else { /*TO DO*/ } } else if (AUDIO_DEVICE_VERSION_02 == if_ptr->deviceAudioVersion) { switch (controlSelector) { /*note ,all the length is defined in audio2.0 Spec chapter 5.2.6*/ case USB_AUDIO_EP_CS_PINTCH_CONTROL_20: /*TO DO*/ break; case USB_AUDIO_EP_CS_OVERRUN_CONTROL_20: /*TO DO*/ break; case USB_AUDIO_EP_CS_UNDERRUN_CONTROL_20: /*TO DO*/ break; default: /*no action*/ break; } } else { /*TO DO*/ } if (status != kStatus_USB_Success) { /*the request is not support*/ return kStatus_USB_Error; } if (0U == ((uint16_t)(cmdCode >> 8U) & 0xFFU)) { /*refer to audio Spec 2.0 chapter 5.2.2*/ typeRequest = 0x22U; } else { typeRequest = 0xA2U; } status = _USB_HostAudioControl(classHandle, typeRequest, request, (uint16_t)csAndCn, windex, length, (uint8_t *)buf, callbackFn, callbackParam); return status; } /*! * @brief usb audio endpoint request. * @deprecated Do not use this function. It has been superceded by @ref USB_HostAudioGetSetEndpointRequest. * * This function implements usb audio endpoint request. * * @param classHandle The class handle. * @param buf The feature unit buffer pointer. * @param cmdCode The feature unit command code, for example USB_AUDIO_GET_CUR_PITCH etc . * @param callbackFn This callback is called after this function completes. * @param callbackParam The first parameter in the callback function. * * @retval kStatus_USB_Success Endpoint request successfully. * @retval kStatus_USB_InvalidHandle The classHandle is NULL pointer. * @retval kStatus_USB_Busy There is no idle transfer. * @retval kStatus_USB_Error Send transfer fail, please reference to USB_HostSendSetup. * */ usb_status_t USB_HostAudioEndpointRequest( usb_host_class_handle classHandle, void *buf, uint32_t cmdCode, transfer_callback_t callbackFn, void *callbackParam) { uint8_t endp_num; usb_status_t status; uint16_t request_value; usb_audio_request_t *p_endpoint_request; audio_instance_t *audioPtr; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } audioPtr = (audio_instance_t *)classHandle; if (AUDIO_DEVICE_VERSION_01 != audioPtr->deviceAudioVersion) { return kStatus_USB_Error; } /* pointer to command */ p_endpoint_request = &(s_usbAudioEpRequests[(uint8_t)cmdCode & 0xfU]); /* get request value */ request_value = (uint16_t)((uint16_t)((uint16_t)p_endpoint_request->requestValue << 8U)); /* Check whether this attribute valid or not */ if (audioPtr->isoEndpDesc == NULL) { return kStatus_USB_Error; } if ((0U != audioPtr->isoEndpDesc->bmAttributes) && (0U != p_endpoint_request->controlMask)) { status = kStatus_USB_Success; } else { status = kStatus_USB_InvalidRequest; } if (kStatus_USB_Success == status) { /* Any isochronous pipe is supported? */ if ((NULL == audioPtr->isoInPipe) && (NULL == audioPtr->isoOutPipe)) { return kStatus_USB_InvalidParameter; } else if (NULL != audioPtr->isoInPipe) { endp_num = (audioPtr->isoEpNum | 0x80U); } else { endp_num = audioPtr->isoEpNum; } /* Endif */ status = _USB_HostAudioControl(classHandle, (p_endpoint_request->typeRequest | ((uint8_t)cmdCode & 0x80U)), (p_endpoint_request->codeRequest | ((uint8_t)cmdCode & 0x80U)), request_value, endp_num, p_endpoint_request->length, (uint8_t *)buf, callbackFn, callbackParam); } return status; } usb_status_t USB_HostAudioSetStreamOutDataInterval(usb_host_class_handle classHandle, uint8_t intervalValue) { audio_instance_t *audioPtr = (audio_instance_t *)classHandle; usb_status_t status = kStatus_USB_Error; uint8_t ep_index = 0U; usb_descriptor_endpoint_t *ep_desc = NULL; usb_host_interface_t *interface_ptr; if (classHandle == NULL) { return kStatus_USB_InvalidHandle; } if (audioPtr->isoOutPipe != NULL) { (void)USB_HostClosePipe(audioPtr->hostHandle, audioPtr->isoOutPipe); audioPtr->isoOutPipe = NULL; } /* open interface pipes */ interface_ptr = (usb_host_interface_t *)audioPtr->streamIntfHandle; for (ep_index = 0U; ep_index < interface_ptr->epCount; ++ep_index) { ep_desc = interface_ptr->epList[ep_index].epDesc; if (((ep_desc->bEndpointAddress & USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_MASK) == USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_OUT) && ((ep_desc->bmAttributes & USB_DESCRIPTOR_ENDPOINT_ATTRIBUTE_TYPE_MASK) == USB_ENDPOINT_ISOCHRONOUS)) { uint8_t intervalBackUp = ep_desc->bInterval; ep_desc->bInterval = intervalValue; status = _USB_HostAudioInitEndpoint(audioPtr, ep_desc); ep_desc->bInterval = intervalBackUp; } } return status; } #endif /* USB_HOST_CONFIG_AUDIO */