机构开通量化交易接口-UVC调用过程部分细节分析

UVC调用过程部分细节分析

通过VideoControlInterface来控制，通过VideoStreamingInterface来读视频数据，VC里含有多个Unit/Terminal等功能模块，可以通过访问这些模块进行控制，比如调亮度

VideoControlInterface用于控制，比如设置亮度。它内部有多个Unit/Terminal

ret = uvc_query_ctrl(dev  /* 哪一个USB设备 /, SET_CUR, ctrl->entity->id  / 哪一个unit/terminal /,dev->intfnum / 哪一个接口: VC interface */, ctrl->info->selector,
uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),ctrl->info->size);

可以通过类似的函数来访问：

ret = uvc_query_ctrl(dev  /* 哪一个USB设备 /, SET_CUR, ctrl->entity->id  / 哪一个unit/terminal /,dev->intfnum / 哪一个接口: VC interface */, ctrl->info->selector,
uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
ctrl->info->size);

VideoStreamingInterface用于获得视频数据，也可以用来选择fromat/frame

可以通过类似的函数来访问：

ret = __uvc_query_ctrl(video->dev /* 哪一个USB设备 */, SET_CUR, 0,video->streaming->intfnum  / 哪一个接口: VS */,
probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
uvc_timeout_param);

我们在设置FORMAT时只是简单的使用format=&stream->format[fmt->index];//获取视频流格式，等数据，

这些数据哪来的？应是设备被枚举时设置的，也就是分析它的描述符时设置的。UVC驱动的重点在于：描述符的分析属性的控制:通过VideoControlInterface来设置格式的选择：通过VideoStreamingInterface来设置数据的获得：通过VideoStreamingInterface的URB来获得

分析UVC驱动调用过程

const struct 机构开通量化交易接口,v4l2_file_operations uvc_fops = {
    .owner        = THIS_MODULE,
    .open        = uvc_机构开通量化交易接口,v4l2_open,
    .release    = uvc_v4l2_release,
    .unlocked_ioctl    = video_ioctl2,
#ifdef CONFIG_COMPAT
    .compat_ioctl32    = uvc_v4l2_compat_ioctl32,
#endif
    .read        = uvc_v4l2_read,
    .mmap        = uvc_v4l2_mmap,
    .poll        = uvc_v4l2_poll,
#ifndef CONFIG_MMU
    .get_unmapped_area = uvc_v4l2_get_unmapped_area,
#endif
};

static int uvc_v4l2_open(struct file *file)
{
    struct uvc_streaming *stream;
    struct uvc_fh *handle;
    int ret = 0;

    // 打印函数调用信息
    uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open
");
    // 获取视频设备的私有数据
    stream = video_drvdata(file);

    // 如果设备已经断开连接，返回错误码
    if (stream->dev->state & UVC_DEV_DISCONNECTED)
        return -ENODEV;

    // 获取接口的使用权
    ret = usb_autopm_get_interface(stream->dev->intf);
    if (ret < 0)
        return ret;

    // 创建设备句柄
    handle = kzalloc(sizeof *handle, GFP_KERNEL);
    if (handle == NULL) {
        usb_autopm_put_interface(stream->dev->intf);
        return -ENOMEM;
    }

    // 加锁，防止多个进程同时访问
    mutex_lock(&stream->dev->lock);
    // 如果当前没有用户使用设备，启动设备状态
    if (stream->dev->users == 0) {
        ret = uvc_status_start(stream->dev, GFP_KERNEL);
        if (ret < 0) {
            mutex_unlock(&stream->dev->lock);
            usb_autopm_put_interface(stream->dev->intf);
            kfree(handle);
            return ret;
        }
    }

    // 增加用户数
    stream->dev->users++;
    mutex_unlock(&stream->dev->lock);

    // 初始化文件句柄
    v4l2_fh_init(&handle->vfh, &stream->vdev);
    // 添加文件句柄
    v4l2_fh_add(&handle->vfh);
    handle->chain = stream->chain;
    handle->stream = stream;
    handle->state = UVC_HANDLE_PASSIVE;
    file->private_data = handle;

    return 0;

}

video_ioctl2将应用中提供的参数拷贝到内核，调用__video_do_ioctl

long video_ioctl2(struct file *file,
           unsigned int cmd, unsigned long arg)
{
    return video_usercopy(file, cmd, arg, __video_do_ioctl);
}

static long __video_do_ioctl(struct file *file,
        unsigned int cmd, void *arg)
{
    // 获取video_device结构体
    struct video_device *vfd = video_devdata(file);
    // 获取v4l2_ioctl_ops结构体
    const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
    // 判断是否为只写操作
    bool write_only = false;
    // 定义默认的ioctl信息
    struct v4l2_ioctl_info default_info;
    // 定义ioctl信息
    const struct v4l2_ioctl_info *info;
    // 获取file结构体的私有数据
    void *fh = file->private_data;
    // 获取v4l2_fh结构体
    struct v4l2_fh *vfh = NULL;
    // 获取dev_debug
    int dev_debug = vfd->dev_debug;
    // 定义返回值
    long ret = -ENOTTY;

    // 判断是否有ioctl_ops
    if (ops == NULL) {
        pr_warn("%s: has no ioctl_ops.
",
                video_device_node_name(vfd));
        return ret;
    }

    // 判断是否使用v4l2_fh
    if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags))
        vfh = file->private_data;

    // 判断是否为已知的ioctl
    if (v4l2_is_known_ioctl(cmd)) {
        // 获取ioctl信息
        info = &v4l2_ioctls[_IOC_NR(cmd)];

            // 判断是否为有效的ioctl
        if (!test_bit(_IOC_NR(cmd), vfd->valid_ioctls) &&
            !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))
            goto done;

        // 判断是否需要检查优先级
        if (vfh && (info->flags & INFO_FL_PRIO)) {
            ret = v4l2_prio_check(vfd->prio, vfh->prio);
            if (ret)
                goto done;
        }
    } else {
        // 设置默认的ioctl信息
        default_info.ioctl = cmd;
        default_info.flags = 0;
        default_info.debug = v4l_print_default;
        info = &default_info;
    }

write_only = _IOC_DIR(cmd) == _IOC_WRITE;
    // 判断是否为标准的ioctl
    if (info->flags & INFO_FL_STD) {
        // 定义vidioc_op函数指针类型
        typedef int (*vidioc_op)(struct file *file, void *fh, void *p);
        // 获取ioctl_ops
        const void *p = vfd->ioctl_ops;
        // 获取vidioc函数指针
        const vidioc_op *vidioc = p + info->u.offset;

        // 调用vidioc函数
        ret = (*vidioc)(file, fh, arg);
    } 
    // 判断是否为函数ioctl
    else if (info->flags & INFO_FL_FUNC) {
        // 调用函数ioctl
        ret = info->u.func(ops, file, fh, arg);
    } 
    // 判断是否有默认的ioctl
    else if (!ops->vidioc_default) {
        ret = -ENOTTY;
    } 
    // 调用默认的ioctl
    else {
        ret = ops->vidioc_default(file, fh,
            vfh ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
            cmd, arg);
    }

done:
    // 判断是否需要打印调试信息
    if (dev_debug & (V4L2_DEV_DEBUG_IOCTL | V4L2_DEV_DEBUG_IOCTL_ARG)) {
        // 判断是否需要打印流信息
        if (!(dev_debug & V4L2_DEV_DEBUG_STREAMING) &&
            (cmd == VIDIOC_QBUF || cmd == VIDIOC_DQBUF))
            return ret;

        // 打印ioctl信息
        v4l_printk_ioctl(video_device_node_name(vfd), cmd);
        if (ret < 0)
            pr_cont(": error %ld", ret);
        if (!(dev_debug & V4L2_DEV_DEBUG_IOCTL_ARG))
            pr_cont("
");
        else if (_IOC_DIR(cmd) == _IOC_NONE)
            info->debug(arg, write_only);
        else {
            pr_cont(": ");
            info->debug(arg, write_only);
        }
    }

    return ret;
}
根据传入的参数调用对应的ioctl
    write_only = _IOC_DIR(cmd) == _IOC_WRITE;
    // 判断是否为标准的ioctl
    if (info->flags & INFO_FL_STD) {
        // 定义vidioc_op函数指针类型
        typedef int (*vidioc_op)(struct file *file, void *fh, void *p);
        // 获取ioctl_ops
        const void *p = vfd->ioctl_ops;
        // 获取vidioc函数指针
        const vidioc_op *vidioc = p + info->u.offset;

        // 调用vidioc函数
        ret = (*vidioc)(file, fh, arg);
    } 
    // 判断是否为函数ioctl
    else if (info->flags & INFO_FL_FUNC) {
        // 调用函数ioctl
        ret = info->u.func(ops, file, fh, arg);
    } 
    // 判断是否有默认的ioctl
    else if (!ops->vidioc_default) {
        ret = -ENOTTY;
    } 
    // 调用默认的ioctl
    else {
        ret = ops->vidioc_default(file, fh,
            vfh ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
            cmd, arg);
    }

const struct v4l2_ioctl_ops uvc_ioctl_ops = {
    .vidioc_querycap = uvc_ioctl_querycap,
    .vidioc_enum_fmt_vid_cap = uvc_ioctl_enum_fmt_vid_cap,
    .vidioc_enum_fmt_vid_out = uvc_ioctl_enum_fmt_vid_out,
    .vidioc_g_fmt_vid_cap = uvc_ioctl_g_fmt_vid_cap,
    .vidioc_g_fmt_vid_out = uvc_ioctl_g_fmt_vid_out,
    .vidioc_s_fmt_vid_cap = uvc_ioctl_s_fmt_vid_cap,
    .vidioc_s_fmt_vid_out = uvc_ioctl_s_fmt_vid_out,
    .vidioc_try_fmt_vid_cap = uvc_ioctl_try_fmt_vid_cap,
    .vidioc_try_fmt_vid_out = uvc_ioctl_try_fmt_vid_out,
    .vidioc_reqbufs = uvc_ioctl_reqbufs,
    .vidioc_querybuf = uvc_ioctl_querybuf,
    .vidioc_qbuf = uvc_ioctl_qbuf,
    .vidioc_dqbuf = uvc_ioctl_dqbuf,
    .vidioc_create_bufs = uvc_ioctl_create_bufs,
    .vidioc_streamon = uvc_ioctl_streamon,
    .vidioc_streamoff = uvc_ioctl_streamoff,
    .vidioc_enum_input = uvc_ioctl_enum_input,
    .vidioc_g_input = uvc_ioctl_g_input,
    .vidioc_s_input = uvc_ioctl_s_input,
    .vidioc_queryctrl = uvc_ioctl_queryctrl,
    .vidioc_query_ext_ctrl = uvc_ioctl_query_ext_ctrl,
    .vidioc_g_ctrl = uvc_ioctl_g_ctrl,
    .vidioc_s_ctrl = uvc_ioctl_s_ctrl,
    .vidioc_g_ext_ctrls = uvc_ioctl_g_ext_ctrls,
    .vidioc_s_ext_ctrls = uvc_ioctl_s_ext_ctrls,
    .vidioc_try_ext_ctrls = uvc_ioctl_try_ext_ctrls,
    .vidioc_querymenu = uvc_ioctl_querymenu,
    .vidioc_g_selection = uvc_ioctl_g_selection,
    .vidioc_g_parm = uvc_ioctl_g_parm,
    .vidioc_s_parm = uvc_ioctl_s_parm,
    .vidioc_enum_framesizes = uvc_ioctl_enum_framesizes,
    .vidioc_enum_frameintervals = uvc_ioctl_enum_frameintervals,
    .vidioc_subscribe_event = uvc_ioctl_subscribe_event,
    .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
    .vidioc_default = uvc_ioctl_default,
};

video->streaming->type应该是在设备被枚举时分析描述符时设置的

static int uvc_ioctl_querycap(struct file *file, void *fh,
                  struct v4l2_capability *cap)
{
    // 获取video_device结构体
    struct video_device *vdev = video_devdata(file);
    // 获取uvc_fh结构体
    struct uvc_fh *handle = file->private_data;
    // 获取uvc_video_chain结构体
    struct uvc_video_chain *chain = handle->chain;
    // 获取uvc_streaming结构体
    struct uvc_streaming *stream = handle->stream;

    // 设置驱动名称
    strlcpy(cap->driver, "uvcvideo", sizeof(cap->driver));
    // 设置设备名称
    strlcpy(cap->card, vdev->name, sizeof(cap->card));
    // 设置总线信息
    usb_make_path(stream->dev->udev, cap->bus_info, sizeof(cap->bus_info));
    // 设置设备能力
    cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING | chain->caps;
    // 设置设备类型
    if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
    else
        cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;

    return 0;
}

   // 设置设备类型
    if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
    else
        cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;

format数组应是在设备被枚举时设置的

static int uvc_ioctl_enum_fmt(struct uvc_streaming *stream,
                  struct v4l2_fmtdesc *fmt)
{
struct uvc_format *format;
    enum v4l2_buf_type type = fmt->type; // 获取视频流类型
    __u32 index = fmt->index; // 获取视频流格式索引

    if (fmt->type != stream->type || fmt->index >= stream->nformats) // 如果视频流类型不匹配或者视频流格式索引超出范围
        return -EINVAL; // 返回无效参数错误

    memset(fmt, 0, sizeof(*fmt)); // 清空fmt结构体
    fmt->index = index; // 设置视频流格式索引
    fmt->type = type; // 设置视频流类型

    format = &stream->format[fmt->index]; // 获取视频流格式
    fmt->flags = 0; // 清空标志位
    if (format->flags & UVC_FMT_FLAG_COMPRESSED) // 如果视频流格式是压缩格式
        fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; // 设置标志位
    strlcpy(fmt->description, format->name, sizeof(fmt->description)); // 设置视频流格式描述
    fmt->description[sizeof(fmt->description) - 1] = 0; // 设置视频流格式描述
    fmt->pixelformat = format->fcc; // 设置视频流像素格式
    return 0; // 返回成功

}

format = &stream->format[fmt->index]; // 获取视频流格式

uvc_v4l2_get_format//USB摄像头支持多种格式fromat,每种格式下有多种frame

static int uvc_v4l2_get_format(struct uvc_streaming *stream,
    struct v4l2_format *fmt)
{
    // 获取当前流的格式和帧
    struct uvc_format *format;
    struct uvc_frame *frame;
    int ret = 0;

    // 如果请求的格式不是当前流的格式，返回错误
    if (fmt->type != stream->type)
        return -EINVAL;

    // 获取当前流的格式和帧
    mutex_lock(&stream->mutex);
    format = stream->cur_format;
    frame = stream->cur_frame;

    // 如果当前流的格式或帧为空，返回错误
    if (format == NULL || frame == NULL) {
        ret = -EINVAL;
        goto done;
    }

    // 设置请求的格式
    fmt->fmt.pix.pixelformat = format->fcc;
    fmt->fmt.pix.width = frame->wWidth;
    fmt->fmt.pix.height = frame->wHeight;
    fmt->fmt.pix.field = V4L2_FIELD_NONE;
    fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
    fmt->fmt.pix.sizeimage = stream->ctrl.dwMaxVideoFrameSize;
    fmt->fmt.pix.colorspace = format->colorspace;
    fmt->fmt.pix.priv = 0;

done:
    mutex_unlock(&stream->mutex);
    return ret;
}

// 获取当前流的格式和帧
struct uvc_format *format;
struct uvc_frame *frame;

// 获取当前流的格式和帧
mutex_lock(&stream->mutex);
format = stream->cur_format;
frame = stream->cur_frame;

    /* Check if the hardware supports the requested format. */

     /* Find the closest image size. The distance between image sizes is
      * the size in pixels of the non-overlapping regions between the
      * requested size and the frame-specified size.
      */

uvc_v4l2_try_format
static int uvc_v4l2_try_format(struct uvc_streaming *stream,
    struct v4l2_format *fmt, struct uvc_streaming_control *probe,
    struct uvc_format **uvc_format, struct uvc_frame **uvc_frame)
{
struct uvc_format *format = NULL; // 初始化uvc_format结构体指针
    struct uvc_frame *frame = NULL; // 初始化uvc_frame结构体指针
    __u16 rw, rh; // 定义宽度和高度
    unsigned int d, maxd; // 定义距离和最大距离
    unsigned int i; // 定义无符号整型变量i
    __u32 interval; // 定义无符号32位整型变量interval
    int ret = 0; // 定义整型变量ret并初始化为0
    __u8 *fcc; // 定义指向无符号8位整型变量的指针fcc

    if (fmt->type != stream->type) // 如果格式类型不匹配
        return -EINVAL; // 返回无效参数错误

    fcc = (__u8 *)&fmt->fmt.pix.pixelformat; // 将fcc指针指向像素格式
    uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.
",
            fmt->fmt.pix.pixelformat,
            fcc[0], fcc[1], fcc[2], fcc[3],
            fmt->fmt.pix.width, fmt->fmt.pix.height); // 打印正在尝试的格式

    /* Check if the hardware supports the requested format, use the default
     * format otherwise.
     */
    for (i = 0; i < stream->nformats; ++i) { // 遍历所有格式
        format = &stream->format[i]; // 将format指针指向当前格式
        if (format->fcc == fmt->fmt.pix.pixelformat) // 如果当前格式与请求格式匹配
            break; // 跳出循环
    }

    if (i == stream->nformats) { // 如果没有匹配的格式
        format = stream->def_format; // 使用默认格式
        fmt->fmt.pix.pixelformat = format->fcc; // 将请求格式设置为默认格式
    }

/* 寻找最接近的图像大小。图像大小之间的距离是请求大小和帧指定大小之间的非重叠区域的大小。*/
    rw = fmt->fmt.pix.width; // 获取请求的宽度
    rh = fmt->fmt.pix.height; // 获取请求的高度
    maxd = (unsigned int)-1; // 初始化最大距离

    for (i = 0; i < format->nframes; ++i) { // 遍历所有帧
        __u16 w = format->frame[i].wWidth; // 获取当前帧的宽度
        __u16 h = format->frame[i].wHeight; // 获取当前帧的高度

        d = min(w, rw) * min(h, rh); // 计算非重叠区域的大小
        d = w*h + rw*rh - 2*d; // 计算距离
        if (d < maxd) { // 如果距离小于最大距离
            maxd = d; // 更新最大距离
            frame = &format->frame[i]; // 更新帧
        }

        if (maxd == 0) // 如果最大距离为0
            break; // 跳出循环
    }

    if (frame == NULL) { // 如果没有找到匹配的帧
        uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.
",
                fmt->fmt.pix.width, fmt->fmt.pix.height); // 打印不支持的大小
        return -EINVAL; // 返回无效参数错误
    }

/* Use the default frame interval. */
    // 使用默认帧间隔
    interval = frame->dwDefaultFrameInterval;
    // 打印使用的帧间隔
    uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us "
        "(%u.%u fps).
", interval/10, interval%10, 10000000/interval,
        (100000000/interval)%10);

    /* Set the format index, frame index and frame interval. */
    // 设置格式索引、帧索引和帧间隔
    memset(probe, 0, sizeof *probe);
    probe->bmHint = 1;  /* dwFrameInterval */
    probe->bFormatIndex = format->index;
    probe->bFrameIndex = frame->bFrameIndex;
    probe->dwFrameInterval = uvc_try_frame_interval(frame, interval);

    /* Some webcams stall the probe control set request when the
     * dwMaxVideoFrameSize field is set to zero. The UVC specification
     * clearly states that the field is read-only from the host, so this
     * is a webcam bug. Set dwMaxVideoFrameSize to the value reported by
     * the webcam to work around the problem.
     *
     * The workaround could probably be enabled for all webcams, so the
     * quirk can be removed if needed. It"s currently useful to detect
     * webcam bugs and fix them before they hit the market (providing
     * developers test their webcams with the Linux driver as well as with
     * the Windows driver).
     */
// 加锁
    mutex_lock(&stream->mutex);
    // 如果设备有 UVC_QUIRK_PROBE_EXTRAFIELDS 标志，设置探测结构体的最大视频帧大小
    if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
        probe->dwMaxVideoFrameSize =
            stream->ctrl.dwMaxVideoFrameSize;

    /* Probe the device. */
    // 探测设备
    ret = uvc_probe_video(stream, probe);
    // 解锁
    mutex_unlock(&stream->mutex);
    // 如果探测失败，跳转到 done 标签
    if (ret < 0)
        goto done;

    // 设置请求的格式
    fmt->fmt.pix.width = frame->wWidth;
    fmt->fmt.pix.height = frame->wHeight;
    fmt->fmt.pix.field = V4L2_FIELD_NONE;
    fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
    fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize;
    fmt->fmt.pix.colorspace = format->colorspace;
    fmt->fmt.pix.priv = 0;

    // 如果 uvc_format 不为空，将当前流的格式赋值给它
    if (uvc_format != NULL)
        *uvc_format = format;
    // 如果 uvc_frame 不为空，将当前流的帧赋值给它
    if (uvc_frame != NULL)
        *uvc_frame = frame;

done:
    // 返回探测结果
    return ret;
}

只是把参数保存起来，还没有发给USB摄像头

 uvc_v4l2_set_format
     uvc_v4l2_try_format
     video->streaming->cur_format = format;
     video->streaming->cur_frame = frame;

static int uvc_v4l2_set_format(struct uvc_streaming *stream,
    struct v4l2_format *fmt)
{
    // 定义探测结构体、格式、帧和返回值
    struct uvc_streaming_control probe;
    struct uvc_format *format;
    struct uvc_frame *frame;
    int ret;

    // 如果请求的格式不是当前流的格式，返回错误
    if (fmt->type != stream->type)
        return -EINVAL;

    // 尝试设置格式
    ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame);
    if (ret < 0)
        return ret;

    // 上锁
    mutex_lock(&stream->mutex);

    // 如果队列已经分配，返回错误
    if (uvc_queue_allocated(&stream->queue)) {
        ret = -EBUSY;
        goto done;
    }

    // 设置控制结构体、当前格式和当前帧
    stream->ctrl = probe;
    stream->cur_format = format;
    stream->cur_frame = frame;

done:
    // 解锁
    mutex_unlock(&stream->mutex);
    return ret;

static int uvc_ioctl_reqbufs(struct file *file, void *fh,
                 struct v4l2_requestbuffers *rb)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;
    int ret;

    // 获取权限
    ret = uvc_acquire_privileges(handle);
    if (ret < 0)
        return ret;

    // 上锁
    mutex_lock(&stream->mutex);
    // 请求缓冲区
    ret = uvc_request_buffers(&stream->queue, rb);
    // 解锁
    mutex_unlock(&stream->mutex);
    if (ret < 0)
        return ret;

    // 如果请求成功，解除权限
    if (ret == 0)
        uvc_dismiss_privileges(handle);

    return 0;
}

int uvc_request_buffers(struct uvc_video_queue *queue,
            struct v4l2_requestbuffers *rb)
{
    int ret;

    mutex_lock(&queue->mutex);
    ret = vb2_reqbufs(&queue->queue, rb);
    mutex_unlock(&queue->mutex);

    return ret ? ret : rb->count;
}

int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
{
    int ret = __verify_memory_type(q, req->memory, req->type);

    return ret ? ret : __reqbufs(q, req);
}

static int __reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
{
    unsigned int num_buffers, allocated_buffers, num_planes = 0;
    int ret;

    // 检查是否正在流传输
    if (q->streaming) {
        dprintk(1, "streaming active
");
        return -EBUSY;
    }

    // 检查是否需要重新分配内存
    if (req->count == 0 || q->num_buffers != 0 || q->memory != req->memory) {
        /*
         * We already have buffers allocated, so first check if they
         * are not in use and can be freed.
         */
        mutex_lock(&q->mmap_lock);

        // 检查内存是否正在使用
        if (q->memory == V4L2_MEMORY_MMAP && __buffers_in_use(q)) {
            mutex_unlock(&q->mmap_lock);
            dprintk(1, "memory in use, cannot free
");
            return -EBUSY;
        }

        /*
         * Call queue_cancel to clean up any buffers in the PREPARED or
         * QUEUED state which is possible if buffers were prepared or
         * queued without ever calling STREAMON.
         */

        // 取消队列中所有处于 PREPARED 或 QUEUED 状态的缓冲区
        __vb2_queue_cancel(q);

        // 释放所有缓冲区
        ret = __vb2_queue_free(q, q->num_buffers);
        mutex_unlock(&q->mmap_lock);
        if (ret)
            return ret;

        /*
         * In case of REQBUFS(0) return immediately without calling
         * driver"s queue_setup() callback and allocating resources.
         */

        // 如果请求的缓冲区数量为 0，则直接返回
        if (req->count == 0)
            return 0;
    }

/*
     * Make sure the requested values and current defaults are sane.
     */
    // 确保请求的值和当前默认值是合理的
    num_buffers = min_t(unsigned int, req->count, VIDEO_MAX_FRAME);
    num_buffers = max_t(unsigned int, num_buffers, q->min_buffers_needed);
    memset(q->plane_sizes, 0, sizeof(q->plane_sizes));
    memset(q->alloc_ctx, 0, sizeof(q->alloc_ctx));
    q->memory = req->memory;

    /*
     * Ask the driver how many buffers and planes per buffer it requires.
     * Driver also sets the size and allocator context for each plane.
     */
    // 询问驱动程序需要多少缓冲区和每个缓冲区的平面数
    // 驱动程序还为每个平面设置大小和分配器上下文
    ret = call_qop(q, queue_setup, q, NULL, &num_buffers, &num_planes,
               q->plane_sizes, q->alloc_ctx);
    if (ret)
        return ret;

    /* Finally, allocate buffers and video memory */
    // 最后，分配缓冲区和视频内存
    allocated_buffers = __vb2_queue_alloc(q, req->memory, num_buffers, num_planes);
    if (allocated_buffers == 0) {
        dprintk(1, "memory allocation failed
");
        return -ENOMEM;
    }

    /*
     * There is no point in continuing if we can"t allocate the minimum
     * number of buffers needed by this vb2_queue.
     */
    // 如果我们无法为此 vb2_queue 分配所需的最小缓冲区数量，则继续没有意义
    if (allocated_buffers < q->min_buffers_needed)
        ret = -ENOMEM;

/*
     * Check if driver can handle the allocated number of buffers.
     */
    // 检查驱动程序是否可以处理分配的缓冲区数量
    if (!ret && allocated_buffers < num_buffers) {
        num_buffers = allocated_buffers;

        // 询问驱动程序需要多少缓冲区和每个缓冲区的平面数
        // 驱动程序还为每个平面设置大小和分配器上下文
        ret = call_qop(q, queue_setup, q, NULL, &num_buffers,
                   &num_planes, q->plane_sizes, q->alloc_ctx);

        // 如果分配的缓冲区数量小于请求的数量，则返回错误
        if (!ret && allocated_buffers < num_buffers)
            ret = -ENOMEM;

        /*
         * Either the driver has accepted a smaller number of buffers,
         * or .queue_setup() returned an error
         */
    }

    // 获取互斥锁
    mutex_lock(&q->mmap_lock);
    q->num_buffers = allocated_buffers;

    if (ret < 0) {
        /*
         * Note: __vb2_queue_free() will subtract "allocated_buffers"
         * from q->num_buffers.
         */
        // 如果分配失败，则释放所有缓冲区
        __vb2_queue_free(q, allocated_buffers);
        mutex_unlock(&q->mmap_lock);
        return ret;
    }
    // 释放互斥锁
    mutex_unlock(&q->mmap_lock);

    /*
     * Return the number of successfully allocated buffers
     * to the userspace.
     */
    // 返回成功分配的缓冲区数量
    req->count = allocated_buffers;
    q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type);

    return 0;


}

static int uvc_ioctl_querybuf(struct file *file, void *fh,
                  struct v4l2_buffer *buf)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;

    // 如果没有权限，返回错误
    if (!uvc_has_privileges(handle))
        return -EBUSY;

    // 查询缓冲区
    return uvc_query_buffer(&stream->queue, buf);
}

int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
{


    int ret;

    mutex_lock(&queue->mutex);
    ret = vb2_querybuf(&queue->queue, buf);
    mutex_unlock(&queue->mutex);

    return ret;
}

 uvc_ioctl_querybuf
     uvc_query_buffer
         vb2_querybuf

int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)
{
    // 获取对应的vb2_buffer
    struct vb2_buffer *vb;
    int ret;

    // 检查buffer类型是否正确
    if (b->type != q->type) {
        dprintk(1, "wrong buffer type
");
        return -EINVAL;
    }

    // 检查buffer index是否越界
    if (b->index >= q->num_buffers) {
        dprintk(1, "buffer index out of range
");
        return -EINVAL;
    }
    vb = q->bufs[b->index];

    // 验证planes数组是否正确
    ret = __verify_planes_array(vb, b);

    // 填充v4l2_buffer结构体
    if (!ret)
        __fill_v4l2_buffer(vb, b);
    return ret;
}

 uvc_ioctl_querybuf
     uvc_query_buffer
         vb2_querybuf
            __fill_v4l2_buffer

复制参数

memcpy(b, &vb->v4l2_buf, offsetof(struct v4l2_buffer, m));

static void __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)
{
    struct vb2_queue *q = vb->vb2_queue;

    /* 复制回时间戳、标志等数据 */
    memcpy(b, &vb->v4l2_buf, offsetof(struct v4l2_buffer, m));
    b->reserved2 = vb->v4l2_buf.reserved2;
    b->reserved = vb->v4l2_buf.reserved;

    if (V4L2_TYPE_IS_MULTIPLANAR(q->type)) {
        /*
         * 如果用户空间提供了一个数组，填充与平面相关的数据。
         * 调用者已经验证了内存和大小。
         */
        b->length = vb->num_planes;
        memcpy(b->m.planes, vb->v4l2_planes,
            b->length * sizeof(struct v4l2_plane));
    } else {
        /*
         * 即使对于单平面缓冲区，我们也使用v4l2_planes数组中的长度和偏移量，
         * 但用户空间不使用。
         */
        b->length = vb->v4l2_planes[0].length;
        b->bytesused = vb->v4l2_planes[0].bytesused;
        if (q->memory == V4L2_MEMORY_MMAP)
            b->m.offset = vb->v4l2_planes[0].m.mem_offset;
        else if (q->memory == V4L2_MEMORY_USERPTR)
            b->m.userptr = vb->v4l2_planes[0].m.userptr;
        else if (q->memory == V4L2_MEMORY_DMABUF)
            b->m.fd = vb->v4l2_planes[0].m.fd;
    }

/*
     * Clear any buffer state related flags.
     */
    // 清除任何与缓冲区状态相关的标志。
    b->flags &= ~V4L2_BUFFER_MASK_FLAGS;
    // 将时间戳标志设置为队列的时间戳标志
    b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK;
    // 如果时间戳标志不是V4L2_BUF_FLAG_TIMESTAMP_COPY，则删除时间戳源位并从队列中获取时间戳源。
    if ((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) !=
        V4L2_BUF_FLAG_TIMESTAMP_COPY) {
        b->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
        b->flags |= q->timestamp_flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
    }

    switch (vb->state) {
    case VB2_BUF_STATE_QUEUED:
    case VB2_BUF_STATE_ACTIVE:
        // 如果缓冲区状态为VB2_BUF_STATE_QUEUED或VB2_BUF_STATE_ACTIVE，则将V4L2_BUF_FLAG_QUEUED标志设置为1。
        b->flags |= V4L2_BUF_FLAG_QUEUED;
        break;
    case VB2_BUF_STATE_ERROR:
        // 如果缓冲区状态为VB2_BUF_STATE_ERROR，则将V4L2_BUF_FLAG_ERROR标志设置为1。
        b->flags |= V4L2_BUF_FLAG_ERROR;
        /* fall through */
    case VB2_BUF_STATE_DONE:
        // 如果缓冲区状态为VB2_BUF_STATE_DONE，则将V4L2_BUF_FLAG_DONE标志设置为1。
        b->flags |= V4L2_BUF_FLAG_DONE;
        break;
    case VB2_BUF_STATE_PREPARED:
        // 如果缓冲区状态为VB2_BUF_STATE_PREPARED，则将V4L2_BUF_FLAG_PREPARED标志设置为1。
        b->flags |= V4L2_BUF_FLAG_PREPARED;
        break;
    case VB2_BUF_STATE_PREPARING:
    case VB2_BUF_STATE_DEQUEUED:
        // 如果缓冲区状态为VB2_BUF_STATE_PREPARING或VB2_BUF_STATE_DEQUEUED，则不做任何操作。
        break;
    }

    // 如果缓冲区正在使用，则将V4L2_BUF_FLAG_MAPPED标志设置为1。
    if (__buffer_in_use(q, vb))
        b->flags |= V4L2_BUF_FLAG_MAPPED;
}

static int
uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
{
    struct video_device *vdev = video_devdata(file);
    struct uvc_device *uvc = video_get_drvdata(vdev);

    return uvcg_queue_mmap(&uvc->video.queue, vma);
}

int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
{
    // 将虚拟内存地址转换为物理内存地址
    unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
    // 定义一个vb2_buffer结构体指针
    struct vb2_buffer *vb;
    // 定义一个unsigned int类型的变量buffer和plane
    unsigned int buffer = 0, plane = 0;
    // 定义一个int类型的变量ret
    int ret;
    // 定义一个unsigned long类型的变量length

    // 判断内存类型是否为V4L2_MEMORY_MMAP
    if (q->memory != V4L2_MEMORY_MMAP) {
        dprintk(1, "queue is not currently set up for mmap
");
        return -EINVAL;
    }

    /*
     * 检查内存区域访问模式。
     */
    if (!(vma->vm_flags & VM_SHARED)) {
        dprintk(1, "invalid vma flags, VM_SHARED needed
");
        return -EINVAL;
    }
    if (V4L2_TYPE_IS_OUTPUT(q->type)) {
        if (!(vma->vm_flags & VM_WRITE)) {
            dprintk(1, "invalid vma flags, VM_WRITE needed
");
            return -EINVAL;
        }
    } else {
        if (!(vma->vm_flags & VM_READ)) {
            dprintk(1, "invalid vma flags, VM_READ needed
");
            return -EINVAL;
        }
    }
    if (vb2_fileio_is_active(q)) {
        dprintk(1, "mmap: file io in progress
");
        return -EBUSY;
    }



    /*
     * Find the plane corresponding to the offset passed by userspace.
     */
    // 找到与用户空间传递的偏移量对应的平面
    ret = __find_plane_by_offset(q, off, &buffer, &plane);
    if (ret)
        return ret;

    vb = q->bufs[buffer];

    /*
     * MMAP requires page_aligned buffers.
     * The buffer length was page_aligned at __vb2_buf_mem_alloc(),
     * so, we need to do the same here.
     */
    // MMAP需要页面对齐的缓冲区。
    // 缓冲区长度在__vb2_buf_mem_alloc()中进行了页面对齐，
    // 因此我们需要在此处执行相同的操作。
    length = PAGE_ALIGN(vb->v4l2_planes[plane].length);
    if (length < (vma->vm_end - vma->vm_start)) {
        dprintk(1,
            "MMAP invalid, as it would overflow buffer length
");
        return -EINVAL;
    }

    mutex_lock(&q->mmap_lock);
    // 调用内存操作函数mmap
    ret = call_memop(vb, mmap, vb->planes[plane].mem_priv, vma);
    mutex_unlock(&q->mmap_lock);
    if (ret)
        return ret;

    dprintk(3, "buffer %d, plane %d successfully mapped
", buffer, plane);
    return 0;


}

static int uvc_ioctl_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;

    // 如果没有权限，返回错误
    if (!uvc_has_privileges(handle))
        return -EBUSY;

    // 将缓冲区加入队列
    return uvc_queue_buffer(&stream->queue, buf);
}

将缓冲区加入队列

static int vb2_internal_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
{
    /* 调用驱动程序提供的函数做些预处理 */
    int ret = vb2_queue_or_prepare_buf(q, b, "qbuf");
    struct vb2_buffer *vb;

    if (ret)
        return ret;

    vb = q->bufs[b->index];

    switch (vb->state) {
    case VB2_BUF_STATE_DEQUEUED:
        ret = __buf_prepare(vb, b);
        if (ret)
            return ret;
        break;
    case VB2_BUF_STATE_PREPARED:
        break;
    case VB2_BUF_STATE_PREPARING:
        dprintk(1, "buffer still being prepared
");
        return -EINVAL;
    default:
        dprintk(1, "invalid buffer state %d
", vb->state);
        return -EINVAL;
    }

    /*
     * Add to the queued buffers list, a buffer will stay on it until
     * dequeued in dqbuf.
     */
     /* 把缓冲区放入队列的尾部 */
    list_add_tail(&vb->queued_entry, &q->queued_list);
    q->queued_count++;
    q->waiting_for_buffers = false;
    vb->state = VB2_BUF_STATE_QUEUED;
    if (V4L2_TYPE_IS_OUTPUT(q->type)) {
        /*
         * For output buffers copy the timestamp if needed,
         * and the timecode field and flag if needed.
         */
        if ((q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) ==
            V4L2_BUF_FLAG_TIMESTAMP_COPY)
            vb->v4l2_buf.timestamp = b->timestamp;
        vb->v4l2_buf.flags |= b->flags & V4L2_BUF_FLAG_TIMECODE;
        if (b->flags & V4L2_BUF_FLAG_TIMECODE)
            vb->v4l2_buf.timecode = b->timecode;
    }

    /*
     * If already streaming, give the buffer to driver for processing.
     * If not, the buffer will be given to driver on next streamon.
     */
    if (q->start_streaming_called)
        __enqueue_in_driver(vb);

    /* Fill buffer information for the userspace */
    __fill_v4l2_buffer(vb, b);

    /*
     * If streamon has been called, and we haven"t yet called
     * start_streaming() since not enough buffers were queued, and
     * we now have reached the minimum number of queued buffers,
     * then we can finally call start_streaming().
     */
    if (q->streaming && !q->start_streaming_called &&
        q->queued_count >= q->min_buffers_needed) {
        ret = vb2_start_streaming(q);
        if (ret)
            return ret;
    }

    dprintk(1, "qbuf of buffer %d succeeded
", vb->v4l2_buf.index);
    return 0;

uvc_video_enable(video, 1)  // 把所设置的参数发给硬件,然后启动摄像头
    /* Commit the streaming parameters. */
    uvc_commit_video
        uvc_set_video_ctrl  /* 设置格式fromat, frame */
                ret = __uvc_query_ctrl(video->dev /* 哪一个USB设备 */, SET_CUR, 0,
                    video->streaming->intfnum  /* 哪一个接口: VS */,
                    probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
                    uvc_timeout_param);
            
    /* 启动：Initialize isochronous/bulk URBs and allocate transfer buffers. */
    uvc_init_video(video, GFP_KERNEL);
            uvc_init_video_isoc / uvc_init_video_bulk
                urb->complete = uvc_video_complete; (收到数据后此函数被调用,它又调用video->decode(urb, video, buf); ==> uvc_video_decode_isoc/uvc_video_encode_bulk => uvc_queue_next_buffer => wake_up(&buf->wait);)
                
            usb_submit_urb

static int uvc_ioctl_streamon(struct file *file, void *fh,
                  enum v4l2_buf_type type)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;
    int ret;

    // 如果没有权限，返回错误
    if (!uvc_has_privileges(handle))
        return -EBUSY;

    // 上锁
    mutex_lock(&stream->mutex);
    // 开始流
    ret = uvc_queue_streamon(&stream->queue, type);
    // 解锁
    mutex_unlock(&stream->mutex);

    return ret;
}

uvc_queue_streamon
    vb2_streamon
        vb2_internal_streamon

static int vb2_internal_streamon(struct vb2_queue *q, enum v4l2_buf_type type)
{
    // 检查type是否合法
    if (type != q->type) {
        dprintk(1, "invalid stream type
");
        return -EINVAL;
    }

    // 如果已经在streaming了，直接返回0
    if (q->streaming) {
        dprintk(3, "already streaming
");
        return 0;
    }

    // 如果没有分配buffer，返回错误
    if (!q->num_buffers) {
        dprintk(1, "no buffers have been allocated
");
        return -EINVAL;
    }

    // 如果分配的buffer数量小于最小需要的数量，返回错误
    if (q->num_buffers < q->min_buffers_needed) {
        dprintk(1, "need at least %u allocated buffers
",
                q->min_buffers_needed);
        return -EINVAL;
    }

    /*
     * 如果已经有足够的buffer在队列中，就通知驱动开始streaming
     */
    if (q->queued_count >= q->min_buffers_needed) {
        int ret = vb2_start_streaming(q);
        if (ret) {
            __vb2_queue_cancel(q);
            return ret;
        }
    }

    // 设置streaming标志位
    q->streaming = 1;

    dprintk(3, "successful
");
    return 0;
}

uvc_queue_streamon
    vb2_streamon
        vb2_internal_streamon
            vb2_start_streaming

uvc_queue_streamon
    vb2_streamon
        vb2_internal_streamon
            __vb2_queue_cancel

static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
{
    // 获取文件句柄
    struct uvc_fh *handle = file->private_data;
    // 获取流
    struct uvc_streaming *stream = handle->stream;

    // 打印调试信息
    uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll
");

    // 调用队列的poll函数
    return uvc_queue_poll(&stream->queue, file, wait);
}

unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
                poll_table *wait)
{
    // 定义返回值
    unsigned int ret;

    // 获取互斥锁
    mutex_lock(&queue->mutex);
    // 调用vb2_poll函数
    ret = vb2_poll(&queue->queue, file, wait);
    // 释放互斥锁
    mutex_unlock(&queue->mutex);

    // 返回结果
    return ret;
}

unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)
{
    // 获取文件描述符对应的video_device结构体
    struct video_device *vfd = video_devdata(file);
    // 获取用户请求的事件
    unsigned long req_events = poll_requested_events(wait);
    // 初始化vb指针
    struct vb2_buffer *vb = NULL;
    // 初始化返回值
    unsigned int res = 0;
    // 初始化标志位
    unsigned long flags;

    // 如果驱动程序使用struct v4l2_fh结构体，则检查是否有挂起的事件
    if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
        struct v4l2_fh *fh = file->private_data;

        // 如果有挂起的事件，则返回POLLPRI
        if (v4l2_event_pending(fh))
            res = POLLPRI;
        // 如果用户请求的事件中包含POLLPRI，则等待事件
        else if (req_events & POLLPRI)
            poll_wait(file, &fh->wait, wait);
    }


    if (!V4L2_TYPE_IS_OUTPUT(q->type) && !(req_events & (POLLIN | POLLRDNORM)))
        return res;
    if (V4L2_TYPE_IS_OUTPUT(q->type) && !(req_events & (POLLOUT | POLLWRNORM)))
        return res;
    /*
     * 如果队列中没有缓冲区，且文件I/O模拟器未启动，则启动文件I/O模拟器。
     */
    if (q->num_buffers == 0 && !vb2_fileio_is_active(q)) {
        /*
         * 如果队列类型不是输出类型，且I/O模式为读，且用户请求的事件中包含POLLIN或POLLRDNORM，则启动文件I/O模拟器。
         */
        if (!V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_READ) &&
                (req_events & (POLLIN | POLLRDNORM))) {
            /*
             * 如果文件I/O模拟器初始化失败，则返回POLLERR。
             */
            if (__vb2_init_fileio(q, 1))
                return res | POLLERR;
        }
        /*
         * 如果队列类型是输出类型，且I/O模式为写，且用户请求的事件中包含POLLOUT或POLLWRNORM，则启动文件I/O模拟器。
         */
        if (V4L2_TYPE_IS_OUTPUT(q->type) && (q->io_modes & VB2_WRITE) &&
                (req_events & (POLLOUT | POLLWRNORM))) {
            /*
             * 如果文件I/O模拟器初始化失败，则返回POLLERR。
             */
            if (__vb2_init_fileio(q, 0))
                return res | POLLERR;
            /*
             * 对于输出队列，可以立即进行写操作。
             */
            return res | POLLOUT | POLLWRNORM;
        }
    }


    /*
     * 如果队列不在流式传输状态，或者错误标志被设置，则没有等待的内容。
     */
    if (!vb2_is_streaming(q) || q->error)
        return res | POLLERR;
    /*
     * 为了与vb1兼容：如果尚未调用QBUF，则返回POLLERR。这仅影响捕获队列，输出队列将始终将waiting_for_buffers初始化为false。
     */
    if (q->waiting_for_buffers)
        return res | POLLERR;


    /*
     * 对于输出流，只要排队的缓冲区少于可用的缓冲区，就可以写入。
     */
    if (V4L2_TYPE_IS_OUTPUT(q->type) && q->queued_count < q->num_buffers)
        return res | POLLOUT | POLLWRNORM;

    // 如果done_list为空，则等待
    if (list_empty(&q->done_list))
        poll_wait(file, &q->done_wq, wait);

    /*
     * 取出第一个可用于出队的缓冲区。
     */
    spin_lock_irqsave(&q->done_lock, flags);
    if (!list_empty(&q->done_list))
        vb = list_first_entry(&q->done_list, struct vb2_buffer,
                    done_entry);
    spin_unlock_irqrestore(&q->done_lock, flags);

    /*
     * 如果缓冲区存在且状态为VB2_BUF_STATE_DONE或VB2_BUF_STATE_ERROR，则返回POLLOUT | POLLWRNORM或POLLIN | POLLRDNORM。
     */
    if (vb && (vb->state == VB2_BUF_STATE_DONE
            || vb->state == VB2_BUF_STATE_ERROR)) {
        return (V4L2_TYPE_IS_OUTPUT(q->type)) ?
                res | POLLOUT | POLLWRNORM :
                res | POLLIN | POLLRDNORM;
    }
    return res;


}

// 从队列中取出缓冲区
static int uvc_ioctl_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;

    // 如果没有权限，返回错误
    if (!uvc_has_privileges(handle))
        return -EBUSY;

    // 从队列中取出缓冲区
    return uvc_dequeue_buffer(&stream->queue, buf,
                  file->f_flags & O_NONBLOCK);
}

// 从视频队列中取出一个缓冲区
int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
               int nonblocking)
{
    // 定义返回值
    int ret;

    // 获取互斥锁
    mutex_lock(&queue->mutex);
    // 调用vb2_dqbuf函数从视频队列中取出一个缓冲区
    ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
    // 释放互斥锁
    mutex_unlock(&queue->mutex);

    // 返回结果
    return ret;
}

int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
{
    // 如果文件IO正在进行，则返回忙
    if (vb2_fileio_is_active(q)) {
        dprintk(1, "file io in progress
"); // 打印信息
        return -EBUSY; // 返回忙
    }
    // 调用内部dqbuf函数
    return vb2_internal_dqbuf(q, b, nonblocking);
}

static int vb2_internal_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)
{
    struct vb2_buffer *vb = NULL;
    int ret;

    if (b->type != q->type) { // 如果缓冲区类型与队列类型不匹配
        dprintk(1, "invalid buffer type
"); // 打印错误信息
        return -EINVAL; // 返回无效参数错误
    }
    ret = __vb2_get_done_vb(q, &vb, b, nonblocking); // 获取已完成的缓冲区
    if (ret < 0) // 如果获取失败
        return ret; // 返回获取失败的错误码

    switch (vb->state) { // 根据缓冲区状态进行不同的操作
    case VB2_BUF_STATE_DONE: // 如果缓冲区状态为已完成
        dprintk(3, "returning done buffer
"); // 打印信息
        break;
    case VB2_BUF_STATE_ERROR: // 如果缓冲区状态为错误
        dprintk(3, "returning done buffer with errors
"); // 打印信息
        break;
    default: // 如果缓冲区状态无效
        dprintk(1, "invalid buffer state
"); // 打印错误信息
        return -EINVAL; // 返回无效参数错误
    }

    call_void_vb_qop(vb, buf_finish, vb); // 调用buf_finish回调

    /* 填充缓冲区信息以供用户空间使用 */
    __fill_v4l2_buffer(vb, b);
    /* 从videobuf队列中删除 */
    list_del(&vb->queued_entry);
    q->queued_count--;
    /* 回到已出队列状态 */
    __vb2_dqbuf(vb);

    dprintk(1, "dqbuf of buffer %d, with state %d
",
            vb->v4l2_buf.index, vb->state); // 打印信息

    return 0; // 返回成功
}

// 停止流
static int uvc_ioctl_streamoff(struct file *file, void *fh,
                   enum v4l2_buf_type type)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取流
    struct uvc_streaming *stream = handle->stream;

    // 如果没有权限，返回错误
    if (!uvc_has_privileges(handle))
        return -EBUSY;

    // 上锁
    mutex_lock(&stream->mutex);
    // 停止流
    uvc_queue_streamoff(&stream->queue, type);
    // 解锁
    mutex_unlock(&stream->mutex);

    return 0;
}

// uvc_queue_streamoff函数，用于停止视频流
int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
{
    int ret;

    // 获取互斥锁
    mutex_lock(&queue->mutex);
    // 调用vb2_streamoff函数停止视频流
    ret = vb2_streamoff(&queue->queue, type);
    // 释放互斥锁
    mutex_unlock(&queue->mutex);

    // 返回结果
    return ret;
}

int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
{
    // 如果文件IO正在进行中，则返回EBUSY
    if (vb2_fileio_is_active(q)) {
        dprintk(1, "file io in progress
");
        return -EBUSY;
    }
    // 调用vb2_internal_streamoff函数停止streaming
    return vb2_internal_streamoff(q, type);
}

static int vb2_internal_streamoff(struct vb2_queue *q, enum v4l2_buf_type type)
{
    // 如果type不等于当前队列的type，返回错误
    if (type != q->type) {
        dprintk(1, "invalid stream type
");
        return -EINVAL;
    }

    /*
     * Cancel will pause streaming and remove all buffers from the driver
     * and videobuf, effectively returning control over them to userspace.
     *
     * Note that we do this even if q->streaming == 0: if you prepare or
     * queue buffers, and then call streamoff without ever having called
     * streamon, you would still expect those buffers to be returned to
     * their normal dequeued state.
     */
    // 取消streaming并将所有缓冲区从驱动程序和videobuf中删除，将控制权返回给用户空间
    __vb2_queue_cancel(q);
    // 如果队列类型不是输出类型，则等待缓冲区
    q->waiting_for_buffers = !V4L2_TYPE_IS_OUTPUT(q->type);

    dprintk(3, "successful
");
    return 0;
}

uvc_ioctl_streamoffuvc_queue_streamoffvb2_streamoffvb2_internal_streamoff__vb2_queue_cancel

分析设置亮度过程：

uvc_ctrl_set
uvc_ctrl_commit
__uvc_ctrl_commit(video, 0);
uvc_ctrl_commit_entity(video->dev, entity, rollback);
ret = uvc_query_ctrl(dev  /* 哪一个USB设备 /, SET_CUR, ctrl->entity->id  / 哪一个unit/terminal /,dev->intfnum / 哪一个接口: VC interface */, ctrl->info->selector,
uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
ctrl->info->size);

static int uvc_ioctl_s_ctrl(struct file *file, void *fh,
                struct v4l2_control *ctrl)
{
    // 获取文件句柄
    struct uvc_fh *handle = fh;
    // 获取视频链
    struct uvc_video_chain *chain = handle->chain;
    // 定义一个v4l2_ext_control结构体
    struct v4l2_ext_control xctrl;
    // 定义返回值
    int ret;

    // 初始化xctrl结构体
    memset(&xctrl, 0, sizeof(xctrl));
    // 将ctrl结构体中的id和value赋值给xctrl结构体
    xctrl.id = ctrl->id;
    xctrl.value = ctrl->value;

    // 开始控制
    ret = uvc_ctrl_begin(chain);
    if (ret < 0)
        return ret;

    // 设置控制
    ret = uvc_ctrl_set(chain, &xctrl);
    if (ret < 0) {
        // 回滚控制
        uvc_ctrl_rollback(handle);
        return ret;
    }

    // 提交控制
    ret = uvc_ctrl_commit(handle, &xctrl, 1);
    if (ret < 0)
        return ret;

    // 将xctrl结构体中的value赋值给ctrl结构体
    ctrl->value = xctrl.value;
    return 0;
}

static int uvc_ctrl_commit_entity(struct uvc_device *dev,
    struct uvc_entity *entity, int rollback)
{
    // 如果entity为空，直接返回0
    if (entity == NULL)
        return 0;

    // 遍历entity的所有控制项
    for (unsigned int i = 0; i < entity->ncontrols; ++i) {
        // 获取控制项
        struct uvc_control *ctrl = &entity->controls[i];
        // 如果控制项未初始化，则跳过
        if (!ctrl->initialized)
            continue;

        /* Reset the loaded flag for auto-update controls that were
         * marked as loaded in uvc_ctrl_get/uvc_ctrl_set to prevent
         * uvc_ctrl_get from using the cached value, and for write-only
         * controls to prevent uvc_ctrl_set from setting bits not
         * explicitly set by the user.
         */
        // 如果控制项是自动更新或者不支持获取当前值，则将loaded标志位重置为0
        if (ctrl->info.flags & UVC_CTRL_FLAG_AUTO_UPDATE ||
            !(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
            ctrl->loaded = 0;

        // 如果控制项没有被修改，则跳过
        if (!ctrl->dirty)
            continue;

        // 如果不是回滚操作，则将控制项的当前值写入硬件
        if (!rollback)
            ret = uvc_query_ctrl(dev, UVC_SET_CUR, ctrl->entity->id,
                dev->intfnum, ctrl->info.selector,
                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                ctrl->info.size);
        else
            ret = 0;

        // 如果是回滚操作或者写入硬件失败，则将控制项的当前值重置为备份值
        if (rollback || ret < 0)
            memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
                   uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
                   ctrl->info.size);

        // 将控制项的dirty标志位重置为0
        ctrl->dirty = 0;

        // 如果写入硬件失败，则返回错误码
        if (ret < 0)
            return ret;
    }

    return 0;
}

ifret=uvc_query_ctrl,ctrl->info.size);elseret=0;

// 如果是回滚操作或者写入硬件失败，则将控制项的当前值重置为备份值
if (rollback || ret < 0)
    memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
           uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
           ctrl->info.size);

dev：哪一个USB设备ctrl->entity->id：哪一个，unit/terminaldev->intfnum：哪一个接口，VCinterface

ret = uvc_query_ctrl(dev  /* 哪一个USB设备 /, SET_CUR, ctrl->entity->id  / 哪一个unit/terminal /,dev->intfnum / 哪一个接口: VC interface */, ctrl->info->selector,
uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
ctrl->info->size);

文章为作者独立观点，不代表股票程序化软件自动交易接口观点

机构开通量化交易接口-量化论文学习之基于 CNNLSTM 混合模型的股价 预测

机构开通量化交易接口-量化论文学习之基于 CNNLSTM 混合模型的股价预测