usb enqueue dequeue_failed to map sgs-优快云博客

本文链接：https://blog.youkuaiyun.com/wing_7/article/details/139063817

参考文档
https://www.cnblogs.com/wen123456/p/14373713.html

https://blog.youkuaiyun.com/weixin_42129680/article/details/125949162?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171618781116800182747485%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=171618781116800182747485&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-4-125949162-null-null.142^v100^pc_search_result_base6&utm_term=usb_ep_queue&spm=1018.2226.3001.4187

数据包传输：应用层-内核-硬件_应用层读取gadget 数据-优快云博客

usb设备控制器之uvc数据传输底层实现_usb uvc请求命令-优快云博客

ioctl—>/drivers/usb/gadget/function/uvc_v4l2.c：v4l2_file_operations uvc_v4l2_fops—>video_ioctl2(该函数在/drivers/media/v4l2-core/v4l2-ioctl.c)—>video_usercopy—>__video_do_ioctl—>v4l2_ioctls(这是个数组，找到对应的cmd执行对应的ioctl)—>v4l_qbuf（入队ioctl）—>ops->vidioc_qbuf(file, fh, p)—>uvc_v4l2_qbuf—>uvcg_video_pump—>uvcg_video_ep_queue—>usb_ep_queue—>ep->ops->queue(ep, req, gfp_flags)—>dwc3_gadget_ep_queue—>__dwc3_gadget_ep_queue（相关dma数据拷贝操作之后调用后面函数使能发送）—>__dwc3_gadget_kick_transfer

原文链接：https://blog.youkuaiyun.com/qq_18804879/article/details/118333486

static int
uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
{
        struct video_device *vdev = video_devdata(file);
        struct uvc_device *uvc = video_get_drvdata(vdev);
        struct uvc_video *video = &uvc->video;
        int ret;

        ret = uvcg_queue_buffer(&video->queue, b);
        if (ret < 0)
                return ret;

        return uvcg_video_pump(video);
}

/*
 * uvcg_video_pump - Pump video data into the USB requests
 *
 * This function fills the available USB requests (listed in req_free) with
 * video data from the queued buffers.
 */
int uvcg_video_pump(struct uvc_video *video)
{
        struct uvc_video_queue *queue = &video->queue;
        struct usb_request *req;
        struct uvc_buffer *buf;
        unsigned long flags;
        int ret;

        /* FIXME TODO Race between uvcg_video_pump and requests completion
         * handler ???
         */

        while (1) {
                /* Retrieve the first available USB request, protected by the
                 * request lock.
                 */
                spin_lock_irqsave(&video->req_lock, flags);
                if (list_empty(&video->req_free)) {
                        spin_unlock_irqrestore(&video->req_lock, flags);
                        return 0;
                }
                req = list_first_entry(&video->req_free, struct usb_request,
                                        list);
                list_del(&req->list);
                spin_unlock_irqrestore(&video->req_lock, flags);

                /* Retrieve the first available video buffer and fill the
                 * request, protected by the video queue irqlock.
                 */
                spin_lock_irqsave(&queue->irqlock, flags);
                buf = uvcg_queue_head(queue);
                if (buf == NULL) {
                        spin_unlock_irqrestore(&queue->irqlock, flags);
                        break;
                }

                video->encode(req, video, buf);

                /* Queue the USB request */
                ret = uvcg_video_ep_queue(video, req);
                spin_unlock_irqrestore(&queue->irqlock, flags);

                if (ret < 0) {
                        uvcg_queue_cancel(queue, 0);
                        break;
                }
        }

        spin_lock_irqsave(&video->req_lock, flags);
        list_add_tail(&req->list, &video->req_free);
        spin_unlock_irqrestore(&video->req_lock, flags);
        return 0;
}

int usb_ep_queue(struct usb_ep *ep,
                               struct usb_request *req, gfp_t gfp_flags)
{
        int ret = 0;

        if (WARN_ON_ONCE(!ep->enabled && ep->address)) {
                ret = -ESHUTDOWN;
                goto out;
        }
        //调用dwc3_gadget_ep_queue
        ret = ep->ops->queue(ep, req, gfp_flags);

out:
        trace_usb_ep_queue(ep, req, ret);

        return ret;
}
EXPORT_SYMBOL_GPL(usb_ep_queue);

static int dwc3_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request,
        gfp_t gfp_flags)
{
        struct dwc3_request             *req = to_dwc3_request(request);
        struct dwc3_ep                  *dep = to_dwc3_ep(ep);
        struct dwc3                     *dwc = dep->dwc;

        unsigned long                   flags;

        int                             ret;

        if (dwc3_gadget_is_suspended(dwc))
                return -EAGAIN;

        spin_lock_irqsave(&dwc->lock, flags);
        ret = __dwc3_gadget_ep_queue(dep, req);
        spin_unlock_irqrestore(&dwc->lock, flags);

        return ret;
}

2.6.1.2.向非端点0提交USB请求
usb_ep_queue向非端点0提交USB请求的过程如下图所示，最终通过__dwc3_gadget_ep_queue函数提交。下面分析一下向非端点0提交USB请求的主要工作内容：

设置USB请求的actual、status、direction、epnum和length等字段，对于输出端点，length必须是MaxPacketSize的整数倍。
对USB请求的缓冲区进行流式DMA映射。USB请求缓冲区是Function驱动使用kmalloc等函数分配，DMA不能直接使用，需要进行DMA映射，具体的映射过程在2.7小结介绍。
将提交的USB请求先放到pending_list链表。
调用__dwc3_gadget_kick_transfer函数驱动USB设备控制器发送USB请求。这里有几个特殊情况，图里面没有画出，下面简要说明一下。
bulk和control传输，则直接调用__dwc3_gadget_kick_transfer发送USB请求。
int和isoc传输，需要处理XferNotReady、XferInProgress、Stream Capable Bulk Endpoints等情况。
调用dwc3_prepare_trbs函数遍历pending_list将TRB和request绑定，执行完后pending_list链表上的request都会被放到started_list链表上。该函数会根据DMA缓冲区的使用形式做不同的处理，若DMA支持Scatter-gather，则调用dwc3_prepare_one_trb_sg函数，否则调用dwc3_prepare_one_trb_linear函数，最终都是通过dwc3_prepare_one_trb将TRB和request绑定。
从started_list链表中获取一个USB请求。若端点空闲，将其绑定的TRB DMA地址设置到param0和param1寄存器中，命令设置为DWC3_DEPCMD_STARTTRANSFER，开始传输。若端点忙碌，则将命令设置为DWC3_DEPCMD_UPDATETRANSFER，只更新传输，则不发送本次的USB请求。端点是否忙碌通过DWC3_EP_BUSY标志判断。
若端点空闲，则获取端点资源索引，用于辨别是那一次传输。

原文链接：https://blog.youkuaiyun.com/u011037593/article/details/123467147

只需要知道一点 usb设备控制器处理的是一个trb结构体指针，控制器自己分析里面数据启动传输

在ioctl qbuf的时候调用到__dwc3_gadget_ep_queue—>usb_gadget_map_request



int usb_gadget_map_request_by_dev(struct device *dev,
        struct usb_request *req, int is_in)
{
    if (req->length == 0)
        return 0;

    if (req->num_sgs) {
        int     mapped;

        mapped = dma_map_sg(dev, req->sg, req->num_sgs,
                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
        if (mapped == 0) {
            dev_err(dev, "failed to map SGs\n");
            return -EFAULT;
        }

        req->num_mapped_sgs = mapped;
    } else {
        req->dma = dma_map_single(dev, req->buf, req->length,
                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);在这映射到dma内存种

        if (dma_mapping_error(dev, req->dma)) {
            dev_err(dev, "failed to map buffer\n");
            return -EFAULT;
        }
    }

    return 0;
}

__dwc3_gadget_ep_queue—>__dwc3_gadget_kick_transfer—>dwc3_prepare_trbs—>dwc3_prepare_one_trb_linear—>dwc3_prepare_one_trb

启动传输

static int __dwc3_gadget_kick_transfer(struct dwc3_ep *dep)
{
        struct dwc3_gadget_ep_cmd_params params;
        struct dwc3_request             *req;
        struct dwc3