Davinci VFPE的框架分析

 dm6446是基于Davinci架构设计的多媒体处理器。在这里我们分析的Linux源码是montavista的2.6.10的版本，该源码中使用的视频驱动架构为V4L2的框架。对这个框架而言，网上已经存在大量的分析，但涉及的内容主要都是框架层的封装以及相关应用层的解析，底层核心的内容很少会涉及。在这里，我将结合DM6446的视频处理前端VPFE中的CCDC模块，完成视频采集的驱动核心内容的解析，核心源码位于kernel/driver/media/video下面。

        依旧驱动模块的注册过程，视频采集的驱动模块主要分为：videodev_init（位于videodev_init.c），vpfe_init（位于davinci_vpfe.c），tvp5146_i2c_init（该模块在这里不做解析，是实现一款解码的芯片）。

videodev_init（位于videodev_init.c）模块解析

       该驱动模块下，主要是完成V4L2核心的驱动的注册。源码如下：

[html] view plain copy print ?

1. static int __init videodev_init(void)  
2. {  
3.     int ret;  
4.   
5.     printk(KERN_INFO "Linux video capture interface: v1.00\n");  
6.     if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {  //注册一个视频驱动，主设备号为81  
7.         printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);  
8.         return -EIO;  
9.     }  
10.   
11.     ret = class_register(&video_class);  
12.     if (ret < 0) {  
13.         unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);  
14.         printk(KERN_WARNING "video_dev: class_register failed\n");  
15.         return -EIO;  
16.     }  
17.   
18.     return 0;  
19. }  

static int __init videodev_init(void)
{
	int ret;

	printk(KERN_INFO "Linux video capture interface: v1.00\n");
	if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {  //注册一个视频驱动，主设备号为81
		printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
		return -EIO;
	}

	ret = class_register(&video_class);
	if (ret < 0) {
		unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
		printk(KERN_WARNING "video_dev: class_register failed\n");
		return -EIO;
	}

	return 0;
}

从代码的分析中我们看到，V4L2的架构中，先是注册一个主设备号为81的字符型设备，文件操作指针定义为video_fops。的确在上述的模块中完成的内容不多，这只是V4L2驱动的基本框架，可以再多平台之间移植。因此在这个框架下针对自己的处理器平台需要完成video_device的抽象设备和驱动的注册。也就是说V4L2下面可以注册进入很多的视频抽象设备。

           vpfe_init（位于davinci_vpfe.c)驱动模块中主要完成的内容就是完成video_device的注册，当然因为结合了专用的处理器平台在完成设备和驱动和注册的同时还需要完成相关硬件设备需求的初始化。

[plain] view plain copy print ?

1. static int vpfe_init(void)  
2. {  
3.     int i = 0;  
4.     int fbuf_size;  
5.     ccdc_frmfmt frame_format;  
6.     void *mem;  
7.     int ret = 0;  
8.   
9.     if (device_type == TVP5146) {  
10.         fbuf_size = VPFE_TVP5146_MAX_FBUF_SIZE;   //768*576*2  
11.         vpfe_device = vpfe_device_ycbcr;  
12.         frame_format = vpfe_device.ccdc_params_ycbcr.frm_fmt;  
13.     }  
14.   
15.     else if (device_type == MT9T001) {  
16.         fbuf_size = VPFE_MT9T001_MAX_FBUF_SIZE;  
17.         vpfe_device = vpfe_device_raw;  
18.         frame_format = vpfe_device.ccdc_params_raw.frm_fmt;  
19.     } else {  
20.         return -1;  
21.     }  
22.     /* allocate memory at initialization time to guarentee availability *///对默认的3路缓冲区进行内存的申请  
23.     for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {  //VPFE_DEFNUM_FBUFS=3  
24.         mem =  
25.             (void *)__get_free_pages(GFP_KERNEL | GFP_DMA,  
26.                          get_order(fbuf_size));  //需要的一帧内存大小为768*576*2  
27.         if (mem) {  
28.             unsigned long adr = (unsigned long)mem;  //获取32位的内存地址  
29.             u32 size = PAGE_SIZE << (get_order(fbuf_size));//get_order(fbuf_size)=8，PAGE_SIZE=4K，  
30.             while (size > 0) {  
31.                 /* make sure the frame buffers   
32.                    are never swapped out of memory */  
33.                 SetPageReserved(virt_to_page(adr));//对256页每页内存申请被保留，不被他人使用  
34.                 adr += PAGE_SIZE;  
35.                 size -= PAGE_SIZE;  
36.             }//获取每一个物理缓存区的首地址，地址存入fbuffers数组  
37.             vpfe_device.fbuffers[i] = (u8 *) mem;//3            
38.         } else {  
39.             while (--i >= 0) {  
40.                 free_reserved_pages((unsigned long)  
41.                             vpfe_device.  
42.                             fbuffers[i], fbuf_size);   
43.             }  
44.             printk(KERN_INFO  
45.                    "frame buffer memory allocation failed.\n");  
46.             return -ENOMEM;  
47.         }  
48.     }  
49.     if (driver_register(&vpfe_driver) != 0) {  
50.         printk(KERN_INFO "driver registration failed\n");  
51.         return -1;  
52.     }  
53.     if (platform_device_register(&_vpfe_device) != 0) {  
54.         driver_unregister(&vpfe_driver);  
55.         printk(KERN_INFO "device registration failed\n");  
56.         return -1;  
57.     }  
58.   
59.     ccdc_reset();  //CCDC复位不使能  
60.   
61.     if (device_type == TVP5146) {  
62.         ret = tvp5146_ctrl(TVP5146_INIT, NULL);    //decoder I2C驱动的初始化  
63.         if (ret >= 0) {  
64.             ret = tvp5146_ctrl(TVP5146_RESET, NULL);  
65.             /* configure the tvp5146 to default parameters */  
66.             ret |=  
67.                 tvp5146_ctrl(TVP5146_CONFIG,  
68.                      &vpfe_device.tvp5146_params);  //vpfe_device=vpfe_device_ycbcr  
69.         }  
70.         if (ret < 0) {  
71.             tvp5146_ctrl(TVP5146_CLEANUP, NULL);  
72.         }  
73.     } else if (device_type == MT9T001) {  
74.         /* enable video port in case of raw capture */  
75.         ccdc_enable_vport();  
76.         vpfe_device.config_dev_fxn = mt9t001_ctrl;  
77.         ret =  
78.             vpfe_device.config_dev_fxn(MT9T001_INIT,  
79.                            &vpfe_device.std,  
80.                            &vpfe_device.device_params);  
81.     }  
82.   
83.     if (ret < 0) {  
84.         platform_device_unregister(&_vpfe_device);  
85.         driver_unregister(&vpfe_driver);  
86.         /* Free memory for all image buffers */  
87.         for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {  
88.             free_reserved_pages((unsigned long)  
89.                         vpfe_device.fbuffers[i], fbuf_size);  
90.         }  
91.         return -1;  
92.     }  
93.   
94.     /* setup interrupt handling */  
95.     /* request VDINT1 if progressive format */   
96.     if (frame_format == CCDC_FRMFMT_PROGRESSIVE) {    //frame_format=CCDC_FRMFMT_INTERLACED=1  
97.         ret = request_irq(IRQ_VDINT1, vdint1_isr, SA_INTERRUPT,  
98.                   "dm644xv4l2", (void *)&vpfe_device); //逐行格式，申请VDINT1中断  
99.         if (ret < 0) {  
100.             platform_device_unregister(&_vpfe_device);  
101.             driver_unregister(&vpfe_driver);  
102.             /* Free memory for all image buffers */  
103.             for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {  
104.                 free_reserved_pages((unsigned long)  
105.                             vpfe_device.  
106.                             fbuffers[i], fbuf_size);  
107.             }  
108.             return -1;  
109.         }  
110.     }  
111.     ret = request_irq(IRQ_VDINT0, vpfe_isr, SA_INTERRUPT,  
112.               "dm644xv4l2", (void *)&vpfe_device);//申请VDINT0中断  
113.     if (ret < 0) {  
114.         platform_device_unregister(&_vpfe_device);  
115.         driver_unregister(&vpfe_driver);  
116.         /* Free memory for all image buffers */  
117.         for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {  
118.             free_reserved_pages((unsigned long)  
119.                         vpfe_device.fbuffers[i], fbuf_size);  
120.         }  
121.         free_irq(IRQ_VDINT1, &vpfe_device);  
122.         return -1;  
123.     }  
124.   
125.     printk(KERN_INFO "DaVinci v4l2 capture driver V1.0 loaded\n");  
126.     return 0;  
127. }  
128.   
129. /  

static int vpfe_init(void)
{
	int i = 0;
	int fbuf_size;
	ccdc_frmfmt frame_format;
	void *mem;
	int ret = 0;

	if (device_type == TVP5146) {
		fbuf_size = VPFE_TVP5146_MAX_FBUF_SIZE;   //768*576*2
		vpfe_device = vpfe_device_ycbcr;
		frame_format = vpfe_device.ccdc_params_ycbcr.frm_fmt;
	}

	else if (device_type == MT9T001) {
		fbuf_size = VPFE_MT9T001_MAX_FBUF_SIZE;
		vpfe_device = vpfe_device_raw;
		frame_format = vpfe_device.ccdc_params_raw.frm_fmt;
	} else {
		return -1;
	}
	/* allocate memory at initialization time to guarentee availability *///对默认的3路缓冲区进行内存的申请
	for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {  //VPFE_DEFNUM_FBUFS=3
		mem =
		    (void *)__get_free_pages(GFP_KERNEL | GFP_DMA,
					     get_order(fbuf_size));  //需要的一帧内存大小为768*576*2
		if (mem) {
			unsigned long adr = (unsigned long)mem;  //获取32位的内存地址
			u32 size = PAGE_SIZE << (get_order(fbuf_size));//get_order(fbuf_size)=8，PAGE_SIZE=4K，
			while (size > 0) {
				/* make sure the frame buffers 
				   are never swapped out of memory */
				SetPageReserved(virt_to_page(adr));//对256页每页内存申请被保留，不被他人使用
				adr += PAGE_SIZE;
				size -= PAGE_SIZE;
			}//获取每一个物理缓存区的首地址，地址存入fbuffers数组
			vpfe_device.fbuffers[i] = (u8 *) mem;//3          
		} else {
			while (--i >= 0) {
				free_reserved_pages((unsigned long)
						    vpfe_device.
						    fbuffers[i], fbuf_size); 
			}
			printk(KERN_INFO
			       "frame buffer memory allocation failed.\n");
			return -ENOMEM;
		}
	}
	if (driver_register(&vpfe_driver) != 0) {
		printk(KERN_INFO "driver registration failed\n");
		return -1;
	}
	if (platform_device_register(&_vpfe_device) != 0) {
		driver_unregister(&vpfe_driver);
		printk(KERN_INFO "device registration failed\n");
		return -1;
	}

	ccdc_reset();  //CCDC复位不使能

	if (device_type == TVP5146) {
		ret = tvp5146_ctrl(TVP5146_INIT, NULL);    //decoder I2C驱动的初始化
		if (ret >= 0) {
			ret = tvp5146_ctrl(TVP5146_RESET, NULL);
			/* configure the tvp5146 to default parameters */
			ret |=
			    tvp5146_ctrl(TVP5146_CONFIG,
					 &vpfe_device.tvp5146_params);  //vpfe_device=vpfe_device_ycbcr
		}
		if (ret < 0) {
			tvp5146_ctrl(TVP5146_CLEANUP, NULL);
		}
	} else if (device_type == MT9T001) {
		/* enable video port in case of raw capture */
		ccdc_enable_vport();
		vpfe_device.config_dev_fxn = mt9t001_ctrl;
		ret =
		    vpfe_device.config_dev_fxn(MT9T001_INIT,
					       &vpfe_device.std,
					       &vpfe_device.device_params);
	}

	if (ret < 0) {
		platform_device_unregister(&_vpfe_device);
		driver_unregister(&vpfe_driver);
		/* Free memory for all image buffers */
		for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {
			free_reserved_pages((unsigned long)
					    vpfe_device.fbuffers[i], fbuf_size);
		}
		return -1;
	}

	/* setup interrupt handling */
	/* request VDINT1 if progressive format */ 
	if (frame_format == CCDC_FRMFMT_PROGRESSIVE) {    //frame_format=CCDC_FRMFMT_INTERLACED=1
		ret = request_irq(IRQ_VDINT1, vdint1_isr, SA_INTERRUPT,
				  "dm644xv4l2", (void *)&vpfe_device); //逐行格式，申请VDINT1中断
		if (ret < 0) {
			platform_device_unregister(&_vpfe_device);
			driver_unregister(&vpfe_driver);
			/* Free memory for all image buffers */
			for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {
				free_reserved_pages((unsigned long)
						    vpfe_device.
						    fbuffers[i], fbuf_size);
			}
			return -1;
		}
	}
	ret = request_irq(IRQ_VDINT0, vpfe_isr, SA_INTERRUPT,
			  "dm644xv4l2", (void *)&vpfe_device);//申请VDINT0中断
	if (ret < 0) {
		platform_device_unregister(&_vpfe_device);
		driver_unregister(&vpfe_driver);
		/* Free memory for all image buffers */
		for (i = 0; i < VPFE_DEFNUM_FBUFS; i++) {
			free_reserved_pages((unsigned long)
					    vpfe_device.fbuffers[i], fbuf_size);
		}
		free_irq(IRQ_VDINT1, &vpfe_device);
		return -1;
	}

	printk(KERN_INFO "DaVinci v4l2 capture driver V1.0 loaded\n");
	return 0;
}

/

在这个初始化的内容中，我们看到做了很多的内容，这里的vpfe_device = vpfe_device_ycbcr;就是上面提到的video_device的实例，也就是DM6446的视频前端VPFE这个视频设备。同时可以发现，在这里进行了连续的内存页式缓存区的申请（主要用于后续的视频采集内存缓存区队列设置的相关内容），完成vpfe_device的初始化。随后通过基于平台设备进行了驱动和设备的注册。其实这个设备和驱动的注册，完全就是为了调用匹配以后的probe函数，进一步完成相关视频设备文件（主设备号为81，次设备号不一）节点的创建（相当于手动在终端完成mknod操作），只有这样才可以在应用层打开设备之后，才能经过系统调来调用主设备号81的文件操作指针video_fops。同时也完成了VPFE前端CCDC的中断申请。下面来看porbe的指针函数。

[plain] view plain copy print ?

1. static int __init vpfe_probe(struct device *device)   //传入参数_vpfe_device->dev  
2. {  
3.     struct video_device *vfd;  
4.     vpfe_obj *vpfe = &vpfe_device;       //vpfe_device=vpfe_device_ycbcr  
5.     vpfe_dev = device;            
6.     dev_dbg(vpfe_dev, "\nStarting of vpfe_probe...");  
7.     /* alloc video device */  
8.     if ((vfd = video_device_alloc()) == NULL) {  
9.         return -ENOMEM;  
10.     }  
11.     *vfd = vpfe_video_template;  //video_device的类型  
12.     vfd->dev = device;  
13.     vfd->release = video_device_release;  
14.     snprintf(vfd->name, sizeof(vfd->name),  
15.          "DM644X_VPFE_DRIVER_V%d.%d.%d",  
16.          (VPFE_VERSION_CODE >> 16) & 0xff,  
17.          (VPFE_VERSION_CODE >> 8) & 0xff, (VPFE_VERSION_CODE) & 0xff);  
18.   
19.     vpfe->video_dev = vfd; //vpfe_obj的实例vpfe_device获取video_device实例  
20.     vpfe->usrs = 0;  
21.     vpfe->io_usrs = 0;  
22.     vpfe->started = FALSE;  
23.     vpfe->latest_only = TRUE;  
24.   
25.     v4l2_prio_init(&vpfe->prio);  
26.     init_MUTEX(&vpfe->lock);  
27.   
28.     /* register video device */  
29.     dev_dbg(vpfe_dev, "trying to register vpfe device.\n");  
30.     dev_dbg(vpfe_dev, "vpfe=%x,vpfe->video_dev=%x\n", (int)vpfe,  
31.         (int)&vpfe->video_dev);  
32.     if (video_register_device(vpfe->video_dev, VFL_TYPE_GRABBER, -1) < 0) {  //完成视频设备vfd的注册  
33.         video_device_release(vpfe->video_dev);  
34.         vpfe->video_dev = NULL;  
35.         return -1;  
36.     }  
37.   
38.     dev_dbg(vpfe_dev, "DM644X vpfe: driver version V%d.%d.%d loaded\n",  
39.         (VPFE_VERSION_CODE >> 16) & 0xff,  
40.         (VPFE_VERSION_CODE >> 8) & 0xff, (VPFE_VERSION_CODE) & 0xff);  
41.   
42.     dev_dbg(vpfe_dev, "vpfe: registered device video%d\n",  
43.         vpfe->video_dev->minor & 0x1f);  
44.   
45.     /* all done */  
46.     return 0;  
47. }  

static int __init vpfe_probe(struct device *device)   //传入参数_vpfe_device->dev
{
	struct video_device *vfd;
	vpfe_obj *vpfe = &vpfe_device;       //vpfe_device=vpfe_device_ycbcr
	vpfe_dev = device;          
	dev_dbg(vpfe_dev, "\nStarting of vpfe_probe...");
	/* alloc video device */
	if ((vfd = video_device_alloc()) == NULL) {
		return -ENOMEM;
	}
	*vfd = vpfe_video_template;  //video_device的类型
	vfd->dev = device;
	vfd->release = video_device_release;
	snprintf(vfd->name, sizeof(vfd->name),
		 "DM644X_VPFE_DRIVER_V%d.%d.%d",
		 (VPFE_VERSION_CODE >> 16) & 0xff,
		 (VPFE_VERSION_CODE >> 8) & 0xff, (VPFE_VERSION_CODE) & 0xff);

	vpfe->video_dev = vfd; //vpfe_obj的实例vpfe_device获取video_device实例
	vpfe->usrs = 0;
	vpfe->io_usrs = 0;
	vpfe->started = FALSE;
	vpfe->latest_only = TRUE;

	v4l2_prio_init(&vpfe->prio);
	init_MUTEX(&vpfe->lock);

	/* register video device */
	dev_dbg(vpfe_dev, "trying to register vpfe device.\n");
	dev_dbg(vpfe_dev, "vpfe=%x,vpfe->video_dev=%x\n", (int)vpfe,
		(int)&vpfe->video_dev);
	if (video_register_device(vpfe->video_dev, VFL_TYPE_GRABBER, -1) < 0) {  //完成视频设备vfd的注册
		video_device_release(vpfe->video_dev);
		vpfe->video_dev = NULL;
		return -1;
	}

	dev_dbg(vpfe_dev, "DM644X vpfe: driver version V%d.%d.%d loaded\n",
		(VPFE_VERSION_CODE >> 16) & 0xff,
		(VPFE_VERSION_CODE >> 8) & 0xff, (VPFE_VERSION_CODE) & 0xff);

	dev_dbg(vpfe_dev, "vpfe: registered device video%d\n",
		vpfe->video_dev->minor & 0x1f);

	/* all done */
	return 0;
}

在这里我们可以看到调用video_register_device完成

[plain] view plain copy print ?

1. int video_register_device(struct video_device *vfd, int type, int nr)  
2. {  
3.     int i=0;  
4.     int base;  
5.     int end;  
6.     char *name_base;  
7.       
8.     switch(type)  
9.     {  
10.         case VFL_TYPE_GRABBER:  //明是一个图像采集设备?包括摄像头、调谐器  
11.             base=0;  
12.             end=64;  
13.             name_base = "video";   
14.             break;  
15.         case VFL_TYPE_VTX:        //代表视传设备  
16.             base=192;  
17.             end=224;  
18.             name_base = "vtx";  
19.             break;  
20.         case VFL_TYPE_VBI:        //代表的设备是从视频消隐的时间段取得信息的设备。  
21.             base=224;  
22.             end=240;  
23.             name_base = "vbi";     
24.             break;  
25.         case VFL_TYPE_RADIO:   //代表无线电设备  
26.             base=64;  
27.             end=128;  
28.             name_base = "radio";  
29.             break;  
30.         default:  
31.             return -1;  
32.     }  
33.   
34.     /* pick a minor number */  
35.     down(&videodev_lock);  
36.     if (nr >= 0  &&  nr < end-base) {  
37.         /* use the one the driver asked for */  
38.         i = base+nr;  
39.         if (NULL != video_device[i]) {  
40.             up(&videodev_lock);  
41.             return -ENFILE;  
42.         }  
43.     } else {  
44.         /* use first free */                //自动分配设备号，如果有当前全局的256个vide0_device为空  
45.         for(i=base;i<end;i++)  
46.             if (NULL == video_device[i])  
47.                 break;  
48.         if (i == end) {  
49.             up(&videodev_lock);  
50.             return -ENFILE;  
51.         }  
52.     }  
53.     video_device[i]=vfd;  
54.     vfd->minor=i;           //次设备号  
55.     up(&videodev_lock);  
56.   
57.     sprintf(vfd->devfs_name, "v4l/%s%d", name_base, i - base); //生成设备文件节点v4l/video0  
58.     devfs_mk_cdev(MKDEV(VIDEO_MAJOR, vfd->minor),  
59.             S_IFCHR | S_IRUSR | S_IWUSR, vfd->devfs_name);    //对当前设备在dev下自动创建设备文件节点  
60.     init_MUTEX(&vfd->lock);  
61.   
62.     /* sysfs class */  
63.         memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));  
64.     if (vfd->dev)  
65.         vfd->class_dev.dev = vfd->dev;  
66.     vfd->class_dev.class       = &video_class;  
67.     strlcpy(vfd->class_dev.class_id, vfd->devfs_name + 4, BUS_ID_SIZE);  
68.     class_device_register(&vfd->class_dev);  
69.     class_device_create_file(&vfd->class_dev,  
70.                  &class_device_attr_name);  
71.     class_device_create_file(&vfd->class_dev,  
72.                  &class_device_attr_dev);  
73.   
74. #if 1 /* needed until all drivers are fixed */  
75.     if (!vfd->release)  
76.         printk(KERN_WARNING "videodev: \"%s\" has no release callback. "  
77.                "Please fix your driver for proper sysfs support, see "  
78.                "http://lwn.net/Articles/36850/\n", vfd->name);  
79. #endif  
80.     return 0;  
81. }  

int video_register_device(struct video_device *vfd, int type, int nr)
{
	int i=0;
	int base;
	int end;
	char *name_base;
	
	switch(type)
	{
		case VFL_TYPE_GRABBER:  //明是一个图像采集设备?包括摄像头、调谐器
			base=0;
			end=64;
			name_base = "video"; 
			break;
		case VFL_TYPE_VTX:        //代表视传设备
			base=192;
			end=224;
			name_base = "vtx";
			break;
		case VFL_TYPE_VBI:        //代表的设备是从视频消隐的时间段取得信息的设备。
			base=224;
			end=240;
			name_base = "vbi";   
			break;
		case VFL_TYPE_RADIO:   //代表无线电设备
			base=64;
			end=128;
			name_base = "radio";
			break;
		default:
			return -1;
	}

	/* pick a minor number */
	down(&videodev_lock);
	if (nr >= 0  &&  nr < end-base) {
		/* use the one the driver asked for */
		i = base+nr;
		if (NULL != video_device[i]) {
			up(&videodev_lock);
			return -ENFILE;
		}
	} else {
		/* use first free */                //自动分配设备号，如果有当前全局的256个vide0_device为空
		for(i=base;i<end;i++)
			if (NULL == video_device[i])
				break;
		if (i == end) {
			up(&videodev_lock);
			return -ENFILE;
		}
	}
	video_device[i]=vfd;
	vfd->minor=i;           //次设备号
	up(&videodev_lock);

	sprintf(vfd->devfs_name, "v4l/%s%d", name_base, i - base); //生成设备文件节点v4l/video0
	devfs_mk_cdev(MKDEV(VIDEO_MAJOR, vfd->minor),
			S_IFCHR | S_IRUSR | S_IWUSR, vfd->devfs_name);    //对当前设备在dev下自动创建设备文件节点
	init_MUTEX(&vfd->lock);

	/* sysfs class */
        memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
	if (vfd->dev)
		vfd->class_dev.dev = vfd->dev;
	vfd->class_dev.class       = &video_class;
	strlcpy(vfd->class_dev.class_id, vfd->devfs_name + 4, BUS_ID_SIZE);
	class_device_register(&vfd->class_dev);
	class_device_create_file(&vfd->class_dev,
				 &class_device_attr_name);
	class_device_create_file(&vfd->class_dev,
				 &class_device_attr_dev);

#if 1 /* needed until all drivers are fixed */
	if (!vfd->release)
		printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
		       "Please fix your driver for proper sysfs support, see "
		       "http://lwn.net/Articles/36850/\n", vfd->name);
#endif
	return 0;
}

我们可以看到在这个视频设备注册的函数中，首先会判断你的设备是采集，传输还是其他用途，用于确定devfs_mk_cdev中的设备文件节点的名字。最终按其自动创建设备文件节点的方法，最终创建出/v4l/video0，/v4l/video1之类的设备节点，此类设备就如同mknod的手动功能，只是设备的次设备号不同，主设备号都为81。这样就符合一个驱动可以带多个设备。只是在设备open时，会首先根据次设备号来选择对应的设备，然后获取该设备的fops，进行后续的操作ioctl时，转向专用的设备（即我们自己的设备不再是之前注册的V4L2最上层的抽象设备）。

       后一博文，我将完成V4L2的ioctl的解析，这块内容是英语词典核心调用所在。在这部分内容里会涉及到对tvp5416的设置，CCDC的控制以及视频缓存区内存的管理等。