1235 lines
45 KiB
C
1235 lines
45 KiB
C
/*
|
||
* Copyright (c) 2022, sakumisu
|
||
*
|
||
* SPDX-License-Identifier: Apache-2.0
|
||
*/
|
||
#include "rtthread.h"
|
||
|
||
#ifdef RT_USBH_UVC
|
||
|
||
#include "basic_include.h"
|
||
#include "rttusb_host.h"
|
||
#include "usbh_video.h"
|
||
#include "dev/usb/hgusb20_v1_dev_api.h"
|
||
#include "dev/usb/usb11_v0/hgusb11_v0_host_api.h"
|
||
|
||
#include "lib/multimedia/msi.h"
|
||
#include "video_app_usb_msi.h"
|
||
#include "video/uvc/rtt_uvc_host.h"
|
||
#include "sysevt_usb/sysevt_usb.h"
|
||
#ifdef RT_USBH_UAC
|
||
#include "usbh_audio.h"
|
||
#endif
|
||
|
||
#define DEV_FORMAT "/dev/video%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 */
|
||
#define DESC_bNumFormats 3 /** Descriptor numformat offset */
|
||
#define DESC_bNumFrameDescriptors 4 /** Descriptor numframe offset */
|
||
#define DESC_bFormatIndex 3 /** Descriptor format index offset */
|
||
#define DESC_bFrameIndex 3 /** Descriptor frame index offset */
|
||
|
||
/* interface descriptor field offsets */
|
||
#define INTF_DESC_bInterfaceNumber 2 /** Interface number offset */
|
||
#define INTF_DESC_bAlternateSetting 3 /** Alternate setting offset */
|
||
#define INTF_DESC_bInterfaceClass 5
|
||
|
||
#define VIDEO_FREE_PIPE 0
|
||
#define VIDEO_ALLOC_PIPE 1
|
||
|
||
#define CONFIG_USBHOST_MAX_VIDEO_CLASS 2
|
||
|
||
#define VIDEO_SET_INTF_ALTSETTING 1 //设置需要配置的AltSetting，默认为1 (根据打印，选择所需的Altersetting)
|
||
|
||
static struct uclass_driver usbh_video_class;
|
||
|
||
static rt_uint8_t g_video_buf[128];
|
||
|
||
static const char *format_type[] = { "uncompressed", "mjpeg", "based" };
|
||
|
||
struct usbh_video g_video_class[CONFIG_USBHOST_MAX_VIDEO_CLASS];
|
||
static rt_uint32_t g_devinuse = 0;
|
||
|
||
extern volatile uint32 rx_packet_len;
|
||
extern volatile uint32 rx_packet_len_2;
|
||
int usb_dma_h264_irq_times = 0;
|
||
int usb_dma_mjpeg_irq_times = 0;
|
||
|
||
static struct usbh_video *usbh_video_class_alloc(void)
|
||
{
|
||
int devno;
|
||
|
||
for (devno = 0; devno < CONFIG_USBHOST_MAX_VIDEO_CLASS; devno++) {
|
||
if ((g_devinuse & (1 << devno)) == 0) {
|
||
g_devinuse |= (1 << devno);
|
||
memset(&g_video_class[devno], 0, sizeof(struct usbh_video));
|
||
g_video_class[devno].minor = devno;
|
||
return &g_video_class[devno];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
static void usbh_video_class_free(struct usbh_video *video_class)
|
||
{
|
||
int devno = video_class->minor;
|
||
|
||
if (devno >= 0 && devno < 32) {
|
||
g_devinuse &= ~(1 << devno);
|
||
}
|
||
memset(video_class, 0, sizeof(struct usbh_video));
|
||
}
|
||
|
||
int usbh_video_get(struct usbh_video *video_class, rt_uint8_t request, rt_uint8_t intf, rt_uint8_t entity_id, rt_uint8_t cs, rt_uint8_t *buf, rt_uint16_t len)
|
||
{
|
||
struct urequest setup;
|
||
rt_uint8_t retry;
|
||
int timeout = USB_TIMEOUT_BASIC;
|
||
|
||
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE;
|
||
setup.bRequest = request;
|
||
setup.wValue = cs << 8;
|
||
setup.wIndex = (entity_id << 8) | intf;
|
||
setup.wLength = len;
|
||
|
||
retry = 0;
|
||
while (1) {
|
||
|
||
if(rt_usb_hcd_setup_xfer(video_class->device->hcd, video_class->device->pipe_ep0_out, &setup, timeout) == 8)
|
||
{
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_in, g_video_buf, len, timeout) > 0)
|
||
{
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_out, RT_NULL, 0, timeout) == 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
retry++;
|
||
|
||
if (retry == 3) {
|
||
return RT_ERROR;
|
||
}
|
||
}
|
||
|
||
os_sleep_ms(5);
|
||
|
||
if (buf) {
|
||
memcpy(buf, g_video_buf, len);
|
||
}
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
int usbh_video_set(struct usbh_video *video_class, rt_uint8_t request, rt_uint8_t intf, rt_uint8_t entity_id, rt_uint8_t cs, rt_uint8_t *buf, rt_uint16_t len)
|
||
{
|
||
struct urequest setup;
|
||
int timeout = USB_TIMEOUT_BASIC;
|
||
|
||
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE;
|
||
setup.bRequest = request;
|
||
setup.wValue = cs << 8;
|
||
setup.wIndex = (entity_id << 8) | intf;
|
||
setup.wLength = len;
|
||
|
||
memcpy(g_video_buf, buf, len);
|
||
|
||
if(rt_usb_hcd_setup_xfer(video_class->device->hcd, video_class->device->pipe_ep0_out, &setup, timeout) != 8)
|
||
{
|
||
return RT_ERROR;
|
||
}
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_out, g_video_buf, len, timeout) != len)
|
||
{
|
||
return RT_ERROR;
|
||
}
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0)
|
||
{
|
||
return RT_ERROR;
|
||
}
|
||
|
||
os_sleep_ms(50);
|
||
return RT_EOK;
|
||
}
|
||
|
||
int usbh_videostreaming_get_cur_probe(struct usbh_video *video_class)
|
||
{
|
||
return usbh_video_get(video_class, VIDEO_REQUEST_GET_CUR, video_class->data_intf, 0x00, VIDEO_VS_PROBE_CONTROL, (rt_uint8_t *)&video_class->probe, 26);
|
||
}
|
||
|
||
int usbh_videostreaming_set_cur_probe(struct usbh_video *video_class, rt_uint8_t formatindex, rt_uint8_t frameindex, rt_uint32_t dwDefaultFrameInterval)
|
||
{
|
||
video_class->probe.bFormatIndex = formatindex;
|
||
video_class->probe.bFrameIndex = frameindex;
|
||
video_class->probe.dwMaxPayloadTransferSize = 0;
|
||
video_class->probe.dwFrameInterval = dwDefaultFrameInterval;
|
||
os_printf("%s set probe interval:%x\n",__FUNCTION__,dwDefaultFrameInterval);
|
||
return usbh_video_set(video_class, VIDEO_REQUEST_SET_CUR, video_class->data_intf, 0x00, VIDEO_VS_PROBE_CONTROL, (rt_uint8_t *)&video_class->probe, 26);
|
||
}
|
||
|
||
int usbh_videostreaming_set_cur_commit(struct usbh_video *video_class, rt_uint8_t formatindex, rt_uint8_t frameindex, rt_uint32_t dwDefaultFrameInterval)
|
||
{
|
||
memcpy(&video_class->commit, &video_class->probe, sizeof(struct video_probe_and_commit_controls));
|
||
video_class->commit.bFormatIndex = formatindex;
|
||
video_class->commit.bFrameIndex = frameindex;
|
||
video_class->commit.dwFrameInterval = dwDefaultFrameInterval;
|
||
os_printf("%s set commit interval:%x\n",__FUNCTION__,dwDefaultFrameInterval);
|
||
return usbh_video_set(video_class, VIDEO_REQUEST_SET_CUR, video_class->data_intf, 0x00, VIDEO_VS_COMMIT_CONTROL, (rt_uint8_t *)&video_class->commit, 26);
|
||
}
|
||
|
||
int usbh_video_open(struct usbh_video *video_class,
|
||
rt_uint8_t format_type,
|
||
rt_uint16_t wWidth,
|
||
rt_uint16_t wHeight,
|
||
rt_uint8_t altsetting)
|
||
{
|
||
struct urequest setup;
|
||
struct uendpoint_descriptor *ep_desc;
|
||
rt_uint8_t mult;
|
||
rt_uint16_t mps;
|
||
int ret;
|
||
bool found = false;
|
||
rt_uint8_t formatidx = 0;
|
||
rt_uint8_t frameidx = 0;
|
||
rt_uint8_t step;
|
||
int timeout = USB_TIMEOUT_BASIC;
|
||
rt_uint8_t set_altsetting = altsetting;
|
||
|
||
// if (video_class->is_opened) {
|
||
// return 0;
|
||
// }
|
||
|
||
for (rt_uint8_t i = 0; i < video_class->num_of_formats; i++) {
|
||
if (format_type == video_class->format[i].format_type) {
|
||
formatidx = i + 1;
|
||
for (rt_uint8_t j = 0; j < video_class->format[i].num_of_frames; j++) {
|
||
if ((wWidth == video_class->format[i].frame[j].wWidth) &&
|
||
(wHeight == video_class->format[i].frame[j].wHeight)) {
|
||
frameidx = j + 1;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (found == false) {
|
||
os_printf("No found %d x %d resolution!!!!!!!!!!!!!\n",wWidth,wHeight);
|
||
return RET_ERR;
|
||
}
|
||
|
||
if (altsetting >= (video_class->num_of_intf_altsettings)) {
|
||
set_altsetting = video_class->cur_set_altersetting_num;
|
||
os_printf("[altsetting error]VIDEO_SET_INTF_ALTSETTING:%d cur_set:%d\n",VIDEO_SET_INTF_ALTSETTING,set_altsetting);
|
||
}
|
||
|
||
/* Open video step:
|
||
* Get CUR request (probe)
|
||
* Set CUR request (probe)
|
||
* Get CUR request (probe)
|
||
* Get MAX request (probe)
|
||
* Get MIN request (probe)
|
||
* Get CUR request (probe)
|
||
* Set CUR request (commit)
|
||
*
|
||
*/
|
||
os_printf("%s :set %d x %d resolution\n",__FUNCTION__,wWidth,wHeight);
|
||
os_printf("Formatidx:%d Frameidx:%d\n",formatidx,frameidx);
|
||
|
||
step = 0;
|
||
ret = usbh_videostreaming_get_cur_probe(video_class);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 1;
|
||
ret = usbh_videostreaming_set_cur_probe(video_class, formatidx, frameidx, video_class->format[formatidx-1].frame[frameidx-1].dwDefaultFrameInterval);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 2;
|
||
ret = usbh_videostreaming_get_cur_probe(video_class);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 3;
|
||
ret = usbh_video_get(video_class, VIDEO_REQUEST_GET_MAX, video_class->data_intf, 0x00, VIDEO_VS_PROBE_CONTROL, NULL, 26);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 4;
|
||
ret = usbh_video_get(video_class, VIDEO_REQUEST_GET_MIN, video_class->data_intf, 0x00, VIDEO_VS_PROBE_CONTROL, NULL, 26);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 5;
|
||
ret = usbh_videostreaming_set_cur_probe(video_class, formatidx, frameidx, video_class->format[formatidx-1].frame[frameidx-1].dwDefaultFrameInterval);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 6;
|
||
ret = usbh_videostreaming_get_cur_probe(video_class);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
step = 7;
|
||
ret = usbh_videostreaming_set_cur_commit(video_class, formatidx, frameidx, video_class->format[formatidx-1].frame[frameidx-1].dwDefaultFrameInterval);
|
||
if (ret < 0) {
|
||
goto errout;
|
||
}
|
||
|
||
if((video_class->pipe_in->ep.bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_ISOC)
|
||
{
|
||
os_printf("ISO set interface altsetting: %u\r\n",set_altsetting);
|
||
step = 8;
|
||
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_INTERFACE;
|
||
setup.bRequest = USB_REQ_SET_INTERFACE;
|
||
setup.wValue = set_altsetting;
|
||
setup.wIndex = video_class->data_intf;
|
||
setup.wLength = 0;
|
||
|
||
if(rt_usb_hcd_setup_xfer(video_class->device->hcd, video_class->device->pipe_ep0_out, &setup, timeout) != 8)
|
||
{
|
||
goto errout;
|
||
}
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0)
|
||
{
|
||
goto errout;
|
||
}
|
||
}
|
||
|
||
ep_desc = &video_class->isoin;
|
||
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) {
|
||
video_class->isoin_mps = mps * (mult + 1);
|
||
} else {
|
||
video_class->isoout_mps = mps * (mult + 1);
|
||
}
|
||
|
||
os_printf("Open video and select formatidx:%u, frameidx:%u, altsetting:%u\r\n", formatidx, frameidx, set_altsetting);
|
||
video_class->is_opened = TRUE;
|
||
video_class->current_format = format_type;
|
||
return ret;
|
||
|
||
errout:
|
||
os_printf("Fail to open video in step %u\r\n", step);
|
||
return ret;
|
||
}
|
||
|
||
int usbh_video_close(uinst_t device, struct usbh_video *video_class)
|
||
{
|
||
struct urequest setup;
|
||
struct uendpoint_descriptor *ep_desc = RT_NULL;
|
||
int timeout = USB_TIMEOUT_BASIC;
|
||
|
||
os_printf("Close video device\r\n");
|
||
|
||
video_class->is_opened = FALSE;
|
||
|
||
ep_desc = &video_class->isoin;
|
||
|
||
if((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_ISOC)
|
||
{
|
||
os_printf("ISO set interface 0\r\n");
|
||
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 = video_class->data_intf;
|
||
setup.wLength = 0;
|
||
|
||
if(rt_usb_hcd_setup_xfer(device->hcd, device->pipe_ep0_out, &setup, timeout) != 8)
|
||
{
|
||
return RT_ERROR;
|
||
}
|
||
if(rt_usb_hcd_pipe_xfer(video_class->device->hcd, video_class->device->pipe_ep0_in, RT_NULL, 0, timeout) != 0)
|
||
{
|
||
return RT_ERROR;
|
||
}
|
||
}
|
||
|
||
if((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_BULK)
|
||
{
|
||
os_printf("BULK clear ep feature: 0x%x\n",(ep_desc->bEndpointAddress));
|
||
rt_usbh_clear_feature(device, ep_desc->bEndpointAddress, 0);
|
||
}
|
||
|
||
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
void usbh_video_list_info(struct usbh_video *video_class)
|
||
{
|
||
|
||
|
||
os_printf("============= Video device information ===================\r\n");
|
||
os_printf("bcdVDC:%04x\r\n", video_class->bcdVDC);
|
||
os_printf("Num of altsettings:%u\r\n", video_class->num_of_intf_altsettings);
|
||
for (rt_uint8_t i = 0; i < video_class->num_of_intf_altsettings; i++) {
|
||
if (video_class->intf_altersetting[i].check_use == 0)
|
||
continue;
|
||
uep_desc_t ep_desc = video_class->intf_altersetting[i].ep_desc_t;
|
||
os_printf(" Altsetting:%u, Ep=%02x Attr=%02u Mps=%d Interval=%02u\r\n",
|
||
i,
|
||
ep_desc->bEndpointAddress,
|
||
ep_desc->bmAttributes,
|
||
ep_desc->wMaxPacketSize,
|
||
ep_desc->bInterval);
|
||
}
|
||
os_printf("\r\n");
|
||
os_printf("bNumFormats:%u\r\n", video_class->num_of_formats);
|
||
for (rt_uint8_t i = 0; i < video_class->num_of_formats; i++) {
|
||
os_printf("\r\n");
|
||
os_printf(" FormatIndex:%u\r\n", i + 1);
|
||
os_printf(" FormatType:%s\r\n", format_type[video_class->format[i].format_type]);
|
||
os_printf(" bNumFrames:%u\r\n", video_class->format[i].num_of_frames);
|
||
os_printf(" Resolution:\r\n");
|
||
for (rt_uint8_t j = 0; j < video_class->format[i].num_of_frames; j++) {
|
||
os_printf(" FrameIndex:%u\r\n", j + 1);
|
||
os_printf(" wWidth: %d, wHeight: %d (%d Fps)\r\n",
|
||
video_class->format[i].frame[j].wWidth,
|
||
video_class->format[i].frame[j].wHeight,
|
||
(video_class->format[i].frame[j].dwDefaultFrameInterval ? (10000000/video_class->format[i].frame[j].dwDefaultFrameInterval) : 0));
|
||
}
|
||
}
|
||
|
||
os_printf("============= Video device information ===================\r\n");
|
||
}
|
||
|
||
static void usbh_video_intf_altersetting_ep_config(struct usbh_video *video_class)
|
||
{
|
||
uep_desc_t ep_desc = NULL;
|
||
|
||
if (video_class->intf_altersetting[VIDEO_SET_INTF_ALTSETTING].check_use)
|
||
{
|
||
ep_desc = video_class->intf_altersetting[VIDEO_SET_INTF_ALTSETTING].ep_desc_t;
|
||
video_class->cur_set_altersetting_num = VIDEO_SET_INTF_ALTSETTING;
|
||
goto __exit_end;
|
||
}
|
||
|
||
if(VIDEO_SET_INTF_ALTSETTING > (video_class->num_of_intf_altsettings - 1))
|
||
{
|
||
for(rt_uint8_t i = 0; i < video_class->num_of_intf_altsettings; i++)
|
||
{
|
||
if (video_class->intf_altersetting[i].check_use == 0)
|
||
{
|
||
if (i == video_class->num_of_intf_altsettings-1)
|
||
{
|
||
//正常情况不会进入该条件
|
||
os_printf("No found altersetting ep!!!!!!\n");
|
||
}
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
ep_desc = video_class->intf_altersetting[i].ep_desc_t;
|
||
video_class->cur_set_altersetting_num = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
__exit_end:
|
||
if(((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN ) &&
|
||
((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_ISOC))
|
||
{
|
||
video_class->isoin = *ep_desc;
|
||
video_class->video_rx_size = ep_desc->wMaxPacketSize;
|
||
|
||
video_class->uvc_head = 0;
|
||
}
|
||
|
||
if(((ep_desc->bEndpointAddress & USB_DIR_MASK) == USB_DIR_IN ) &&
|
||
((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) == USB_EP_ATTR_BULK))
|
||
{
|
||
video_class->isoin = *ep_desc;
|
||
video_class->video_rx_size = ep_desc->wMaxPacketSize;
|
||
|
||
video_class->uvc_head = 12+4; //BULK HEAD
|
||
}
|
||
|
||
}
|
||
|
||
static rt_err_t rt_usbh_class_driver_video_enable(void *arg)
|
||
{
|
||
int ret;
|
||
struct uhintf **p_intf = arg;
|
||
rt_uint8_t cur_iface = 0xff;
|
||
rt_uint8_t cur_alt_setting = 0xff;
|
||
rt_uint8_t cur_class = 0xff;
|
||
rt_uint8_t frame_index = 0xff;
|
||
rt_uint8_t format_index = 0xff;
|
||
rt_uint8_t num_of_frames = 0xff;
|
||
rt_uint8_t *p;
|
||
rt_uint8_t intf;
|
||
uhcd_t hcd = NULL;
|
||
rt_int32_t cfg_len = 0;
|
||
|
||
if (p_intf[0] == NULL) {
|
||
return -EIO;
|
||
}
|
||
|
||
hcd = p_intf[0]->device->hcd;
|
||
os_printf("subclass %d, protocal %d intfnum:%d\r\n",p_intf[0]->intf_desc->bInterfaceSubClass,p_intf[0]->intf_desc->bInterfaceProtocol, p_intf[0]->intf_desc->bInterfaceNumber);
|
||
os_printf("device:%x cfg_desc:%x hcd:%x\n",(uinst_t)p_intf[0]->device,p_intf[0]->device->cfg_desc,p_intf[0]->device->hcd);
|
||
|
||
struct usbh_video *video_class = usbh_video_class_alloc();
|
||
if (video_class == NULL) {
|
||
os_printf("Fail to alloc video_class\r\n");
|
||
return RT_ENOMEM;
|
||
}
|
||
|
||
intf = p_intf[0]->intf_desc->bInterfaceNumber;
|
||
|
||
video_class->device = p_intf[0]->device;
|
||
video_class->ctrl_intf = intf;
|
||
video_class->data_intf = intf + 1;
|
||
video_class->num_of_intf_altsettings = 2;
|
||
video_class->video_rx_size = 1024;
|
||
|
||
p_intf[0]->user_data = video_class;
|
||
os_printf("p_intf[0]:%x\n",p_intf[0]);
|
||
|
||
p = (rt_uint8_t *)p_intf[0]->device->cfg_desc;
|
||
cfg_len = p_intf[0]->device->cfg_desc->wTotalLength;
|
||
os_printf("cfg_len:%x\n",cfg_len);
|
||
|
||
while (p[DESC_bLength]) {
|
||
switch (p[DESC_bDescriptorType]) {
|
||
case USB_DESC_TYPE_INTERFACE:
|
||
//os_printf("USB_DESC_TYPE_INTERFACE :%d\n",p[DESC_bDescriptorType]);
|
||
cur_iface = p[INTF_DESC_bInterfaceNumber];
|
||
cur_alt_setting = p[INTF_DESC_bAlternateSetting];
|
||
cur_class = p[INTF_DESC_bInterfaceClass];
|
||
if (cur_iface == video_class->data_intf){
|
||
video_class->num_of_intf_altsettings = cur_alt_setting + 1;
|
||
}
|
||
break;
|
||
case USB_DESC_TYPE_ENDPOINT:
|
||
//os_printf("USB_DESC_TYPE_ENDPOINT\n");
|
||
if ((cur_iface == video_class->data_intf) && (cur_class == USB_CLASS_VIDEO))
|
||
{
|
||
video_class->intf_altersetting[cur_alt_setting].ep_desc_t = (uep_desc_t)p;
|
||
video_class->intf_altersetting[cur_alt_setting].altersetting_num = cur_alt_setting;
|
||
video_class->intf_altersetting[cur_alt_setting].check_use = 1;
|
||
}
|
||
break;
|
||
case VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE:
|
||
if (cur_iface == video_class->ctrl_intf) {
|
||
//os_printf("VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE 1 cur_iface:%d p[DESC_bDescriptorSubType]:0x%x\n",cur_iface,p[DESC_bDescriptorSubType]);
|
||
switch (p[DESC_bDescriptorSubType]) {
|
||
case VIDEO_VC_HEADER_DESCRIPTOR_SUBTYPE:
|
||
video_class->bcdVDC = ((rt_uint16_t)p[4] << 8) | (rt_uint16_t)p[3];
|
||
break;
|
||
case VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE:
|
||
break;
|
||
case VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE:
|
||
break;
|
||
case VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE:
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
} else if (cur_iface == video_class->data_intf) {
|
||
//os_printf("VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE 2, cur_inface:%d p[DESC_bDescriptorSubType]:0x%x\n",cur_iface,p[DESC_bDescriptorSubType]);
|
||
switch (p[DESC_bDescriptorSubType]) {
|
||
case VIDEO_VS_INPUT_HEADER_DESCRIPTOR_SUBTYPE:
|
||
video_class->num_of_formats = p[DESC_bNumFormats];
|
||
if(video_class->num_of_formats > USBH_VIDEO_MAX_FORMAT_NUM) {
|
||
os_printf("The value of USBH_VIDEO_MAX_FORMAT_NUM needs to be increased,USBH_VIDEO_MAX_FORMAT_NUM:%d video_class->num_of_formats:%d\n",
|
||
USBH_VIDEO_MAX_FORMAT_NUM, video_class->num_of_formats);
|
||
}
|
||
break;
|
||
case VIDEO_VS_FORMAT_UNCOMPRESSED_DESCRIPTOR_SUBTYPE:
|
||
format_index = p[DESC_bFormatIndex];
|
||
num_of_frames = p[DESC_bNumFrameDescriptors];
|
||
if (num_of_frames > USBH_VIDEO_MAX_FRAME_NUM) {
|
||
os_printf("The value of USBH_VIDEO_MAX_FRAME_NUM needs to be increased,USBH_VIDEO_MAX_FRAME_NUM:%d num_of_frames:%d\n",
|
||
USBH_VIDEO_MAX_FRAME_NUM, num_of_frames);
|
||
}
|
||
|
||
video_class->format[format_index - 1].num_of_frames = num_of_frames;
|
||
video_class->format[format_index - 1].format_type = USBH_VIDEO_FORMAT_UNCOMPRESSED;
|
||
break;
|
||
case VIDEO_VS_FORMAT_MJPEG_DESCRIPTOR_SUBTYPE:
|
||
format_index = p[DESC_bFormatIndex];
|
||
num_of_frames = p[DESC_bNumFrameDescriptors];
|
||
if (num_of_frames > USBH_VIDEO_MAX_FRAME_NUM) {
|
||
os_printf("The value of USBH_VIDEO_MAX_FRAME_NUM needs to be increased,USBH_VIDEO_MAX_FRAME_NUM:%d num_of_frames:%d\n",
|
||
USBH_VIDEO_MAX_FRAME_NUM, num_of_frames);
|
||
}
|
||
|
||
video_class->format[format_index - 1].num_of_frames = num_of_frames;
|
||
video_class->format[format_index - 1].format_type = USBH_VIDEO_FORMAT_MJPEG;
|
||
break;
|
||
case VIDEO_VS_FORMAT_FRAME_BASED_DESCRIPTOR_SUBTYPE:
|
||
format_index = p[DESC_bFormatIndex];
|
||
num_of_frames = p[DESC_bNumFrameDescriptors];
|
||
if (num_of_frames > USBH_VIDEO_MAX_FRAME_NUM) {
|
||
os_printf("The value of USBH_VIDEO_MAX_FRAME_NUM needs to be increased,USBH_VIDEO_MAX_FRAME_NUM:%d num_of_frames:%d\n",
|
||
USBH_VIDEO_MAX_FRAME_NUM, num_of_frames);
|
||
}
|
||
|
||
video_class->format[format_index - 1].num_of_frames = num_of_frames;
|
||
video_class->format[format_index - 1].format_type = USBH_VIDEO_FORMAT_BASED;
|
||
break;
|
||
case VIDEO_VS_FRAME_UNCOMPRESSED_DESCRIPTOR_SUBTYPE:
|
||
frame_index = p[DESC_bFrameIndex];
|
||
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wWidth = ((struct video_cs_if_vs_frame_uncompressed_descriptor *)p)->wWidth;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wHeight = ((struct video_cs_if_vs_frame_uncompressed_descriptor *)p)->wHeight;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].dwDefaultFrameInterval = ((struct video_cs_if_vs_frame_uncompressed_descriptor *)p)->dwDefaultFrameInterval;
|
||
break;
|
||
case VIDEO_VS_FRAME_MJPEG_DESCRIPTOR_SUBTYPE:
|
||
frame_index = p[DESC_bFrameIndex];
|
||
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wWidth = ((struct video_cs_if_vs_frame_mjpeg_descriptor *)p)->wWidth;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wHeight = ((struct video_cs_if_vs_frame_mjpeg_descriptor *)p)->wHeight;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].dwDefaultFrameInterval = ((struct video_cs_if_vs_frame_mjpeg_descriptor *)p)->dwDefaultFrameInterval;
|
||
break;
|
||
case VIDEO_VS_FRAME_FRAME_BASED_DESCRIPTOR_SUBTYPE:
|
||
frame_index = p[DESC_bFrameIndex];
|
||
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wWidth = ((struct video_cs_if_vs_frame_h26x_descriptor *)p)->wWidth;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].wHeight = ((struct video_cs_if_vs_frame_h26x_descriptor *)p)->wHeight;
|
||
video_class->format[format_index - 1].frame[frame_index - 1].dwDefaultFrameInterval = ((struct video_cs_if_vs_frame_h26x_descriptor *)p)->dwDefaultFrameInterval;
|
||
break;
|
||
|
||
default:
|
||
os_printf("VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE default %X\n",p[DESC_bDescriptorSubType]);
|
||
break;
|
||
}
|
||
}else{
|
||
//os_printf("cur_iface:%d default:0x%x\n",cur_iface,p[DESC_bDescriptorSubType]);
|
||
}
|
||
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
/* skip to next descriptor */
|
||
if (cfg_len > 0) {
|
||
cfg_len -= p[DESC_bLength];
|
||
}
|
||
//os_printf("cfg_len:%d\n",cfg_len);
|
||
if (cfg_len <= 0) {
|
||
break;
|
||
}
|
||
p += p[DESC_bLength];
|
||
}
|
||
|
||
usbh_video_list_info(video_class);
|
||
|
||
if (cfg_len != 0) {
|
||
os_printf("UVC cfg_desc analysis failed\n");
|
||
return RT_ERROR;
|
||
}
|
||
|
||
usbh_video_intf_altersetting_ep_config(video_class);
|
||
|
||
video_class->rx_buff = (rt_uint8_t *)rt_malloc(video_class->video_rx_size + video_class->uvc_head + USB_RX_BUFF_RESERVE_SIZE);
|
||
if(video_class->rx_buff == RT_NULL) {
|
||
os_printf("malloc rx_buff fail!!!!!!!!!!!\n");
|
||
return RT_ENOMEM;
|
||
}
|
||
os_printf("video_class->rx_buff:%x video_class->uvc_head:%d\n",video_class->rx_buff,video_class->uvc_head);
|
||
|
||
#if USBH_VIDEO_PPB
|
||
video_class->usbh_pingpang_flag = 0;
|
||
video_class->rx_double_buff = (rt_uint8_t *)rt_malloc(video_class->video_rx_size + video_class->uvc_head + USB_RX_BUFF_RESERVE_SIZE);
|
||
if(video_class->rx_double_buff == RT_NULL) {
|
||
rt_free(video_class->rx_buff);
|
||
video_class->rx_buff = RT_NULL;
|
||
os_printf("malloc rx_double_buff fail!!!!!!!!!\n");
|
||
return RT_ENOMEM;
|
||
}
|
||
|
||
os_printf("video_class->rx_double_buff:%x video_class->uvc_head:%d\n",video_class->rx_double_buff,video_class->uvc_head);
|
||
#endif
|
||
|
||
ret = usbh_video_close(p_intf[0]->device,video_class);
|
||
if (ret == RT_ERROR) {
|
||
os_printf("Fail to close video device\r\n");
|
||
return ret;
|
||
}
|
||
|
||
snprintf(video_class->devname, CONFIG_USBHOST_DEV_NAMELEN, DEV_FORMAT, video_class->minor);
|
||
|
||
os_printf("Register Video Class:%s\r\n", video_class->devname);
|
||
os_printf("video_class device:%x hcd:%x\n",video_class->device,video_class->device->hcd);
|
||
usbh_video_run(video_class);
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
static rt_err_t rt_usbh_class_driver_video_disable(void *arg)
|
||
{
|
||
struct uhintf *p_intf = arg;
|
||
struct usbh_video *video_class;
|
||
|
||
if (p_intf == NULL) {
|
||
return -EIO;
|
||
}
|
||
os_printf("%s %d p_intf:%x\n",__FUNCTION__,__LINE__,p_intf);
|
||
video_class = (struct usbh_video *)p_intf->user_data;
|
||
|
||
if (video_class) {
|
||
if (video_class->pipe_in != RT_NULL) {
|
||
}
|
||
|
||
if (video_class->pipe_out != RT_NULL) {
|
||
}
|
||
|
||
if (video_class->devname[0] != '\0') {
|
||
os_printf("Unregister Video Class:%s\r\n", video_class->devname);
|
||
rtt_usbh_video_user_close(video_class->minor);
|
||
usbh_video_stop(video_class);
|
||
}
|
||
|
||
if (video_class->rx_buff != RT_NULL) {
|
||
rt_free(video_class->rx_buff);
|
||
video_class->rx_buff = RT_NULL;
|
||
}
|
||
|
||
#if USBH_VIDEO_PPB
|
||
if (video_class->rx_double_buff != RT_NULL) {
|
||
rt_free(video_class->rx_double_buff);
|
||
video_class->rx_double_buff = RT_NULL;
|
||
}
|
||
#endif
|
||
|
||
usbh_video_class_free(video_class);
|
||
}
|
||
|
||
return RT_EOK;
|
||
|
||
}
|
||
|
||
static rt_uint32_t rt_usbh_video_class_ep_search_devnum(rt_uint8_t ep, uhcd_t hcd)
|
||
{
|
||
rt_uint32_t dev_num = 0xFF;
|
||
|
||
for (int i = 0; i < CONFIG_USBHOST_MAX_VIDEO_CLASS; i++) {
|
||
if ( (ep == g_video_class[i].pipe_in->pipe_index) &&
|
||
(g_video_class[i].pipe_in != RT_NULL) &&
|
||
(g_video_class[i].device->hcd == hcd) )
|
||
{
|
||
if ((g_devinuse & (1 << i)) == 0) {
|
||
break;
|
||
}
|
||
|
||
dev_num = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return dev_num;
|
||
}
|
||
|
||
/* ----------------------------- USB 2.0 / USB 1.1 UVC IRQ ----------------------------- */
|
||
|
||
bool rtt_uvc_data_deal(void *p_dev, rt_uint8_t ep, rt_uint32_t *rx_dma_len)
|
||
{
|
||
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){
|
||
return 1;
|
||
}
|
||
|
||
if(rx_len < 0){
|
||
os_printf("The length of the configured dma needs to be increased\n");
|
||
return 1;
|
||
}
|
||
|
||
*rx_dma_len = rx_len;
|
||
// printf("rx len:%d\n",rx_packet_len);
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
void rtt_usbh_video_irq(void * p_dev, rt_uint8_t ep, uhcd_t hcd)
|
||
{
|
||
rt_uint32_t ret;
|
||
rt_uint32_t dev_num;
|
||
rt_uint32_t rx_packet_len = 0;
|
||
struct usb_device_dma_cfg dma_cfg;
|
||
|
||
if (!p_dev)
|
||
return;
|
||
|
||
dev_num = rt_usbh_video_class_ep_search_devnum(ep, hcd);
|
||
|
||
#if USBH_VIDEO_PPB
|
||
switch(dev_num)
|
||
{
|
||
case 0:
|
||
{
|
||
usb_dma_mjpeg_irq_times++;
|
||
ret = rtt_uvc_data_deal(p_dev, ep, &rx_packet_len);
|
||
|
||
if(g_video_class[dev_num].usbh_pingpang_flag)
|
||
{
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_double_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
g_video_class[dev_num].usbh_pingpang_flag = 0;
|
||
}
|
||
else
|
||
{
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_double_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
g_video_class[dev_num].usbh_pingpang_flag = 1;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 1:
|
||
{
|
||
usb_dma_h264_irq_times++;
|
||
ret = rtt_uvc_data_deal(p_dev, ep, &rx_packet_len);
|
||
|
||
if(g_video_class[dev_num].usbh_pingpang_flag)
|
||
{
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_double_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
g_video_class[dev_num].usbh_pingpang_flag = 0;
|
||
}
|
||
else
|
||
{
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_double_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
g_video_class[dev_num].usbh_pingpang_flag = 1;
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
#else
|
||
switch(dev_num)
|
||
{
|
||
case 0:
|
||
{
|
||
usb_dma_mjpeg_irq_times++;
|
||
ret = rtt_uvc_data_deal(p_dev, ep, &rx_packet_len);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, &dma_cfg, (rt_uint32_t)RT_NULL);
|
||
}
|
||
break;
|
||
|
||
case 1:
|
||
{
|
||
usb_dma_h264_irq_times++;
|
||
ret = rtt_uvc_data_deal(p_dev, ep, &rx_packet_len);
|
||
if(ret == 0) {
|
||
uint8_t drop = 0;
|
||
if(usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_ISO_IS_CRC_ERR, ep, (uint32_t)NULL)) {
|
||
drop = 1;
|
||
}
|
||
process_uvc_payload(dev_num, (g_video_class[dev_num].isoin.bmAttributes & USB_EP_ATTR_TYPE_MASK), g_video_class[dev_num].current_format, (g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head), rx_packet_len, drop);
|
||
}
|
||
dma_cfg.ep_index = ep;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, &dma_cfg, (rt_uint32_t)RT_NULL);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
|
||
rt_uint32_t rtt_usbh_video_dev_pipe_manage(rt_uint8_t dev_num, rt_uint8_t alloc_or_free)
|
||
{
|
||
uep_desc_t ep_desc;
|
||
upipe_t pipe;
|
||
struct usbh_video *video_class = RT_NULL;
|
||
|
||
if(dev_num >= CONFIG_USBHOST_MAX_VIDEO_CLASS)
|
||
{
|
||
os_printf("Invalid dev_num %d!!!!!!!\n",dev_num);
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
video_class = &g_video_class[dev_num];
|
||
|
||
ep_desc = &video_class->isoin;
|
||
|
||
os_printf("Video Class dev%d: Altsetting:%u, Ep=%02x Attr=%02u Mps=%d Interval=%02u\r\n",
|
||
dev_num,
|
||
video_class->cur_set_altersetting_num,
|
||
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(video_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(video_class->device->hcd, &pipe, video_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(video_class->device, pipe);
|
||
|
||
video_class->pipe_in = pipe;
|
||
}
|
||
else
|
||
{
|
||
if(video_class->pipe_in != RT_NULL) {
|
||
rt_list_remove(&video_class->pipe_in->list);
|
||
rt_usb_hcd_free_pipe(video_class->device->hcd, video_class->pipe_in);
|
||
video_class->pipe_in = RT_NULL;
|
||
} else {
|
||
os_printf("g_video_class[%d] pipe_in is NULL, not free\n",dev_num);
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
}
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
|
||
|
||
rt_uint32_t rtt_usbh_video_user_open(rt_uint8_t dev_num)
|
||
{
|
||
rt_uint32_t ret;
|
||
struct usb_device *p_dev = NULL;
|
||
|
||
if ((g_devinuse & (1 << dev_num)) == 0)
|
||
{
|
||
os_printf("video/dev%d is not use!!!\n",dev_num);
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
ret = rtt_usbh_video_dev_pipe_manage(dev_num, VIDEO_ALLOC_PIPE);
|
||
if(ret)
|
||
{
|
||
os_printf("alloc pipe failed!!!!!!!!!!!\n");
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
switch(g_video_class[dev_num].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;
|
||
}
|
||
|
||
switch(dev_num)
|
||
{
|
||
case 0:
|
||
{
|
||
/* 摄像头0 设置需要打开的格式、分辨率 */
|
||
rt_uint8_t video_format = USBH_VIDEO_FORMAT_MJPEG;
|
||
rt_uint32_t width = 640;
|
||
rt_uint32_t height = 480;
|
||
|
||
rt_uint8_t fb_mtype = (video_format == USBH_VIDEO_FORMAT_MJPEG) ? F_JPG : ((video_format == USBH_VIDEO_FORMAT_BASED) ? F_H264 : F_YUV);
|
||
|
||
usbh_video_open((&g_video_class[dev_num]), video_format, width, height, VIDEO_SET_INTF_ALTSETTING);
|
||
system_event_usbh_video_update_info(dev_num, g_video_class[dev_num].devname, video_format, width, height);
|
||
|
||
#ifdef PSRAM_HEAP
|
||
extern struct usbh_video_priv_func uvc_host_stream_1;
|
||
uvc_host_stream_1.dev_num = dev_num;
|
||
uvc_host_stream_1.p_dev = p_dev;
|
||
usbh_video_enum_finish_init(g_video_class[dev_num].devname,(fb_mtype << 8) | (FSTYPE_USB_CAM0),&uvc_host_stream_1,&usb_dma_mjpeg_irq_times);
|
||
#else
|
||
|
||
#endif
|
||
}
|
||
break;
|
||
|
||
case 1:
|
||
{
|
||
/* 摄像头1 设置需要打开的格式、分辨率 */
|
||
rt_uint8_t video_format = USBH_VIDEO_FORMAT_MJPEG;
|
||
rt_uint32_t width = 1280;
|
||
rt_uint32_t height = 720;
|
||
|
||
rt_uint8_t fb_mtype = (video_format == USBH_VIDEO_FORMAT_MJPEG) ? F_JPG : ((video_format == USBH_VIDEO_FORMAT_BASED) ? F_H264 : F_YUV);
|
||
|
||
usbh_video_open((&g_video_class[dev_num]), video_format, width, height, VIDEO_SET_INTF_ALTSETTING);
|
||
system_event_usbh_video_update_info(dev_num, g_video_class[dev_num].devname, video_format, width, height);
|
||
|
||
#ifdef PSRAM_HEAP
|
||
extern struct usbh_video_priv_func uvc_host_stream_2;
|
||
uvc_host_stream_2.dev_num = dev_num;
|
||
uvc_host_stream_2.p_dev = p_dev;
|
||
usbh_video_enum_finish_init(g_video_class[dev_num].devname,(fb_mtype << 8) | (FSTYPE_USB_CAM1),&uvc_host_stream_2,&usb_dma_h264_irq_times);
|
||
#else
|
||
|
||
#endif
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
struct usb_device_dma_cfg dma_cfg;
|
||
dma_cfg.ep_index = g_video_class[dev_num].pipe_in->pipe_index;
|
||
dma_cfg.ep_dir = USB_CORE_HOST_EP_RX;
|
||
dma_cfg.dma_addr = (rt_uint32_t *)(g_video_class[dev_num].rx_buff+g_video_class[dev_num].uvc_head);
|
||
dma_cfg.dma_len = g_video_class[dev_num].video_rx_size;
|
||
usb_device_ioctl((struct usb_device *)p_dev, USB_HOST_KICK_EP_DMA, (rt_uint32_t)&dma_cfg, (rt_uint32_t)RT_NULL);
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
rt_uint32_t rtt_usbh_video_user_close(rt_uint8_t dev_num)
|
||
{
|
||
rt_uint32_t ret;
|
||
|
||
if ((g_devinuse & (1 << dev_num)) == 0)
|
||
{
|
||
os_printf("video/dev%d is not use!!!\n",dev_num);
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
|
||
ret = rtt_usbh_video_dev_pipe_manage(dev_num, VIDEO_FREE_PIPE);
|
||
if(ret)
|
||
{
|
||
os_printf("free pipe failed!!!!!!!!!!!\n");
|
||
return -RT_ERROR;
|
||
}
|
||
|
||
switch(dev_num)
|
||
{
|
||
case 0:
|
||
#ifdef PSRAM_HEAP
|
||
|
||
#else
|
||
|
||
#endif
|
||
break;
|
||
|
||
case 1:
|
||
#ifdef PSRAM_HEAP
|
||
|
||
#else
|
||
|
||
#endif
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
usbh_video_close((&g_video_class[dev_num])->device,&g_video_class[dev_num]);
|
||
|
||
return RT_EOK;
|
||
}
|
||
|
||
int32 demo_atcmd_select_resolution(const char *cmd, char *argv[], uint32 argc)
|
||
{
|
||
//摄像头0，不带UAC
|
||
if (*argv[0] == '1') {
|
||
//打开摄像头0
|
||
if (*argv[1] == '1') {
|
||
rtt_usbh_video_user_open(0);
|
||
}
|
||
//关闭摄像头0
|
||
if (*argv[1] == '0') {
|
||
rtt_usbh_video_user_close(0);
|
||
}
|
||
}
|
||
//摄像头1，带UAC
|
||
else if (*argv[0] == '2') {
|
||
//打开摄像头1
|
||
if (*argv[1] == '1') {
|
||
rtt_usbh_video_user_open(1);
|
||
#ifdef RT_USBH_UAC
|
||
rtt_usbh_audio_user_open(); //先打开视频流，再打开音频流
|
||
#endif
|
||
}
|
||
//关闭摄像头1
|
||
if (*argv[1] == '0') {
|
||
#ifdef RT_USBH_UAC
|
||
rtt_usbh_audio_user_close(); //先关闭音频流，再关闭视频流
|
||
#endif
|
||
rtt_usbh_video_user_close(1);
|
||
}
|
||
}
|
||
|
||
printf("OK/n");
|
||
return 0;
|
||
}
|
||
|
||
|
||
void usbh_video_thread_entry(void *arg)
|
||
{
|
||
//struct usbh_video *video_class = arg;
|
||
|
||
}
|
||
|
||
__attribute__((weak)) void usbh_video_run(struct usbh_video *video_class)
|
||
{
|
||
|
||
switch (video_class->minor)
|
||
{
|
||
case 0:
|
||
os_printf("usbh_video_run video dev 0\n");
|
||
rtt_usbh_video_user_open(0); // 默认摄像头1为 MJPEG格式 640 x 480
|
||
break;
|
||
|
||
|
||
case 1:
|
||
os_printf("usbh_video_run video dev 1\n");
|
||
rtt_usbh_video_user_open(1); // 默认摄像头2为 H264格式 1280 x 720
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
|
||
#if 0
|
||
rt_thread_t usbh_video_thread;
|
||
usbh_video_thread = rt_thread_create("usbh_video_thread",
|
||
usbh_video_thread_entry,
|
||
video_class,
|
||
1024,
|
||
OS_TASK_PRIORITY_NORMAL,
|
||
20);
|
||
|
||
if(usbh_video_thread != RT_NULL)
|
||
rt_thread_startup(usbh_video_thread);
|
||
#endif
|
||
|
||
}
|
||
|
||
__attribute__((weak)) void usbh_video_stop(struct usbh_video *video_class)
|
||
{
|
||
switch (video_class->minor)
|
||
{
|
||
case 0:
|
||
os_printf("usbh_video_stop video dev 0\n");
|
||
break;
|
||
|
||
case 1:
|
||
os_printf("usbh_video_stop video dev 1\n");
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
ucd_t rt_usbh_class_driver_video(void)
|
||
{
|
||
uvc_device_pool_init();
|
||
system_event_usbh_video_init();
|
||
usbh_video_class.class_code = USB_CLASS_VIDEO;
|
||
|
||
usbh_video_class.enable = rt_usbh_class_driver_video_enable;
|
||
usbh_video_class.disable = rt_usbh_class_driver_video_disable;
|
||
|
||
return &usbh_video_class;
|
||
};
|
||
|
||
#endif
|