/* * Copyright (c) 2022, sakumisu * * SPDX-License-Identifier: Apache-2.0 */ #include "rtthread.h" #ifdef RT_USBH_UAC #include "basic_include.h" #include "rttusb_host.h" #include "usbh_audio.h" #define DEV_FORMAT "/dev/audio%d" /* general descriptor field offsets */ #define DESC_bLength 0 /** Length offset */ #define DESC_bDescriptorType 1 /** Descriptor type offset */ #define DESC_bDescriptorSubType 2 /** Descriptor subtype offset */ /* interface descriptor field offsets */ #define INTF_DESC_bInterfaceNumber 2 /** Interface number offset */ #define INTF_DESC_bAlternateSetting 3 /** Alternate setting offset */ #define AUDIO_FREE_PIPE 0 #define AUDIO_ALLOC_PIPE 1 #define AUDIO_MIC_EN 1 //应用层MIC使能 #define AUDIO_SPK_EN 1 //应用层SPK使能 #define AUDIO_VOLUME_CONTROL_EN 0 //UAC音量控制使能 (根据设备是否支持该功能，自行选择打开) #define AUDIO_SET_INTF_ALTSETTING 1 /* ---------------------------- MIC ---------------------------- */ #define AUDIO_MIC_SAMPLING_FREQ 8000 //设置MIC接收的采样率 #define AUDIO_MIC_RESOLUTION_BITS 16 //设置MIC接收的采样精度 #define AUDIO_MIC_MODULE_CHANNEL 1 //设置MIC接收的通道数 #define AUDIO_MIC_RESOLUTION_BYTES (AUDIO_MIC_RESOLUTION_BITS / 8) #define AUDIO_RX_PACKET_SIZE ((AUDIO_MIC_SAMPLING_FREQ * AUDIO_MIC_MODULE_CHANNEL * AUDIO_MIC_RESOLUTION_BYTES) / 1000) //计算MIC每毫秒接收的数据包大小 /* ---------------------------- SPK ---------------------------- */ #define AUDIO_SPK_SAMPLING_FREQ 8000 //设置SPK发送的采样率 #define AUDIO_SPK_RESOLUTION_BITS 16 //设置SPK发送的采样精度 #define AUDIO_SPK_MODULE_CHANNEL 1 //设置SPK发送的通道数 #define AUDIO_SPK_RESOLUTION_BYTES (AUDIO_SPK_RESOLUTION_BITS / 8) #define AUDIO_TX_PACKET_SIZE ((AUDIO_SPK_SAMPLING_FREQ * AUDIO_SPK_MODULE_CHANNEL * AUDIO_SPK_RESOLUTION_BYTES) / 1000) //计算SPK每毫秒发送的数据包大小 extern uint32 usbmic_packet_len; extern uint8_t uac_run; extern uint8_t uac_open; static int usb_dma_uac_irq_times = 0; static struct uclass_driver usbh_audio_class; rt_uint8_t g_audio_buf[128]; struct usbh_audio g_audio_class[CONFIG_USBHOST_MAX_AUDIO_CLASS]; static rt_uint32_t g_devinuse = 0; static struct usbh_audio *usbh_audio_class_alloc(void) { int devno; for (devno = 0; devno < CONFIG_USBHOST_MAX_AUDIO_CLASS; devno++) { if ((g_devinuse & (1 << devno)) == 0) { g_devinuse |= (1 << devno); memset(&g_audio_class[devno], 0, sizeof(struct usbh_audio)); g_audio_class[devno].minor = devno; return &g_audio_class[devno]; } } return RT_NULL; } static void usbh_audio_class_free(struct usbh_audio *audio_class) { int devno = audio_class->minor; if (devno >= 0 && devno < 32) { g_devinuse &= ~(1 << devno); } memset(audio_class, 0, sizeof(struct usbh_audio)); } int usbh_audio_open(struct usbh_audio *audio_class, const char *name, rt_uint32_t samp_freq) { struct urequest setup; struct uendpoint_descriptor *ep_desc = RT_NULL; rt_uint8_t intf = 0xff; rt_uint8_t altsetting = 1; int timeout = USB_TIMEOUT_BASIC; // if (audio_class->is_opened) { // return 0; // } for (rt_uint8_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { printf("audio_class->module[%d]\n",i); for (rt_uint8_t j = 0; j < audio_class->num_of_intf_altsettings; j++) { for (rt_uint8_t k = 0; k < audio_class->module[i].altsetting[j].sampfreq_num; k++) { if (audio_class->module[i].altsetting[j].sampfreq[k] == samp_freq) { intf = audio_class->module[i].data_intf; altsetting = j; printf("usb host audio open:%d %d\n",intf,altsetting); goto freq_found; } } } } } return -EIO; freq_found: setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_INTERFACE; setup.bRequest = USB_REQ_SET_INTERFACE; setup.wValue = altsetting; setup.wIndex = intf; setup.wLength = 0; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RET_ERR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RET_ERR; } if (strcmp(name, "mic") == 0) { ep_desc = &audio_class->isoin; } else if (strcmp(name, "speaker") == 0) { ep_desc = &audio_class->isoout; } setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_ENDPOINT; setup.bRequest = SET_CUR; setup.wValue = (SAMPLING_FREQ_CONTROL << 8) | 0x00; setup.wIndex = ep_desc->bEndpointAddress; setup.wLength = 3; memcpy(g_audio_buf, &samp_freq, 3); if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RET_ERR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, g_audio_buf, 3, timeout) != 3) { return RET_ERR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RET_ERR; } os_printf("Open audio module :%s, altsetting: %u\r\n", name, altsetting); audio_class->is_opened = TRUE; uac_open = 1; uac_run = 1; return RT_EOK; } int usbh_audio_close(struct usbh_audio *audio_class, const char *name) { struct urequest setup; rt_uint8_t intf = 0xff; int timeout = USB_TIMEOUT_BASIC; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->module[i].data_intf; } } if (intf == 0xff) { return -EIO; } LOG_D("Close audio module :%s\r\n", name); audio_class->is_opened = FALSE; setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_INTERFACE; setup.bRequest = USB_REQ_SET_INTERFACE; setup.wValue = 0; setup.wIndex = intf; setup.wLength = 0; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } uac_open = 0; uac_run = 0; return RT_EOK; } int usbh_audio_get_min_volume(struct usbh_audio *audio_class, const char *name, rt_uint16_t *min_volume) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = GET_MIN; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } memcpy(min_volume, g_audio_buf, 2); return RT_EOK; } int usbh_audio_get_max_volume(struct usbh_audio *audio_class, const char *name, rt_uint16_t *max_volume) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = GET_MAX; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } memcpy(max_volume, g_audio_buf, 2); return RT_EOK; } int usbh_audio_get_cur_volume(struct usbh_audio *audio_class, const char *name, rt_uint16_t *cur_volume) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = GET_CUR; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } memcpy(cur_volume, g_audio_buf, 2); return RT_EOK; } int usbh_audio_get_res_volume(struct usbh_audio *audio_class, const char *name, rt_uint16_t *res_volume) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = GET_RES; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } memcpy(res_volume, g_audio_buf, 2); return RT_EOK; } int usbh_audio_set_volume(struct usbh_audio *audio_class, const char *name, rt_uint16_t volume_hex) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; if(audio_class == RT_NULL) { return -EIO; } for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff || feature_id == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = SET_CUR; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; memcpy(g_audio_buf, &volume_hex, 2); if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } return RT_EOK; } int usbh_audio_set_volume_db(struct usbh_audio *audio_class, const char *name, int volume_db, int min_volume_db, int max_volume_db) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; rt_uint16_t volume_hex; float volume_min_db,volume_max_db; rt_uint8_t ch; int timeout = USB_TIMEOUT_BASIC; if(audio_class == RT_NULL) { return -EIO; } if ((volume_db > 127) || (volume_db < -127)) { return -EIO; } for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff || feature_id == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = SET_CUR; setup.wValue = (VOLUME_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 2; if (min_volume_db < 0x8000) { volume_min_db = (float)min_volume_db / 256; } else { volume_min_db = (float)(min_volume_db - 0x10000) / 256; } if (max_volume_db < 0x8000) { volume_max_db = (float)max_volume_db / 256; } else { volume_max_db = (float)(max_volume_db - 0x10000) / 256; } os_printf("Get ch: [%s] , dB range: %f dB ~ %f dB , set %d dB\r\n", name, volume_min_db, volume_max_db, volume_db); if (volume_db > volume_max_db || volume_db < volume_min_db) { os_printf("set (%d dB) not in range!!!\n",volume_db); return RT_ERROR; } if (volume_db >= 0) { volume_hex = volume_db * 256; if (volume_hex > max_volume_db) { os_printf("%s [ERR]volume_hex(%x) not in range\n",__FUNCTION__,volume_hex); return RT_ERROR; } } else { volume_hex = volume_db * 256 + 0x10000; if (volume_hex < min_volume_db) { os_printf("%s [ERR]volume_hex(%x) not in range\n",__FUNCTION__,volume_hex); return RT_ERROR; } } memcpy(g_audio_buf, &volume_hex, 2); if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, g_audio_buf, 2, timeout) != 2) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } os_printf("%s success, volume_hex:%x\n",__FUNCTION__,volume_hex); return RT_EOK; } int usbh_audio_set_mute(struct usbh_audio *audio_class, const char *name, bool mute) { struct urequest setup; rt_uint8_t intf = 0xff; rt_uint8_t feature_id = 0xff; int timeout = USB_TIMEOUT_BASIC; rt_uint8_t ch; for (size_t i = 0; i < audio_class->module_num; i++) { if (strcmp(name, audio_class->module[i].name) == 0) { intf = audio_class->ctrl_intf; feature_id = audio_class->module[i].feature_unit_id; ch = audio_class->module[i].altsetting[AUDIO_SET_INTF_ALTSETTING].channels; } } if (intf == 0xff) { return -EIO; } setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE; setup.bRequest = SET_CUR; setup.wValue = (MUTE_CONTROL << 8) | ch; setup.wIndex = (feature_id << 8) | intf; setup.wLength = 1; memcpy(g_audio_buf, &mute, 1); if(rt_usb_hcd_setup_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, &setup, timeout) != 8) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_out, g_audio_buf, 1, timeout) != 1) { return RT_ERROR; } if(rt_usb_hcd_pipe_xfer(audio_class->device->hcd, audio_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0) { return RT_ERROR; } return RT_EOK; } void usbh_audio_list_module(struct usbh_audio *audio_class) { uep_desc_t ep_desc = RT_NULL; rt_uint8_t mult; rt_uint16_t mps; os_printf("============= Audio module information ===================\r\n"); os_printf("bcdADC :%04x\r\n", audio_class->bcdADC); os_printf("Num of modules :%u\r\n", audio_class->module_num); os_printf("Num of altsettings:%u\r\n", audio_class->num_of_intf_altsettings); for (rt_uint8_t i = 0; i < audio_class->module_num; i++) { os_printf(" module name :%s\r\n", audio_class->module[i].name); os_printf(" module feature unit id :%d\r\n", audio_class->module[i].feature_unit_id); if(strcmp("mic", audio_class->module[i].name) == 0) { ep_desc = &audio_class->isoin; }else if (strcmp("speaker", audio_class->module[i].name) == 0) { ep_desc = &audio_class->isoout; } mult = (ep_desc->wMaxPacketSize & USB_MAXPACKETSIZE_ADDITIONAL_TRANSCATION_MASK) >> USB_MAXPACKETSIZE_ADDITIONAL_TRANSCATION_SHIFT; mps = ep_desc->wMaxPacketSize & USB_MAXPACKETSIZE_MASK; if (ep_desc->bEndpointAddress & 0x80) { audio_class->isoin_mps = mps * (mult + 1); } else { audio_class->isoout_mps = mps * (mult + 1); } os_printf(" Ep=%02X Attr=%02x Mps=%d Interval=%02u Mult=%02u\r\n", ep_desc->bEndpointAddress, ep_desc->bmAttributes, mps, ep_desc->bInterval, mult); for (rt_uint8_t j = 0; j < audio_class->num_of_intf_altsettings; j++) { if (j == 0) { os_printf(" Ingore altsetting 0\r\n"); continue; } os_printf(" Altsetting %u\r\n", j); os_printf(" module channels :%u\r\n", audio_class->module[i].altsetting[j].channels); //LOG_D(" module format_type :%u\r\n",audio_class->module[i].altsetting[j].format_type); os_printf(" module bitresolution :%u\r\n", audio_class->module[i].altsetting[j].bitresolution); os_printf(" module sampfreq num :%u\r\n", audio_class->module[i].altsetting[j].sampfreq_num); for (rt_uint8_t k = 0; k < audio_class->module[i].altsetting[j].sampfreq_num; k++) { os_printf(" module sampfreq :%d hz\r\n", audio_class->module[i].altsetting[j].sampfreq[k]); } } } os_printf("============= Audio module information ===================\r\n"); } static rt_err_t rt_usbh_class_driver_audio_enable(void *arg) { int ret; struct uhintf **p_intf = arg; rt_uint8_t intf; rt_uint8_t cur_iface = 0xff; rt_uint8_t cur_iface_count = 0xff; rt_uint8_t cur_alt_setting = 0xff; rt_uint8_t input_offset = 0; rt_uint8_t output_offset = 0; rt_uint8_t feature_unit_offset = 0; rt_uint8_t format_offset = 0; rt_uint8_t *p = RT_NULL; uhcd_t hcd = NULL; uep_desc_t ep_desc; if (p_intf[0] == NULL) { return -EIO; } hcd = p_intf[0]->device->hcd; intf = p_intf[0]->intf_desc->bInterfaceNumber; struct usbh_audio *audio_class = usbh_audio_class_alloc(); if (audio_class == RT_NULL) { LOG_D("Fail to alloc audio_class\r\n"); return RET_ERR; } audio_class->device = p_intf[0]->device; audio_class->ctrl_intf = intf; audio_class->num_of_intf_altsettings = 2; p_intf[0]->user_data = audio_class; p = (rt_uint8_t *)(p_intf[0]->device->cfg_desc); while (p[DESC_bLength]) { switch (p[DESC_bDescriptorType]) { case USB_DESC_TYPE_IAD: cur_iface_count = p[3]; break; case USB_DESC_TYPE_INTERFACE: cur_iface = p[INTF_DESC_bInterfaceNumber]; cur_alt_setting = p[INTF_DESC_bAlternateSetting]; break; case USB_DESC_TYPE_ENDPOINT: //os_printf("USB_DESC_TYPE_ENDPOINT\n"); if(((cur_iface == audio_class->module[0].data_intf) && (audio_class->module[0].data_intf != 0)) || ((cur_iface == audio_class->module[1].data_intf) && (audio_class->module[1].data_intf != 0))) { ep_desc = (struct uendpoint_descriptor *)p; os_printf("Altsetting:%u, Ep=%02x Attr=%02u Mps=%d Interval=%02u Cur_iface:%d\r\n", cur_alt_setting, ep_desc->bEndpointAddress, ep_desc->bmAttributes, ep_desc->wMaxPacketSize, ep_desc->bInterval, cur_iface); if (cur_alt_setting == AUDIO_SET_INTF_ALTSETTING) { if(((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN ) && ((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_ISOC)) { audio_class->isoin = *ep_desc; } if(((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_OUT ) && ((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_ISOC)) { audio_class->isoout = *ep_desc; } } } break; case UDESC_CS_INTERFACE: if (cur_iface == audio_class->ctrl_intf) { switch (p[DESC_bDescriptorSubType]) { case UDESCSUB_AC_HEADER: { struct usb_audio_control_descriptor *desc = (struct usb_audio_control_descriptor *)p; audio_class->bcdADC = desc->bcdADC; audio_class->bInCollection = desc->bInCollection; } break; case UDESCSUB_AC_INPUT: { struct usb_audio_input_terminal *desc = (struct usb_audio_input_terminal *)p; audio_class->module[input_offset].input_terminal_id = desc->bTerminalId; audio_class->module[input_offset].input_terminal_type = desc->wTerminalType; audio_class->module[input_offset].input_channel_config = desc->wChannelConfig; if (desc->wTerminalType == UAT_STREAM) { audio_class->module[input_offset].terminal_link_id = desc->bTerminalId; } if (desc->wTerminalType == UATI_MICROPHONE) { audio_class->module[input_offset].name = "mic"; } input_offset++; } break; break; case UDESCSUB_AC_OUTPUT: { struct usb_audio_output_terminal *desc = (struct usb_audio_output_terminal *)p; audio_class->module[output_offset].output_terminal_id = desc->bTerminalId; audio_class->module[output_offset].output_terminal_type = desc->wTerminalType; if (desc->wTerminalType == UAT_STREAM) { audio_class->module[output_offset].terminal_link_id = desc->bTerminalId; } if (desc->wTerminalType == UATO_SPEAKER) { audio_class->module[output_offset].name = "speaker"; } output_offset++; } break; case UDESCSUB_AC_FEATURE: { struct usb_audio_feature_unit *desc = (struct usb_audio_feature_unit *)p; audio_class->module[feature_unit_offset].feature_unit_id = desc->bUnitId; audio_class->module[feature_unit_offset].feature_unit_controlsize = desc->bControlSize; for (rt_uint8_t j = 0; j < desc->bControlSize; j++) { audio_class->module[feature_unit_offset].feature_unit_controls[j] = p[6 + j]; } feature_unit_offset++; } break; case UDESCSUB_AC_PROCESSING: break; default: break; } } else if ((cur_iface < (audio_class->ctrl_intf + cur_iface_count)) && (cur_iface > audio_class->ctrl_intf)) { switch (p[DESC_bDescriptorSubType]) { case AS_GENERAL: break; case FORMAT_TYPE: { struct usb_audio_streaming_type1_descriptor *desc = (struct usb_audio_streaming_type1_descriptor *)p; audio_class->module[format_offset].data_intf = cur_iface; audio_class->module[format_offset].altsetting[cur_alt_setting].channels = desc->bNrChannels; audio_class->module[format_offset].altsetting[cur_alt_setting].format_type = desc->bFormatType; audio_class->module[format_offset].altsetting[cur_alt_setting].bitresolution = desc->bBitResolution; audio_class->module[format_offset].altsetting[cur_alt_setting].sampfreq_num = desc->bSamFreqType; for (rt_uint8_t j = 0; j < desc->bSamFreqType; j++) { audio_class->module[format_offset].altsetting[cur_alt_setting].sampfreq[j] = (rt_uint32_t)(p[10 + j * 3] << 16) | (rt_uint32_t)(p[9 + j * 3] << 8) | (rt_uint32_t)(p[8 + j * 3] << 0); } if (cur_alt_setting == (audio_class->num_of_intf_altsettings - 1)) { format_offset++; } } break; default: break; } } break; default: break; } /* skip to next descriptor */ p += p[DESC_bLength]; } if ((input_offset != output_offset) && (input_offset != feature_unit_offset) && (input_offset != format_offset)) { return -EIO; } audio_class->module_num = input_offset; usbh_audio_list_module(audio_class); audio_class->rx_buff = (rt_uint8_t *)rt_malloc(AUDIO_RX_PACKET_SIZE + USB_RX_BUFF_RESERVE_SIZE); if(audio_class->rx_buff == RT_NULL) { os_printf("malloc rx_buff fail\n"); return RT_ENOMEM; } for (size_t i = 0; i < audio_class->module_num; i++) { ret = usbh_audio_close(audio_class, audio_class->module[i].name); if (ret < 0) { os_printf("Fail to close audio module :%s\r\n", audio_class->module[i].name); return ret; } } snprintf(audio_class->devname, CONFIG_USBHOST_DEV_NAMELEN, DEV_FORMAT, audio_class->minor); os_printf("Register Audio Class:%s\r\n", audio_class->devname); usbh_audio_run(audio_class); return 0; } static rt_err_t rt_usbh_class_driver_audio_disable(void *arg) { int ret = RT_EOK; struct uhintf *p_intf = arg; if (p_intf == NULL) { return -EIO; } struct usbh_audio *audio_class = (struct usbh_audio *)p_intf->user_data; if (audio_class) { if (audio_class->devname[0] != '\0') { os_printf("Unregister Audio Class:%s\r\n", audio_class->devname); usbh_audio_stop(audio_class); } if(audio_class->rx_buff) { rt_free(audio_class->rx_buff); } usbh_audio_class_free(audio_class); } return ret; } /* ----------------------------- USB 2.0 / USB 1.1 UAC IRQ ----------------------------- */ static void _usbh_audio_spk_tx(void * p_dev, uint8_t ep, uint8_t *data, uint32_t len) { struct usb_device_dma_cfg dma_cfg; if (p_dev == RT_NULL || data == RT_NULL || len == 0) { return; } dma_cfg.ep_index = ep; dma_cfg.ep_dir = USB_CORE_HOST_EP_TX; dma_cfg.dma_addr = (rt_uint32_t *)data; dma_cfg.dma_len = len; usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL); } bool rtt_uac_data_deal(void *p_dev, rt_uint8_t ep) { rt_int32_t rx_len = 0; usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_GET_RX_DMA_LEN, ep, (rt_uint32_t)&rx_len); if((rx_len == 0) || (rx_len != AUDIO_RX_PACKET_SIZE)){ return 1; } if(rx_len < 0){ os_printf("The length of the configured dma needs to be increased\n"); return 1; } usbmic_packet_len = rx_len; // os_printf("rx_len:%d\n", rx_len); return 0; } void rtt_usbh_audio_irq(void * dev, rt_uint32_t irq, rt_uint8_t ep) { rt_uint32_t ret; struct usb_device *p_dev = (struct usb_device *)dev; struct usb_device_dma_cfg dma_cfg; if (!p_dev) return; switch (irq) { case USB_EP_RX_IRQ: if ((ep == (&g_audio_class[0])->pipe_in->pipe_index) && ((&g_audio_class[0])->pipe_in != RT_NULL)) { #if AUDIO_MIC_EN usb_dma_uac_irq_times++; if(uac_open && uac_run) { ret = rtt_uac_data_deal(p_dev, ep); if(ret == 0){ ret = usbmic_deal((struct usb_device *)p_dev, (uint8_t *)(&g_audio_class[0])->rx_buff); } dma_cfg.ep_index = ep; dma_cfg.ep_dir = USB_CORE_HOST_EP_RX; dma_cfg.dma_addr = (rt_uint32_t *)g_audio_class[0].rx_buff; dma_cfg.dma_len = AUDIO_RX_PACKET_SIZE; usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL); } #endif } break; case USB_EP_TX_IRQ: if ((ep == (&g_audio_class[0])->pipe_out->pipe_index) && ((&g_audio_class[0])->pipe_out != RT_NULL)) { #if AUDIO_SPK_EN usb_dma_uac_irq_times++; if(uac_open && uac_run) { usbspk_tx((struct usb_device *)p_dev, ep, AUDIO_TX_PACKET_SIZE, _usbh_audio_spk_tx); } #endif } break; default: break; } } rt_uint32_t rtt_usbh_audio_dev_pipe_mange(rt_uint8_t dev_num, const char *name, rt_uint8_t alloc_or_free) { uep_desc_t ep_desc = RT_NULL; upipe_t pipe; struct usbh_audio *audio_class = RT_NULL; if(dev_num >= CONFIG_USBHOST_MAX_AUDIO_CLASS) { os_printf("Invalid dev_num %d!!!!!!!!\n",dev_num); return -RT_ERROR; } audio_class = &g_audio_class[dev_num]; if (strcmp(name, "mic") == 0) { ep_desc = &audio_class->isoin; } else if (strcmp(name, "speaker") == 0) { ep_desc = &audio_class->isoout; } os_printf("Audio Class dev%d: Altsetting:%u, Ep=%02x Attr=%02u Mps=%d Interval=%02u\r\n", dev_num, AUDIO_SET_INTF_ALTSETTING, ep_desc->bEndpointAddress, ep_desc->bmAttributes, ep_desc->wMaxPacketSize, ep_desc->bInterval); if(ep_desc->bEndpointAddress == 0 || ep_desc->bmAttributes == 0 || ep_desc->wMaxPacketSize == 0) { return -RT_ERROR; } if(alloc_or_free) { pipe = rt_usb_instance_find_pipe(audio_class->device, ep_desc->bEndpointAddress); if(pipe != RT_NULL) { os_printf("g_video_class[%d] pipe has been alloced!!!\n",dev_num); return -RT_ERROR; } if (rt_usb_hcd_alloc_pipe(audio_class->device->hcd, &pipe, audio_class->device, ep_desc) != RT_EOK) { rt_kprintf("alloc iso pipe failed\n"); return -RT_ERROR; } os_printf("alloc iso pipe ok %x\n",pipe); rt_usb_instance_add_pipe(audio_class->device, pipe); if ((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN) { audio_class->pipe_in = pipe; } else { audio_class->pipe_out = pipe; } struct usb_device *p_dev = NULL; switch(g_audio_class[0].device->hcd->devid) { case HG_USB11_HOST_CONTROLLER_DEVID: { os_printf("HG_USB11_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USB11HOST_DEVID); if (p_dev) { os_printf("kick usb11\n"); }; /* USB Full Speed : 1 frame = 1 ms */ if ((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN) { usb_device_ioctl(p_dev, USB_HOST_SET_RX_INTERVAL, pipe->pipe_index, 1); } else { usb_device_ioctl(p_dev, USB_HOST_SET_TX_INTERVAL, pipe->pipe_index, 1); } } break; case HG_USB_HOST_CONTROLLER_DEVID: { os_printf("HG_USB_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USBDEV_DEVID); if (p_dev) { os_printf("kick usb20\n"); }; if (usb_device_ioctl(p_dev, USB_HOST_GET_BUS_SPEED, 0, 0)) { /* USB High Speed : 8 microframe = 1 ms */ if ((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN) { usb_device_ioctl(p_dev, USB_HOST_SET_RX_INTERVAL, pipe->pipe_index, 4); } else { usb_device_ioctl(p_dev, USB_HOST_SET_TX_INTERVAL, pipe->pipe_index, 4); } } else { /* USB Full Speed : 1 frame = 1 ms */ if ((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN) { usb_device_ioctl(p_dev, USB_HOST_SET_RX_INTERVAL, pipe->pipe_index, 1); } else { usb_device_ioctl(p_dev, USB_HOST_SET_TX_INTERVAL, pipe->pipe_index, 1); } } } break; default: break; } } else { if ((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN) { if(audio_class->pipe_in != RT_NULL) { rt_list_remove(&audio_class->pipe_in->list); rt_usb_hcd_free_pipe(audio_class->device->hcd, audio_class->pipe_in); audio_class->pipe_in = RT_NULL; } else { os_printf("g_audio_class[%d] pipe_in is NULL, not free\n",dev_num); return -RT_ERROR; } } else { if(audio_class->pipe_out != RT_NULL) { rt_list_remove(&audio_class->pipe_out->list); rt_usb_hcd_free_pipe(audio_class->device->hcd, audio_class->pipe_out); audio_class->pipe_out = RT_NULL; } else { os_printf("g_audio_class[%d] pipe_out is NULL, not free\n",dev_num); return -RT_ERROR; } } } return RT_EOK; } /* 用户调用接口 */ rt_uint32_t rtt_usbh_audio_user_open() { rt_uint32_t ret; struct usbh_audio *audio_class = &g_audio_class[0]; struct usb_device *p_dev = NULL; switch(g_audio_class[0].device->hcd->devid) { case HG_USB11_HOST_CONTROLLER_DEVID: { os_printf("HG_USB11_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USB11HOST_DEVID); if (p_dev) { os_printf("kick usb11\n"); }; } break; case HG_USB_HOST_CONTROLLER_DEVID: { os_printf("HG_USB_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USBDEV_DEVID); if (p_dev) { os_printf("kick usb20\n"); }; } break; default: break; } #if AUDIO_VOLUME_CONTROL_EN rt_uint16_t min_volume,max_volume,res_volume,cur_volume; #if AUDIO_MIC_EN //设置设备非静音状态和音量大小 usbh_audio_set_mute(audio_class, "mic", 0); //获取设备最大最小音量，设置音量大小 usbh_audio_get_cur_volume(audio_class, "mic", &cur_volume); usbh_audio_get_min_volume(audio_class, "mic", &min_volume); usbh_audio_get_max_volume(audio_class, "mic", &max_volume); usbh_audio_get_res_volume(audio_class, "mic", &res_volume); os_printf("[mic] min volume:%x,max volume:%x cur_volume:%x res_volume:%x\n",min_volume,max_volume,cur_volume,res_volume); usbh_audio_set_volume(audio_class, "mic", max_volume); //默认设置最大音量 //usbh_audio_set_volume_db(audio_class, "mic", -127, min_volume, max_volume); //根据打印的可调dB范围设置 #endif #if AUDIO_SPK_EN //设置设备非静音状态 usbh_audio_set_mute(audio_class, "speaker", 0); //获取设备最大最小音量，设置音量大小 usbh_audio_get_cur_volume(audio_class, "speaker", &cur_volume); usbh_audio_get_min_volume(audio_class, "speaker", &min_volume); usbh_audio_get_max_volume(audio_class, "speaker", &max_volume); usbh_audio_get_res_volume(audio_class, "spekaer", &res_volume); os_printf("[speaker] min volume:%x,max volume:%x cur_volume:%x res_volume:%x\n",min_volume,max_volume,cur_volume,res_volume); usbh_audio_set_volume(audio_class, "speaker", max_volume); //默认设置最大音量 //usbh_audio_set_volume_db(audio_class, "speaker", -37, min_volume, max_volume); //根据打印的可调dB范围设置 #endif #endif //给设备分配pipe #if AUDIO_MIC_EN rtt_usbh_audio_dev_pipe_mange(0, "mic", AUDIO_ALLOC_PIPE); #endif #if AUDIO_SPK_EN rtt_usbh_audio_dev_pipe_mange(0, "speaker", AUDIO_ALLOC_PIPE); #endif //USB发送打开UAC数据流命令 #if AUDIO_MIC_EN ret = usbh_audio_open(audio_class, "mic", AUDIO_MIC_SAMPLING_FREQ); if(ret != 0){ printf("mic open fail\n"); return -RT_ERROR; } #endif #if AUDIO_SPK_EN ret = usbh_audio_open(audio_class, "speaker", AUDIO_SPK_SAMPLING_FREQ); if(ret != 0){ printf("speaker open fail\n"); return -RT_ERROR; } #endif //应用层数据流初始化 #if AUDIO_MIC_EN usbmic_room_init(); usbmic_enum_finish(&usb_dma_uac_irq_times); #endif #if AUDIO_SPK_EN usbspk_room_init(AUDIO_TX_PACKET_SIZE); usbspk_enum_finish(&usb_dma_uac_irq_times); #endif //使能端点收发，触发中断循环 #if AUDIO_MIC_EN struct usb_device_dma_cfg dma_cfg; dma_cfg.ep_index = (&g_audio_class[0])->pipe_in->pipe_index; dma_cfg.ep_dir = USB_CORE_HOST_EP_RX; dma_cfg.dma_addr = (rt_uint32_t *)g_audio_class[0].rx_buff; dma_cfg.dma_len = AUDIO_RX_PACKET_SIZE; usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL); #endif #if AUDIO_SPK_EN usbspk_tx(p_dev, (&g_audio_class[0])->pipe_out->pipe_index, AUDIO_TX_PACKET_SIZE, _usbh_audio_spk_tx); #endif return RET_OK; } rt_uint32_t rtt_usbh_audio_user_close() { struct usbh_audio *audio_class = &g_audio_class[0]; rtt_usbh_audio_user_stop(); #if AUDIO_MIC_EN rtt_usbh_audio_dev_pipe_mange(0, "mic", AUDIO_FREE_PIPE); #endif #if AUDIO_SPK_EN rtt_usbh_audio_dev_pipe_mange(0, "speaker", AUDIO_FREE_PIPE); #endif #if AUDIO_MIC_EN usbh_audio_close(audio_class, "mic"); #endif #if AUDIO_SPK_EN usbh_audio_close(audio_class, "speaker"); #endif return RT_EOK; } rt_uint32_t rtt_usbh_audio_user_stop() { struct usb_device *p_dev = NULL; uac_stop(); switch(g_audio_class[0].device->hcd->devid) { case HG_USB11_HOST_CONTROLLER_DEVID: { os_printf("HG_USB11_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USB11HOST_DEVID); if (p_dev) { #if AUDIO_MIC_EN hgusb11_v0_host_ep_abort(p_dev, USB_CORE_HOST_EP_RX, (&g_audio_class[0])->pipe_in->pipe_index); #endif #if AUDIO_SPK_EN hgusb11_v0_host_ep_abort(p_dev, USB_CORE_HOST_EP_TX, (&g_audio_class[0])->pipe_out->pipe_index); #endif }; } break; case HG_USB_HOST_CONTROLLER_DEVID: { os_printf("HG_USB_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USBDEV_DEVID); if (p_dev) { #if AUDIO_MIC_EN hgusb20_ep_rx_abort((struct hgusb20_dev *)p_dev, (&g_audio_class[0])->pipe_in->pipe_index); #endif #if AUDIO_SPK_EN hgusb20_ep_tx_abort((struct hgusb20_dev *)p_dev, (&g_audio_class[0])->pipe_out->pipe_index); #endif }; } break; default: break; } return RT_EOK; } rt_uint32_t rtt_usbh_audio_user_start() { struct usb_device *p_dev = NULL; switch(g_audio_class[0].device->hcd->devid) { case HG_USB11_HOST_CONTROLLER_DEVID: { os_printf("HG_USB11_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USB11HOST_DEVID); if (p_dev) { os_printf("kick usb11\n"); }; } break; case HG_USB_HOST_CONTROLLER_DEVID: { os_printf("HG_USB_HOST_CONTROLLER_DEVID\n"); p_dev = (struct usb_device *)dev_get(HG_USBDEV_DEVID); if (p_dev) { os_printf("kick usb20\n"); }; } break; default: break; } if(uac_open) { uac_run = 1; #if AUDIO_MIC_EN struct usb_device_dma_cfg dma_cfg; dma_cfg.ep_index = (&g_audio_class[0])->pipe_in->pipe_index; dma_cfg.ep_dir = USB_CORE_HOST_EP_RX; dma_cfg.dma_addr = (rt_uint32_t *)g_audio_class[0].rx_buff; dma_cfg.dma_len = AUDIO_RX_PACKET_SIZE; usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL); #endif #if AUDIO_SPK_EN usbspk_tx((struct usb_device *)p_dev, (&g_audio_class[0])->pipe_out->pipe_index, AUDIO_TX_PACKET_SIZE, _usbh_audio_spk_tx); #endif } return RT_EOK; } int32 demo_atcmd_usbh_audio(const char *cmd, char *argv[], uint32 argc) { if (*argv[0] == '1') { if (*argv[1] == '1') { rtt_usbh_audio_user_open(); } if (*argv[1] == '0') { rtt_usbh_audio_user_close(); } } else if (*argv[0] == '2') { if (*argv[1] == '1') { } if (*argv[1] == '0') { } } printf("OK/n"); return 0; } void usbh_audio_thread_entry(void *arg) { //struct usbh_audio *audio_class = arg; } __attribute__((weak)) void usbh_audio_run(struct usbh_audio *audio_class) { rtt_usbh_audio_user_open(); #if 0 rt_thread_t usbh_audio_thread; usbh_audio_thread = rt_thread_create("usbh_video_thread", usbh_audio_thread_entry, audio_class, 1024, OS_TASK_PRIORITY_NORMAL, 20); if(usbh_audio_thread != RT_NULL) rt_thread_startup(usbh_audio_thread); #endif } __attribute__((weak)) void usbh_audio_stop(struct usbh_audio *audio_class) { } ucd_t rt_usbh_class_driver_audio(void) { usbh_audio_class.class_code = USB_CLASS_AUDIO; usbh_audio_class.enable = rt_usbh_class_driver_audio_enable; usbh_audio_class.disable = rt_usbh_class_driver_audio_disable; return &usbh_audio_class; } #endif