Linux USB 摄像头驱动

我会带着你远行 2022-06-04 09:20 462阅读 0赞

![20141116160858428][]

在 cortex-a8 中，可接入摄像头的接口通常可以分为两种， CAMERA 接口和 USB 接口的摄像头。这一章主要是介绍 USB 摄像头的设备驱动程序。在我们印象中，驱动程序都是一个萝卜一个坑，拿到一个硬件就需要去安装它相对应的驱动程序。有时候稍有不对还会导致电脑崩溃，是不是让人很郁闷？这一章我们讲 USB 摄像头设备驱动，那么是不是支持所有的 USB 摄像头驱动呢？带着这个疑问开始我们这一章的摄像头学习之旅吧。  
  
14. 1 确定 USB 摄像头支持 UVC （在 PC 上）

WEBEE 在某宝上搜索 USB 摄像头，发现了摄像头形状千奇百怪，那到底哪一种适合这一章我们学习呢？摄像头的市场并不仅仅只是针对我们这些程序猿，很多参数并不会在介绍页面上写出来，你去实体店上买，那些卖家很可能也不知道。所以在购买 USB 摄像头要认准这些参数哦，不然，按照这一章的教材，很可能答不到效果哦，那么可能就需要自己对我们的应用层的测试代码进行修改哦。

那什么 USB 摄像头适合我们这一章的教程呢，这里有几个关键字： 1.支持  
UVC（免驱）， 2.YUV 或者 MJPEG 格式输出。

在写这一章教程的时候， WEBEE 手头刚好有一个 USB 摄像头，想当年还是买电脑的时候送的，不知道现在能不能用上。那拿到摄像头，我们需要怎么做呢？  
  
14.1.1 把摄像头插入 PC 机的 USB 接口，查看 ID

注：如果你是在 Ubuntu 等 linux操作系统下请看 1~2，在 windows 下请直接看看 3 。1. 在 linux 类操作系统下插入 USB 摄像头，用 dmesg 打印信息

\#dmesg  
\[ 8705.813109\] uvcvideo: Found UVC 1.00 device USB2.0 UVC PC  
Camera (174f:5931)  
\[ 8705.867695\] uvcvideo: UVC non compliance - GET\_DEF(PROBE) not  
supported. Enabling workaround.  
\[ 8705.886554\] uvcvideo: Found UVC 1.00 device USB2.0 Camera  
(1e4e:0102)  
\[ 8705.888801\] uvcvideo: UVC non compliance - GET\_DEF(PROBE) not  
supported. Enabling workaround.  
\[8705.889829\] input: USB2.0 Camera as  
/devices/pci0000:00/0000:00:1a.7/usb1/1 -1/1 -1:1.0/input/input12  
\[ 8705.890440\] usbcore: registered new interface driver uvcvideo  
\[ 8705.890446\] USB Video Class driver (1.1.1)  
\[ 8827.856129\] pool\[5982\]: segfault at 0 ip (null) sp afabc0ec error 14 in  
gnome-screenshot\[8048000+12000\]

第一个 UVC 1.00 device USB2.0 UVC PC Camera 是笔记本自带的摄像头它的 VID:PID 是 174f:5931 ；第二个 UVC 1.00 device USB2.0 Camera 也就是我们插入的 USB 摄像头他的 VID:PID 是 1e4e:0102。这里的 ID 号可以在下一步 UVC 官方的文档中进一步确定是否被支持。

2. 用 ls /dev/video\* 查看设备节点  
![20141116161026428][]

这里的 video0 是笔记本自带的摄像头的设备节点， video1 才是我们刚接入的 USB 摄像头。

3. 在 windows 操作系统下插入 USB 摄像头插入，打开设备管理器  
![20141116161136296][]  
第一个 USB2.0 Camera 是我们接入的 USB 摄像头，第二个 USB2.0 UVCPC Camera 是笔记本自带的摄像头。

右键属性 -> 详细信息 –> 属性 选择硬件 ID 查看  
![20141116161147860][]  
可以得到插入的 USB 摄像头 VID:PID 为 1e4e： 0102 。 这里的 ID 号可以在下一步 UVC 官方的文档中进一步确定是否被支持。  
  
14. 1.2 确定 USB 摄像头种类

通过这个文档《摄像头驱动VID+PID 大全》 来确定芯片类型，这个文件在附带的文件夹下；通过这个网页 http://www.ideasonboard.org/uvc/ 来查看是否支持 UVC，这个网站是 USB Video Class Linux device driver 的主页，里面有 UVC 的详细的介绍。根据前面的打印信息，根据自己的 ID 号， WEBEE 这里是搜索 USB 摄像头的 VID 号： 1e4e 和 PID 号： 0102。

通过摄像头的 ID，可以看到该摄像头是否支持 UVC 和其他信息。绿勾代表支持。

![20141116161258715][]  
  
14.1.3 安装并使用 xawtv 测试 (Ubuntu 下)

1. 安装 xawtv 测试软件  
\#sudo apt-get install xawtv

2. 执行 xawtv 后面带 usb 摄像头的设备节点  
\#xawtv /dev/videoX  
  
![20141116161336888][]  
得到图像， PC 端测试结束。  
  
14. 2 移植到 WEBEE210 开发板

确定 USB 摄像头在 PC 上可以用之后，就需要让它在我们的开发板也能用上这个摄像头。但是接入我们之前板子上的 USB 接口，发现内核却没显示 PC机上打印的信息。

这是因为 UVC 是 Microsoft 与另外几家设备厂商联合推出的为 USB 视频捕获设备定义的协议标准，目前已成为 USB org 标准之一。如今的主流操作系统(如Windows XP SP2 and later, Linux 2.4.6 and later, MacOS 10.5 and later)都已提供 UVC 设备驱动，因此符合 UVC 规格的硬件设备在不需要安装任何的驱动程序下即可在主机中正常使用，这也是上面说的免驱的意思。使用 UVC 技术的包括摄像头、数码相机、类比影像转换器、电视棒及静态影像相机等设备。

但是之前在我们板子上的内核并没有把这个驱动包含进来，所以现在为了能在板子上运行，有两种方法， 1.重新配置内核，把 UVC 编进内核，并测试是否可以用 2.自己从零写这个驱动。

因为这个 usb 摄像头涉及到了很多东西，从零写起来比较复杂，字里行间很难让大家理解，所以这里先用第一种方法实现，在后面的章节会分析内核的这个驱动，你也可以明白这个驱动的来龙去脉，再加上你自己的代码阅读和悟性，相信你可以搞懂的。 -.-

注：如果你买的是 webee 配套的摄像头直接跳到 14.3 节

0. 好了，打开我们的内核目录  
  
注：这里的内核是基于移植好 OHCI 主控制器的内核，用之前的内核配置好也是不能用的，因为 usb 主控制器是会被用到的。 请务必先看第 10 章并移植好内核，该实验需要此基础上开发。（或者可以在文件夹下用我们配置好 ohci 的内核）

\#make menuconfig

1. 进入 USB support  
Device Drivers --->  
   \[\*\] USB support --->

如图配置：  
  
![20141116161516744][]  
  
2. 选中 Multimedia support

Device Drivers --->  
      <\*> Multimedia support --->

如图配置：  
  
![20141116161551423][]

3. 再进入 Media USB Adapters  
Device Drivers --->  
    <\*> Multimedia support --->  
         <\*>Media USB Adapters --->  
  
如图配置  
![20141116161720250][]  
  
注：如果你不想编译成模块，可以把 UVC 这一项改为\*，之后就不用 insmod 了  
  
4. 进入 V4L platform devices

Device Drivers --->

<\*> Multimedia support --->

<\*>V4L platform devices --->

如图配置

![20141116161746816][]

5. 编译内核

\#make uImage

6. 编译模块并拷贝下面三个 ko 文件到文件系统下

\#make modules  
\# cp ./drivers/media/v4l2-core/videobuf2-memops.ko /nfs/ko  
\# cp ./drivers/media/v4l2-core/videobuf2-vmalloc.ko /nfs/ko  
\#cp ./drivers/media/usb/uvc/uvcvideo.ko /nfs/ko

把生成的./arch/arm/boot/uImage 烧进开发板，重新启动，进行下一步。  
  
14.3 官方淘宝店上摄像头的配置  
![20141116161837282][]

如果你手头上和 Webee 一样有不知型号的摄像头，你可以按 14.2 节去试一下能不能用。但是如果你没有的话，强烈建议在我们官方的淘宝店购买 USB 摄像头， 也就是上面这一张图片， 之后按照这一节的教程，你是可以很顺利的完成这一章的实验。因为 Webee 已经用这个摄像头实验过了。而且这个摄像头还可以用在接下来第八部分的综合实验上哦。

这一节和上一节（ 14.2）差不多， 只是在内核配置中添加了适配这款摄像头的配置而已。 如果你买的不是 webee 的摄像头， 配置完 14.2 后可以跳过这一节 …

0. 打开我们的内核目录  
注：这里的内核也是基于移植好 OHCI 主控制器的内核，用之前的内核配置好也是不能用的，因为 usb 主控制器是会被用到的。 请务必先看第 10 章并移植好内核，该实验需要此基础上开发。（或者可以在文件夹下用我们配置好 ohci 的内核）

\#make menuconfig

1. 进入 USB support  
  
Device Drivers --->  
    \[\*\] USB support --->

如图配置：  
![20141116162032406][]

2. 选中 Multimedia support  
  
Device Drivers --->  
      <\*> Multimedia support --->

如图配置：  
![20141116162114171][]

3. 再进入 Media USB Adapters

Device Drivers --->  
     <\*> Multimedia support --->  
           <\*>Media USB Adapters --->

如图配置  
![20141116162135606][]

注：如果你不想编译成模块，可以把 UVC 这一项改为\*，之后就不用 insmod 了

4. 进入 GSPCA base webcams

Device Drivers --->  
   <\*> Multimedia support --->  
        <\*>Media USB Adapters --->  
            <\*>GSPCA base webcams

如图配置  
  
![20141116162234091][]

5. 进入 V4L platform devices

Device Drivers --->  
      <\*> Multimedia support --->  
            <\*>V4L platform devices --->

如图配置  
![20141116162320719][]

6. 编译内核

\#make uImage

7. 编译模块并拷贝下面三个 ko 文件到文件系统下

\#make modules  
\# cp ./drivers/media/v4l2-core/videobuf2-memops.ko /nfs/ko  
\# cp ./drivers/media/v4l2-core/videobuf2-vmalloc.ko /nfs/ko  
\#cp ./drivers/media/usb/uvc/uvcvideo.ko /nfs/ko

把生成的./arch/arm/boot/uImage 烧进开发板，重新启动，进行下一步。  
  
14. 4 在 WEBEE210 的 LCD 上显示 USB 摄像头图像

1. 重启开发板，加载模块。

\#cd ./ko  
\#insmod videobuf2-memops.ko  
\#insmod videobuf2-vmalloc.ko  
\#insmod uvcvideo.ko

出现如下信息  
![20141116162822218][]  
  
2．插入 USB 摄像头到 webee210 板子上，出现如下信息  
  
![20141116162935562][]

ls /dev/video\* ,如图出现 video0  
![20141116162953637][]

3. 执行 qt 测试程序这文件夹下有两个 qt 程序： qt\_camera\_yuv\_ts 和 qt\_camera\_mjpeg\_ts。先拷贝生成的 qt\_camera\_mjpeg\_ts 文件到 QT 文件系统下，再执行。

\# ./ qt\_camera\_mjpeg\_ts -qws

出现图像：  
  
![20141116163125265][]

这样，我们的 usb 摄像头实验现象就出来了。  
  
14. 5 QT 测试程序浅析

对于 qt 应用程序，除了做开启 v4l2 视频设备的一些初始化工作外，还要注意到一个编码转化的问题。 如果是 YUV 输出的话， 这里的转码是 YUV422 转RGB888， 如果是 MJPE 的话，则不需要这个函数。  
  
14.5.1 YUV 格式输出

VideoDevice \*vd;  
/\* 初始化一个 VideoDevice 设备 \*/  
void ProcessImage::paintEvent(QPaintEvent \*)  
\{  
/\*捕获图片\*/  
rs = vd->get\_frame((void \*\*)&p,&len);  
/\*将 yuv442 转为 rgb24 码\*/  
convert\_yuv\_to\_rgb\_buffer(p,pp,WIDTH,HEIGHT/\*QWidget::width(),QWidget::height()\*/);  
frame->loadFromData((uchar \*)pp,/\*len\*/WIDTH \* HEIGHT \* 3\*sizeof(char));  
/\*用 label 控件将图片显示于 LCD\*/  
label->setPixmap(QPixmap::fromImage(\*frame,Qt::AutoColor));  
// label->show();  
rs = vd->unget\_frame();  
// label->drawFrame();  
\}  
  
这里要科普一下 YUV 与 RGB 编码的相关知识。YUV 是编译 true-color 颜色空间（ color space）的种类， Y'UV, YUV, YCbCr，YPbPr 等专有名词都可以称为 YUV，彼此有重叠。“ Y”表示明亮度（ Luminance、Luma），“U”和“V”则是色度、浓度（ Chrominance、 Chroma）， Y'UV, YUV,YCbCr, YPbPr 常常有些混用的情况，其中 YUV 和 Y'UV 通常用来描述模拟信号，而相反的 YCbCr 与 YPbPr 则是用来描述数位的影像信号，例如在一些压缩格式内 MPEG、 JPEG 中，但在现今， YUV 通常已经在电脑系统上广泛使用。

RGB 颜色模型或红绿蓝颜色模型，是一种加色模型，将红（ Red）、绿（ Green）、蓝（ Blue）三原色的色光以不同的比例相加，以产生多种多样的色光。RGB24(or RGB888)每像素 24 位（比特 s per pixel， bpp）编码的 RGB 值：使用三个 8 位无符号整数（ 0 到 255）表示红色、绿色和蓝色的强度。这是当前主流的标准表示方法，用于真彩色和 JPEG 或者 TIFF 等图像文件格式里的通用颜色交换。它可以产生一千六百万种颜色组合，对人眼来说其中很多已经分辨不开。RGB32 模式实际就是 24 比特模式，余下的 8 比特不分配到象素中，这种模式是为了提高数据输送的速度（ 32 比特为一个 DWORD， DWORD 全称为 DoubleWord，一般而言一个 Word 为 16 比特或 2 个字节，处理器可直接对其运算而不需额外的转换）。同样在一些特殊情况下，如 DirectX、 OpenGL 等环境，余下的8 比特用来表示象素的透明度（ Alpha）。  
  
Uvc 摄像头一般的视频输出格式为 yuv 或 mjpg。 如果你的摄像头是 YUV 格式输出，但是我们的 LCD 显示屏幕是 RGB24 的显示模式，所以我们需要把 YUV格式的图像转为 RGB 格式才能在 LCD 上显示。

YUV 与 RGB 的转换有某种对应关系，所以可以通过算法进行转换。下面是一种 YUV 转 RGB 的算法：  
  
int ProcessImage::convert\_yuv\_to\_rgb\_buffer(unsigned char \*yuv, unsigned char \*rgb, unsigned int width, unsigned int height)  
\{  
unsigned int in, out = 0;  
unsigned int pixel\_16;  
unsigned char pixel\_24\[3\];  
unsigned int pixel32;  
int y0, u, y1, v;  
for(in = 0; in < width \* height \* 2; in += 4) \{  
pixel\_16 =  
yuv\[in + 3\] << 24 |  
yuv\[in + 2\] << 16 |  
yuv\[in + 1\] << 8 |  
yuv\[in + 0\];  
y0 = (pixel\_16 & 0x000000ff);  
u = (pixel\_16 & 0x0000ff00) >> 8;  
y1 = (pixel\_16 & 0x00ff0000) >> 16;  
v = (pixel\_16 & 0xff000000) >> 24;  
pixel32 = convert\_yuv\_to\_rgb\_pixel(y0, u, v);  
pixel\_24\[0\] = (pixel32 & 0x000000ff);  
pixel\_24\[1\] = (pixel32 & 0x0000ff00) >> 8;  
pixel\_24\[2\] = (pixel32 & 0x00ff0000) >> 16;  
rgb\[out++\] = pixel\_24\[0\];  
rgb\[out++\] = pixel\_24\[1\];  
rgb\[out++\] = pixel\_24\[2\];  
pixel32 = convert\_yuv\_to\_rgb\_pixel(y1, u, v);  
pixel\_24\[0\] = (pixel32 & 0x000000ff);  
pixel\_24\[1\] = (pixel32 & 0x0000ff00) >> 8;  
pixel\_24\[2\] = (pixel32 & 0x00ff0000) >> 16;  
rgb\[out++\] = pixel\_24\[0\];  
rgb\[out++\] = pixel\_24\[1\];  
rgb\[out++\] = pixel\_24\[2\];  
\}  
return 0;  
\}

int ProcessImage::convert\_yuv\_to\_rgb\_pixel(int y, int u, int v)  
\{  
unsigned int pixel32 = 0;  
unsigned char \*pixel = (unsigned char \*)&pixel32;  
int r, g, b;  
r = y + (1.370705 \* (v-128));  
g = y - (0.698001 \* (v-128)) - (0.337633 \* (u-128));  
b = y + (1.732446 \* (u-128));  
if(r > 255) r = 255;  
if(g > 255) g = 255;  
If(b > 255) b = 255;  
if(r < 0) r = 0;  
if(g < 0) g = 0;  
if(b < 0) b = 0;  
pixel\[0\] = r \* 220 / 256;  
pixel\[1\] = g \* 220 / 256;  
pixel\[2\] = b \* 220 / 256;  
return pixel32;  
\}  
  
这里的算法用到了浮点，所以运算起来比较慢，所以在 LCD 显示的时候会有卡顿现象。关于编码的高效率转化，有人多人在研究，包括硬解和软件。想要提供算法的效率，提供刷屏率，可以通过优化算法实现。  
  
14.5. 2 mjpeg 格式输出

VideoDevice \*vd;  
/\* 初始化一个 VideoDevice 设备 \*/  
void ProcessImage::paintEvent(QPaintEvent \*)  
\{  
/\*捕获图片\*/  
rs = vd->get\_frame((void \*\*)&p,&len);  
/\*不用转码\*/  
//convert\_yuv\_to\_rgb\_buffer(p,pp,WIDTH,HEIGHT/\*QWidget::width(),QWidget::height()\*/);  
/\*直接把捕获的数据传递进去\*/  
frame->loadFromData((uchar \*)p,/\*len\*/WIDTH \* HEIGHT \* 3\*sizeof(char));  
/\*用 label 控件将图片显示于 LCD\*/  
label->setPixmap(QPixmap::fromImage(\*frame,Qt::AutoColor));  
// label->show();  
rs = vd->unget\_frame();  
// label->drawFrame();  
\}  
  
14. 6 V4L2 架构浅析

14. 6.1 什么是 V4L2

V4L2 即 Video4Linux2，它是 Linux 内核中关于视频设备的内核驱动框架，为上层的访问底层的视频设备提供了统一的接口。凡是内核中的子系统都有抽象底层硬件的差异，为上层提供统一的接口和提取出公共代码避免代码冗余等好处。

V4L2 支持三类设备：视频输入输出设备、 VBI 设备和 radio 设备，分别会在/dev 目录下产生 videoX、 radioX 和 vbiX 设备节点。我们常见的视频输入设备主要是摄像头。 V4L2 在 Linux 系统中的架构如图 14.1 所示：  
  
![20141116163737578][]  
  
Linux 系统中视频输入设备主要包括以下四个部分：  
字符设备驱动程序核心： V4L2 本身就是一个字符设备，具有字符设备所有的特性，暴露接口给用户空间。  
V4L2 驱动核心： 主要是构建一个内核中标准视频设备驱动的框架，为视频操作提供统一的接口函数。  
平台 V4L2 设备驱动： 在 V4L2 框架下，根据平台自身的特性实现与平台相关的 V4L2 驱动部分，包括注册 video\_device 和 v4l2\_dev。  
具体的 sensor 驱动： 主要上电、提供工作时钟、视频图像裁剪、流 IO 开启等，实现各种设备控制方法供上层调用并注册 v4l2\_subdev。  
  
14. 6.2 定位 USB 摄像头驱动源码

在前面的测试中，发现插入 USB 摄像头后，会打印出下面这些信息：  
  
![20141116163803618][]  
  
认真学习的读者，应该对前面几行信息相当熟悉，这就是第十章讲过的 OHCI驱动和 hub.c 的相关知识，这里我们只关心如图上最后三行信息。。

使用 Source Insight打开内核工程，搜索” Found UVC”，搜索结果如图 14.2：  
  
![20141116163844959][]

点击进去，在\\drivers\\media\\usb\\uvc\\uvc\_driver.c 文件的第 1864 行：

uvc\_printk(KERN\_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\\n",

这看上去好像有点熟悉，没错，这就是内核输出信息的倒数第三行打印信息。

uvcvideo: Found UVC 1.00 device USB2.0 Camera (1e4e:0102)  
  
14. 6.3 USB 摄像头设备驱动(uvc\_driver.c)

前面说过 Webee 使用的摄像头是符合 UVC（免驱）和 YUV 格式输出。 这种摄像头相对没有那么复杂，非常适合初学者学习 USB 摄像头驱动。通过 14.5.2小节的分析知道 uvc\_driver.c 这个文件就是我们的 UVC 摄像头设备驱动了。

14. 6.3.1 入口函数

还是老样子，分析一个驱动，从它的入口函数开始：  
  
static int \_\_init uvc\_init(void)  
\{  
int ret;  
uvc\_debugfs\_init();  
ret = usb\_register(&uvc\_driver.driver);  
if (ret < 0) \{  
uvc\_debugfs\_cleanup();  
return ret;  
\}  
printk(KERN\_INFO DRIVER\_DESC " (" DRIVER\_VERSION ")\\n");  
return 0;  
\}

uvc\_init()函数主要通过 usb\_register(driver)宏来注册一个 usb\_driver，这个宏其实是调用了 usb\_register\_driver 函数。这与第十章的 10.4 小节的 USB 鼠标驱动的入口函数做的工作基本一致。

\#define usb\_register(driver) \\  
usb\_register\_driver(driver, THIS\_MODULE, KBUILD\_MODNAME)  
  
14. 6.3.2 uvc\_driver 实例

struct uvc\_driver uvc\_driver = \{  
.driver = \{  
.name = "uvcvideo",  
.probe = uvc\_probe,  
.disconnect = uvc\_disconnect,  
.suspend = uvc\_suspend,  
.resume = uvc\_resume,  
.reset\_resume = uvc\_reset\_resume,  
.id\_table = uvc\_ids,  
.supports\_autosuspend = 1,  
\},  
\};  
struct uvc\_driver \{  
struct usb\_driver driver;  
\};

当发现内核有与 uvc\_ids 匹配的 USB 摄像头就会调用 uvc\_probe 函数

static struct usb\_device\_id uvc\_ids\[\] = \{  
/\* LogiLink Wireless Webcam \*/  
\{ .match\_flags = USB\_DEVICE\_ID\_MATCH\_DEVICE  
| USB\_DEVICE\_ID\_MATCH\_INT\_INFO,  
.idVendor = 0x0416,  
.idProduct = 0xa91a,  
.bInterfaceClass = USB\_CLASS\_VIDEO,  
.bInterfaceSubClass = 1,  
.bInterfaceProtocol = 0,  
.driver\_info = UVC\_QUIRK\_PROBE\_MINMAX \},  
……  
/\* Generic USB Video Class \*/  
\{ USB\_INTERFACE\_INFO(USB\_CLASS\_VIDEO, 1, 0) \},  
\{\}  
\};

uvc\_ids 是 usb\_device\_id 类型的，在 usb 鼠标驱动的章节里也讲解过，具体怎么匹配，自己回去看看 10.4 小节的内容吧，这里不重复了，不是重点。  
  
14. 6.3.3 uvc\_probe 函数

当内核发现当前插入的 USB 摄像头被匹配后，最终就会调用 uvc\_probe 函数，下面是 uvc\_probe 函数的主体，为了方便分析主干，把不重要的省略掉。

/\* 参考： \\drivers\\media\\usb\\uvc\\Uvc\_driver.c \*/  
static int uvc\_probe(struct usb\_interface \*intf, const struct usb\_device\_id \*id)  
\{  
/\* 通过接口获取 usb\_device \*/  
struct usb\_device \*udev = interface\_to\_usbdev(intf);  
struct uvc\_device \*dev;  
/\* 为 uvc\_device 分配内存 \*/  
dev = kzalloc(sizeof \*dev, GFP\_KERNEL)  
/\* 初始化各种锁，初始化 uvc\_device 成员 ... \*/  
......  
/\* 初始化自旋锁、引用计数等 \*/  
if (v4l2\_device\_register(&intf->dev, &dev->vdev) < 0)  
goto error;  
/\* Initialize controls. \*/  
if (uvc\_ctrl\_init\_device(dev) < 0)  
goto error;  
/\* Scan the device for video chains. \*/  
if (uvc\_scan\_device(dev) < 0)  
goto error;  
/\* Register video device nodes. \*/  
if (uvc\_register\_chains(dev) < 0)  
goto error;  
......  
error:  
uvc\_unregister\_video(dev);  
return -ENODEV;  
\}  
  
14. 6.3.4 uvc\_register\_chains 函数

/\* 参考： \\drivers\\media\\usb\\uvc\\Uvc\_driver.c \*/  
static int uvc\_register\_chains(struct uvc\_device \*dev)  
\{  
struct uvc\_video\_chain \*chain;  
int ret;  
list\_for\_each\_entry(chain, &dev->chains, list) \{  
ret = uvc\_register\_terms(dev, chain);  
if (ret < 0)  
return ret;  
\}  
......  
return 0;  
\}

uvc\_register\_chains 函数遍历所有 chains 对链表上的每个 chain 都调用uvc\_register\_terms()函数。  
  
14. 6.3.5 uvc\_register\_terms 函数

/\* 参考： \\drivers\\media\\usb\\uvc\\Uvc\_driver.c \*/  
/\* Register all video devices in all chains. \*/  
static int uvc\_register\_terms(struct uvc\_device \*dev,  
struct uvc\_video\_chain \*chain)  
\{  
...  
uvc\_register\_video(dev, stream);  
...  
return 0;  
\}

uvc\_register\_terms()函数调用 uvc\_register\_video()，它是一个主体函数。  
  
14. 6.3.6 uvc\_register\_video 函数

static int uvc\_register\_video(struct uvc\_device \*dev, struct uvc\_streaming \*stream)  
\{  
struct video\_device \*vdev;  
/\* 初始化流接口 \*/  
uvc\_video\_init(stream);  
/\* 分配 video\_device 结构体 \*/  
video\_device\_alloc();  
/\* 设置 video\_device 的 v4l2\_device、 v4l2\_file\_operations 等成员 \*/  
vdev->v4l2\_dev = &dev->vdev;  
vdev->fops = &uvc\_fops; //后面再分析，暂且记住它  
vdev->release = uvc\_release;  
/\* 注册一个 video\_devices 结构体 \*/  
video\_register\_device(vdev, VFL\_TYPE\_GRABBER, -1);  
\}  
struct video\_device \*video\_device\_alloc(void)  
\{  
return kzalloc(sizeof(struct video\_device), GFP\_KERNEL);  
\}

uvc\_register\_video()函数主要做了三件事：

1. 分配 video\_device 结构体

2. 初始化 video\_device v4l2\_file\_operations 成员，里面包含各种函数指针，里面的 open、 read、 write、 ioctl 就是底层 USB 摄像头驱动的重点工作。

3. 注册一个 video\_devices 结构体  
  
14. 6.3.7 video\_register\_device 函数

/\* 参考： \\include\\media\\v4l2-dev.h \*/  
static inline int \_\_must\_check  
video\_register\_device(struct video\_device \*vdev,int type, int nr)  
\{  
return \_\_video\_register\_device(vdev, type, nr, 1, vdev->fops->owner);  
\}

video\_register\_device()函数又是通过调用 \_\_video\_register\_device()函数来实现的，它的实现位于\\drivers\\media\\v4l2-core\\v4l2-dev.c。从路径上可以看到，这属于 v4l2 核心的事了。对，没错，是 v4l2 核心本分工作。  
  
14. 6.4 V4L2 核心(v4l2-dev.c)

14. 6.4.1 \_\_video\_register\_device 函数

/\* 参考： \\drivers\\media\\v4l2-core\\v4l2-dev.c \*/  
/\* \_\_video\_register\_device:register video4linux devices \*/  
int \_\_video\_register\_device(struct video\_device \*vdev, int type, int nr,int warn\_if\_nr\_in\_use, struct module \*owner)  
\{  
...  
const char \*name\_base;  
...  
switch (type) \{  
case VFL\_TYPE\_GRABBER:  
name\_base = "video";  
break;  
case VFL\_TYPE\_VBI:  
name\_base = "vbi";  
break;  
...  
\}  
/\* 设置各种 ctrl 属性,用于用户程序 ioctl 设置摄像头属性 \*/  
if (vdev->ioctl\_ops)  
determine\_valid\_ioctls(vdev);  
/\* Part 3: Initialize the character device \*/  
vdev->cdev = cdev\_alloc();  
vdev->cdev->ops = &v4l2\_fops;  
vdev->cdev->owner = owner;  
ret = cdev\_add(vdev->cdev, MKDEV(VIDEO\_MAJOR, vdev->minor), 1);  
/\* Part 4: register the device with sysfs \*/  
...  
dev\_set\_name(&vdev->dev, "%s%d", name\_base, vdev->num);  
ret = device\_register(&vdev->dev);  
...  
/\* Part 6: Activate this minor. The char device can now be used. \*/  
...  
/\* 以次设备号为下标，将 video\_device 型 vdev 实例存到  
\* video\_device\[\]数组里，以供其他函数提取，如在 v4l2\_open  
\* 函数通过 video\_devdata(filp)提取 video\_device  
\*/  
video\_device\[vdev->minor\] = vdev;  
\}

\_\_video\_register\_device()函数首先根据 type 来确定设备节点，如何知道type 是什么呢？很简单，还记得 uvc\_register\_video()函数？里面就将 type 设置为 VFL\_TYPE\_GRABBER 了，所以我们的设备节点是/dev/vide0%d.

然后设置各种 ctrl 属性,用于用户程序 ioctl 设置摄像头属性，后面会分析如何调用到这里设置的 ctrl 属性。

其次创建了 VIDEO\_MAJOR = 81 ，即主设备号为 81 的字符设备，我们说过USB 摄像头驱动其实就是一个字符设备驱动，重点关注 v4l2\_fops 结构体。

最后将 video\_device 型 vdev 实例存到 video\_device\[\]数组里， 以供其他函数提取，如在 v4l2\_open 函数通过 video\_devdata(filp)提取 video\_device。  
  
14. 6.4.2 v4l2\_fops 实例

/\* 参考： \\drivers\\media\\v4l2-core\\v4l2-dev.c \*/  
static const struct file\_operations v4l2\_fops = \{  
.owner = THIS\_MODULE,  
.read = v4l2\_read,  
.write = v4l2\_write,  
.open = v4l2\_open,  
.get\_unmapped\_area = v4l2\_get\_unmapped\_area,  
.mmap = v4l2\_mmap,  
.unlocked\_ioctl = v4l2\_ioctl,  
...  
.release = v4l2\_release,  
.poll = v4l2\_poll,  
.llseek = no\_llseek,  
\};

v4l2\_fops 实例是一个 file\_operations 结构体型的，这不，又回到熟悉字符设备驱动的那套架构了吗？

14. 6.4.3 v4l2\_open 函数

当应用程序调用 open 函数，例如： open("/dev/video0",....)，首先就会调用到 v4l2 核心里的 open 函数，也就是 v4l2\_open 函数。我们来看看 v4l2\_open函数做了什么工作呢？  
  
static int v4l2\_open(struct inode \*inode, struct file \*filp)  
\{  
struct video\_device \*vdev;  
...  
/\* 根据次设备号从数组中得到 video\_device \*/  
vdev = video\_devdata(filp);  
...  
/\* 如果 vdev->fops->open 存在，并且 video\_device 已经注册，  
\* 就调用 vdev->fops->open(filp)函数，即调用到底层驱动的 open 方法  
\*/  
if (vdev->fops->open) \{  
if (video\_is\_registered(vdev))  
ret = vdev->fops->open(filp);  
else  
ret = -ENODEV;  
\}  
\}  
/\* 将\_\_video\_register\_device 函数里设置好的 video\_device\[\]返回 \*/  
struct video\_device \*video\_devdata(struct file \*file)  
\{  
return video\_device\[iminor(file->f\_path.dentry->d\_inode)\];  
\}

那这个 vdev->fops->open(filp)，将调用底层的驱动里的 open 方法，对于我们的 USB 摄像头驱动里的什么函数呢？  
  
14. 6.4.4 uvc\_v4l2\_open 函数

前面的答案就是， vdev->fops->open(filp)相当于调用 uvc\_v4l2\_open()函数。这个函数的实现在\\drivers\\media\\usb\\uvc\\uvc\_v4l2.c 里。

/\* ------------------------------------------------------------------------  
\* V4L2 file operations  
\*/  
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\\n");  
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;  
/\* Create the device handle. \*/  
handle = kzalloc(sizeof \*handle, GFP\_KERNEL);  
if (handle == NULL) \{  
usb\_autopm\_put\_interface(stream->dev->intf);  
return -ENOMEM;  
\}  
if (atomic\_inc\_return(&stream->dev->users) == 1) \{  
ret = uvc\_status\_start(stream->dev);  
if (ret < 0) \{  
usb\_autopm\_put\_interface(stream->dev->intf);  
atomic\_dec(&stream->dev->users);  
kfree(handle);  
return ret;  
\}  
\}  
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;  
\}

关于 USB 摄像头驱动里的 uvc\_v4l2\_open()函数， webee 就不再继续分析下去了，相对比较复杂，我们的目的是抓 V4L2 的框架，有兴趣的读者自己研究一下呗。  
  
14. 6.4.5 v4l2\_read 函数

static ssize\_t v4l2\_read(struct file \*filp, char \_\_user \*buf, size\_t sz, loff\_t \*off)  
\{  
struct video\_device \*vdev = video\_devdata(filp);  
...  
/\* 如果底层驱动的 read 方法不存在，则返回错误 \*/  
if (!vdev->fops->read)  
return -EINVAL;  
/\* 如果 video\_device 已经注册，则调用到底层驱动的 read 方法 \*/  
if (video\_is\_registered(vdev))  
ret = vdev->fops->read(filp, buf, sz, off);  
...  
\}

vdev->fops->read(filp, buf, sz, off)最后就相当于调用 uvc\_v4l2\_read()函数，这个函数也是在\\drivers\\media\\usb\\uvc\\uvc\_v4l2.c 文件里实现，我们不继续分析，有兴趣的读者自己研究研究哈。  
  
14. 6.4.6 v4l2\_ioctl 函数

static long v4l2\_ioctl(struct file \*filp, unsigned int cmd, unsigned long arg)  
\{  
struct video\_device \*vdev = video\_devdata(filp);  
...  
if (vdev->fops->unlocked\_ioctl) \{  
...  
if (video\_is\_registered(vdev))  
ret = vdev->fops->unlocked\_ioctl(filp, cmd, arg);  
\}  
else if (vdev->fops->ioctl) \{  
/\* Linux3.8 已经将 ioctl 改为 unlocked\_ioctl，  
\* 为了兼容低版本的内核所以存在 else 分支  
\*/  
...  
\}  
\}

同 样 地 ， vdev->fops->unlocked\_ioctl(filp, cmd, arg); 最 后 相 当 于 调 用uvc\_v4l2\_ioctl() 函 数 ， 它 又 调 用 video\_usercopy(file, cmd, arg,uvc\_v4l2\_do\_ioctl);函数， video\_usercopy()函数的作用从名字上可以猜测，它是根据用户空间传递过来的 cmd 命令，调用 uvc\_v4l2\_do\_ioctl()函数来解析 arg参数。  
  
14. 6.4.7 uvc\_v4l2\_do\_ioctl 函数

uvc\_v4l2\_do\_ioctl()函数是一个非常庞大的函数，有将近 600 行的代码，这里，我们只摘取部分代码。

static long uvc\_v4l2\_do\_ioctl(struct file \*file, unsigned int cmd, void \*arg)  
\{  
struct video\_device \*vdev = video\_devdata(file);  
struct uvc\_fh \*handle = file->private\_data;  
struct uvc\_video\_chain \*chain = handle->chain;  
struct uvc\_streaming \*stream = handle->stream;  
long ret = 0;  
switch (cmd) \{  
/\* Query capabilities \*/  
case VIDIOC\_QUERYCAP:  
\{  
struct v4l2\_capability \*cap = arg;  
memset(cap, 0, sizeof \*cap);  
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->version = LINUX\_VERSION\_CODE;  
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;  
break;  
\}  
case VIDIOC\_G\_PRIORITY:  
…  
case VIDIOC\_S\_PRIORITY:  
...  
case VIDIOC\_QUERYCTRL:  
…  
case VIDIOC\_G\_CTRL:  
…  
\}  
  
uvc\_v4l2\_do\_ioctl 根据应用程序传进来的 cmd 命令来判断要执行哪个switch 分 支 。 cmd 命 令 有 很 多 种 了 ， 这 里 随 便 列 举 几 种 ， 比 如 ：VIDIOC\_QUERYCAP、 VIDIOC\_G\_PRIORITY、 VIDIOC\_S\_PRIORITY 等等。那这些 cmd 是什么时候被设置的呢？

14. 6.4.8 ctrl 属性的函数调用流程  
  uvc\_probe  
       uvc\_register\_chains  
           uvc\_register\_terms  
               uvc\_register\_video  
                    video\_register\_device  
                          \_\_video\_register\_device  
                               determine\_valid\_ioctls  
  
14. 6.4.9 determine\_valid\_ioctls 函数

这些 ctrl 属性就是 USB 摄像头的各种属性，比如亮度的调节，打开、关闭STREAM 等等操作，这些是 v4l2 核心最最复杂的工作了，没有之一。

/\* 参考： \\drivers\\media\\v4l2-core\\v4l2-dev.c \*/  
static void determine\_valid\_ioctls(struct video\_device \*vdev)  
\{  
...  
SET\_VALID\_IOCTL(ops, VIDIOC\_QUERYCAP, vidioc\_querycap);  
SET\_VALID\_IOCTL(ops, VIDIOC\_REQBUFS, vidioc\_reqbufs);  
SET\_VALID\_IOCTL(ops, VIDIOC\_QUERYBUF, vidioc\_querybuf);  
SET\_VALID\_IOCTL(ops, VIDIOC\_QBUF, vidioc\_qbuf);  
SET\_VALID\_IOCTL(ops, VIDIOC\_EXPBUF, vidioc\_expbuf);  
SET\_VALID\_IOCTL(ops, VIDIOC\_DQBUF, vidioc\_dqbuf);  
SET\_VALID\_IOCTL(ops, VIDIOC\_STREAMON, vidioc\_streamon);  
SET\_VALID\_IOCTL(ops, VIDIOC\_STREAMOFF, vidioc\_streamoff);  
...  
\}

14. 7 本章小结

相信本章是很多读者最感兴趣的一章之一，本章首先动手移植了 USB 摄像头驱动到 webee210 开发板，成功显示在 7 寸 LCD 上，有木有高大上的感觉啊？其次分析了 qt 测试程序。最重点是 V4L2 架构的分析，主要包括符合 UVC 架构的 USB 摄像头设备驱动，还有 V4L2 核心的主要核心工作。限于时间和文章的篇幅， V4L2 架构的知识没有分析的太深，有机会以后再慢慢分析。

[20141116160858428]: /images/20220604/aa0b6864e4544b699f6c9b00499d7eec.png
[20141116161026428]: /images/20220604/724be56d00c148c990891a00fdd12f24.png
[20141116161136296]: /images/20220604/e3ded5eed51e416da678b7af8bca299b.png
[20141116161147860]: /images/20220604/db440b30eaa24090ab55cf142fb5f66e.png
[20141116161258715]: /images/20220604/511bd35da3424eeb95d89965ff65d54e.png
[20141116161336888]: /images/20220604/b9cd6cb55696403bbd323f2fae284a4d.png
[20141116161516744]: /images/20220604/03be636e41c64889b6c05eba7af1a02a.png
[20141116161551423]: /images/20220604/9713fe794750483ba2bca4a153e0f281.png
[20141116161720250]: /images/20220604/d10595d97bbf405ea5033560a043cd80.png
[20141116161746816]: /images/20220604/457ce7861c2b451883e990690b1c532c.png
[20141116161837282]: /images/20220604/d60c1a97934c448f88651a7d11d9f1a2.png
[20141116162032406]: /images/20220604/ae38a59022f34aa79610dd7bfc461b48.png
[20141116162114171]: /images/20220604/61e8620ff80e478980a3c98a571a2745.png
[20141116162135606]: /images/20220604/8bb39998698643078c9b229369564fae.png
[20141116162234091]: /images/20220604/58344d52d9274c18a17ffadee17a98ad.png
[20141116162320719]: /images/20220604/c358b07b1e194920be4a46e16c179e21.png
[20141116162822218]: /images/20220604/4d5de95b36f84b3288b9565c47b4cfd6.png
[20141116162935562]: /images/20220604/c59d453b21a948c49a99d3510ec1d743.png
[20141116162953637]: /images/20220604/d9d00e1bdd524b8dbfbd4ee4d29e280d.png
[20141116163125265]: /images/20220604/d827c0595b9641c79a8c9fb93a52ad86.png
[20141116163737578]: /images/20220604/823a5fca469740158705b7b35e9158fc.png
[20141116163803618]: /images/20220604/a6437a852587488598b4c8091a2d46d4.png
[20141116163844959]: /images/20220604/5206dfbfeab84b738776200bf52eba1a.png