3.2 vidioc_int_* 类函数的调用过程

最新推荐文章于 2024-03-02 16:58:50 发布
最新推荐文章于 2024-03-02 16:58:50 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： i.MX6-IPU子系统 文章标签： IPU NXP arm imx6 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanbixing123/article/details/52291502
版权

在《2.master和slave的匹配过程》中我们分析了master设备和slave设备的匹配过程，但是在操作过程中，如果想要获取slave设备的一些信息，该如何获得呢？你也许会说，只需要定义一个函数，去slave设备文件中获取即可，但是，如果一个驱动会支持好几个slave设备，那么对于不同的slave设备，驱动中都需要为它们定义一个功能相似的函数。如果是多master对应多slave设备的情况下，那么这些函数就需要在多个文件中定义多次，这种现象在内核中是肯定不会允许的。对于相似功能的函数，在驱动中只存在一个，而这个函数会根据不同的slave设备在不同的slave设备文件中转换成各自的子函数。所以，这里使用了Linux设备驱动框架设计中的分割的思想，提炼出一种通用的函数接口，在不同的slave设备中会转换成不同的底层调用函数，这些就是vidioc_int_*类函数调用。


首先以ov5640.c为例，回忆slave设备的注册过程：

module_i2c_driver(ov5640_i2c_driver); 
static struct i2c_driver ov5640_i2c_driver = { 
	.driver = { 
		  .owner = THIS_MODULE, 
		  .name  = "ov564x", 
		  }, 
	.probe  = ov5640_probe, 
	.remove = ov5640_remove, 
	.id_table = ov5640_id, 
};

调用ov5640_probe函数，在ov5640_probe函数中，首先会为structsensor_data ov5640_data设置初始值，然后通过ov5640_int_device.priv= &ov5640_data;

retval= v4l2_int_device_register(&ov5640_int_device);

在v4l2_int_device_register函数中，会在里面通过list_add将这个设备添加到int_list链表中，由于无论master还是slave设备都会调用到这个函数，所以这个int_list链表中会存在master和slave设备，然后根据不同的type类型来区分它们。之后在v4l2_int_device_register函数继续调用v4l2_int_device_try_attach_all()函数，会从int_list链表找到master设备和第一个没有设置master的slave设备，然后将这个slave设备的master设置成找到的master，并且调用master的attach函数完成匹配过程。

在v4l2_int_device_register函数注册的是ov5640_int_device结构体，这个结构体如下所示：

static struct v4l2_int_device ov5640_int_device = { 
	.module = THIS_MODULE, 
	.name = "ov564x", 
	.type = v4l2_int_type_slave, 
	.u = { 
		.slave = &ov5640_slave, 
	}, 
};

这个结构体里面u.slave变量是v4l2_int_slave类型的，如下所示：

static struct v4l2_int_slave ov5640_slave = { 
	.ioctls = ov5640_ioctl_desc, 
	.num_ioctls = ARRAY_SIZE(ov5640_ioctl_desc), 
};

同样继续追踪ov5640_ioctl_desc结构体：

static struct v4l2_int_ioctl_desc ov5640_ioctl_desc[] = { 
	{ vidioc_int_dev_init_num, 
	  (v4l2_int_ioctl_func *)ioctl_dev_init }, 
	{ vidioc_int_dev_exit_num, 
	  ioctl_dev_exit}, 
	{ vidioc_int_s_power_num, 
	  (v4l2_int_ioctl_func *)ioctl_s_power }, 
	{ vidioc_int_g_ifparm_num, 
	  (v4l2_int_ioctl_func *)ioctl_g_ifparm }, 
	{ vidioc_int_init_num, 
	  (v4l2_int_ioctl_func *)ioctl_init }, 
	{ vidioc_int_enum_fmt_cap_num, 
	  (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap }, 
	{ vidioc_int_g_fmt_cap_num, 
	  (v4l2_int_ioctl_func *)ioctl_g_fmt_cap }, 
	{ vidioc_int_g_parm_num, 
	  (v4l2_int_ioctl_func *)ioctl_g_parm }, 
	{ vidioc_int_s_parm_num, 
	  (v4l2_int_ioctl_func *)ioctl_s_parm }, 
	{ vidioc_int_g_ctrl_num, 
	  (v4l2_int_ioctl_func *)ioctl_g_ctrl }, 
	{ vidioc_int_s_ctrl_num, 
	  (v4l2_int_ioctl_func *)ioctl_s_ctrl }, 
	{ vidioc_int_enum_framesizes_num, 
	  (v4l2_int_ioctl_func *)ioctl_enum_framesizes }, 
	{ vidioc_int_enum_frameintervals_num, 
	  (v4l2_int_ioctl_func *)ioctl_enum_frameintervals }, 
	{ vidioc_int_g_chip_ident_num, 
	  (v4l2_int_ioctl_func *)ioctl_g_chip_ident }, 
};


这些ioctl函数是如何调用的？下面来分析这一个过程，在v4l2-int-device.h中有这样的定义：

enum v4l2_int_ioctl_num { 
	/* 
	 * 
	 * "Proper" V4L ioctls, as in struct video_device. 
	 * 
	 */ 
	vidioc_int_enum_fmt_cap_num = 1, 
	vidioc_int_g_fmt_cap_num, 
	vidioc_int_s_fmt_cap_num, 
	vidioc_int_try_fmt_cap_num, 
	vidioc_int_queryctrl_num, 
	vidioc_int_g_ctrl_num, 
	vidioc_int_s_ctrl_num, 
	vidioc_int_cropcap_num, 
	vidioc_int_g_crop_num, 
	vidioc_int_s_crop_num, 
	vidioc_int_g_parm_num, 
	vidioc_int_s_parm_num, 
	vidioc_int_querystd_num, 
	vidioc_int_s_std_num, 
	vidioc_int_s_video_routing_num, 

	..............
	/* 
	* Get slave private data, e.g. platform-specific slave 
	* configuration used by the master. 
	*/ 
	vidioc_int_g_priv_num, 
	/* Get slave interface parameters. */ 
	vidioc_int_g_ifparm_num, 
	/* Does the slave need to be reset after VIDIOC_DQBUF? */ 
	vidioc_int_g_needs_reset_num, 
	vidioc_int_enum_framesizes_num, 
	vidioc_int_enum_frameintervals_num, 
	 .................
	vidioc_int_priv_start_num = 2000, 
};
#define V4L2_INT_WRAPPER_1(name, arg_type, asterisk)			\ 
	static inline int vidioc_int_##name(struct v4l2_int_device *d,	\ 
					    arg_type asterisk arg)	\ 
	{								\ 
		return v4l2_int_ioctl_1(d, vidioc_int_##name##_num,	\ 
					(void *)(unsigned long)arg);	\ 
	}								\ 
									\ 
	static inline struct v4l2_int_ioctl_desc			\ 
	vidioc_int_##name##_cb(int (*func)				\ 
			       (struct v4l2_int_device *,		\ 
				arg_type asterisk))			\ 
	{								\ 
		struct v4l2_int_ioctl_desc desc;			\ 
									\ 
		desc.num = vidioc_int_##name##_num;			\ 
		desc.func = (v4l2_int_ioctl_func *)func;		\ 
									\ 
		return desc;						\ 
	} 

V4L2_INT_WRAPPER_1(enum_fmt_cap, struct v4l2_fmtdesc, *); 
V4L2_INT_WRAPPER_1(g_fmt_cap, struct v4l2_format, *); 
V4L2_INT_WRAPPER_1(s_fmt_cap, struct v4l2_format, *); 
V4L2_INT_WRAPPER_1(try_fmt_cap, struct v4l2_format, *); 
V4L2_INT_WRAPPER_1(queryctrl, struct v4l2_queryctrl, *); 
V4L2_INT_WRAPPER_1(g_ctrl, struct v4l2_control, *); 
V4L2_INT_WRAPPER_1(s_ctrl, struct v4l2_control, *); 
V4L2_INT_WRAPPER_1(cropcap, struct v4l2_cropcap, *); 
V4L2_INT_WRAPPER_1(g_crop, struct v4l2_crop, *); 
V4L2_INT_WRAPPER_1(s_crop, struct v4l2_crop, *); 
V4L2_INT_WRAPPER_1(g_parm, struct v4l2_streamparm, *); 
V4L2_INT_WRAPPER_1(s_parm, struct v4l2_streamparm, *); 
V4L2_INT_WRAPPER_1(querystd, v4l2_std_id, *); 
V4L2_INT_WRAPPER_1(s_std, v4l2_std_id, *); 
V4L2_INT_WRAPPER_1(s_video_routing, struct v4l2_routing, *); 

V4L2_INT_WRAPPER_0(dev_init); 
V4L2_INT_WRAPPER_0(dev_exit); 
V4L2_INT_WRAPPER_1(s_power, enum v4l2_power, /*dummy arg*/); 
V4L2_INT_WRAPPER_1(g_priv, void, *); 
V4L2_INT_WRAPPER_1(g_ifparm, struct v4l2_ifparm, *); 
V4L2_INT_WRAPPER_1(g_needs_reset, void, *); 
V4L2_INT_WRAPPER_1(enum_framesizes, struct v4l2_frmsizeenum, *); 
V4L2_INT_WRAPPER_1(enum_frameintervals, struct v4l2_frmivalenum, *); 

V4L2_INT_WRAPPER_0(reset); 
V4L2_INT_WRAPPER_0(init); 
V4L2_INT_WRAPPER_1(g_chip_ident, int, *);

上面这个宏定义中的##是连字符，相当于直接将##后面的字符连到##号之前的字符后面。这样做的目的是什么？

这种用法一般用在宏定义中，比如定义一个宏：

#defineAAAAA(name, type, num) xxxxx_##name(type, num)

如果在代码中使用到这个宏，编译器就会根据宏中不同的name字段来自动生成几个不同的函数。

#defineAAAAA(aaa, int, 1)

#defineAAAAA(bbb, int, 2)

#defineAAAAA(ccc, int, 3)

在编译的时候，就会生成：

xxxxx_aaa(int,1)

xxxxx_bbb(int,2)

xxxxx_ccc(int,3)


在后面用到的mxc_v4l2_capture.c中的open函数中，调用了vidioc_int_g_ifparm这样一个函数，我在内核源码中搜索都没有找到这个函数的定义，但是与vidioc_int...相关的头文件只有这个v4l2-int-device.h，所以仔细看这个头文件中，它采用一种gcc宏扩展的方式定义了一个宏V4L2_INT_WRAPPER_1，如上所示，就以这个vidioc_int_g_ifparm为例来说明：

V4L2_INT_WRAPPER_1(g_ifparm, struct v4l2_ifparm, *);

通过上面这个宏就相当于声明创建了两个内联函数：

static inline int vidioc_int_g_ifparm(struct v4l2_int_device *d,	\ 
					    arg_type asterisk arg)	\ 
	{								\ 
		return v4l2_int_ioctl_1(d, vidioc_int_g_ifparm_num,	\ 
					(void *)(unsigned long)arg);	\ 
	}								\ 
									\ 
	static inline struct v4l2_int_ioctl_desc			\ 
	vidioc_int_g_ifparm_cb(int (*func)				\ 
			       (struct v4l2_int_device *,		\ 
				arg_type asterisk))			\ 
	{								\ 
		struct v4l2_int_ioctl_desc desc;			\ 
									\ 
		desc.num = vidioc_int_g_ifparm_num;			\ 
		desc.func = (v4l2_int_ioctl_func *)func;		\ 
									\ 
		return desc;						\ 
	}

这样的话，当mxc_v4l2_capture.c中的open函数中调用vidioc_int_g_ifparm的话，就会调用到v4l2_int_ioctl_1函数，这个函数如下所示：

int v4l2_int_ioctl_1(struct v4l2_int_device *d, int cmd, void *arg) 
{ 
	return ((v4l2_int_ioctl_func_1 *) 
		find_ioctl(d->u.slave, cmd, 
			   (v4l2_int_ioctl_func *)no_such_ioctl_1))(d, arg); 
}

然后就转到find_ioctl函数里面，

static v4l2_int_ioctl_func *find_ioctl(struct v4l2_int_slave *slave, int cmd, 
				       v4l2_int_ioctl_func *no_such_ioctl) 
{ 
	const struct v4l2_int_ioctl_desc *first = slave->ioctls; 
	const struct v4l2_int_ioctl_desc *last = 
		first + slave->num_ioctls - 1; 

	while (first <= last) { 
		const struct v4l2_int_ioctl_desc *mid; 

		mid = (last - first) / 2 + first; 

		if (mid->num < cmd) 
			first = mid + 1; 
		else if (mid->num > cmd) 
			last = mid - 1; 
		else 
			return mid->func; 
/* 找到就返回具体的函数,具体的说这里的函数就是ov5640 slave定义的 ov5640_ioctl_desc 中的ioctl_g_ifparm 函数! */
	} 

	return no_such_ioctl; 
}

这个find_ioctl函数通过一个二分查找，根据vidioc_int_g_ifparm_num来找到具体的函数即ioctl_g_ifparm函数。

也就是说如果其他函数中有调用vidioc_int_g_ifparm的话，最终就会调用到ov5640.c中的

ioctl_g_ifparm函数。


同理，对于其他vidioc_int*类函数调用，最终都会根据不同的slave设备来对应找到vidioc_int_*_num函数，然后根据v4l2_int_ioctl_desc中的定义来找到对应的函数。


其他相似的函数比如：

vidioc_int_enum_fmt

vidioc_int_g_fmt

vidioc_int_g_ctrl

可以自己分析分析这几个函数的调用过程，就会对这种方式比较理解。


yanbixing123
关注
专栏目录
V4L2开发应用流程的各类超实用VIDIOC命令及其结构体集锦
Mark_minGE的博客
08-05 6378
本人作为初入音视频领域的新人，观摩了各位大佬关于V4L2详细开发流程的满满干货，特意为这两周的学习做个总结，希望后来者能顺利完成关于V4L2的第一个demo。这期内容主要内容为V4L2的各类实用VIDIOC命令调用， 各命令顺序总体上呈现的一个V4L2开发流程。 读前必看： 1. 在函数原型中出现的 int request , 其中request 参数即所属的VIDIOC命令。 ...
linux V4L2子系统——v4l2的结构体（4）之ioctl， my write
最新发布
小硕算法工程师
07-31 827
在应用程序获取视频数据的流程中，都是通过 ioctl 命令与驱动程序进行交互，结合实际需求，实现struct v4l2_ioctl_ops相关的成员即可。//源码：include/media/v4l2-ioctl.h/*** output* capture*//**/
/*通过简单的函数调用，来认识函数调用*/
等闲的博客
02-24 280
/*函数 引用*/ # include&lt;stdio.h&gt; int add(void); //函数声明 int main() { add(); //使用函数 printf("%d\n", add()); return 0; } //定义函数 int add(void) { return 1; };注意：在主函数中add（）；不能写成add (void)以及输出...
指针和引用（int*、int&、int*&、int&*、int**）
m1nt的博客
11-23 1947
C++ 指针C++ 引用[C++基础]019_指针和引用（int*、int&、int*&、int&、int*）
嵌入式Linux驱动——摄像头驱动之VIDIOC详解
FangsTun的博客
03-02 647
VIDIOC 是 Linux 内核中用于视频设备的 ioctl 命令集合。它提供了一系列操作，用于配置、控制和查询视频设备的功能。这些命令允许用户空间程序与视频设备进行交互，包括配置视频格式、请求内存缓冲区、启动/停止数据流等。
v4l2应用框架-摄像头v4l2编程(15)_出队VIDIOC_DQBUF
weixin_42581177的博客
08-29 3041
这里单独说一下:VIDIOC_QBUF和VIDIOC_DQBUF VIDIOC_QBUF /* 将空闲的内存加入可捕获视频的队列 VIDIOC_DQBUF /* 将已经捕获好视频的内存拉出已捕获视频的队列 *
v4l2 VIDIOC_QUERYBUF
02-06
v4l2中的VIDIOC_QUERYBUF用于查询缓存信息。下面是一个示例代码，展示了如何使用VIDIOC_QUERYBUF来查询缓存信息： ...最后，我们使用ioctl函数调用VIDIOC_QUERYBUF命令来查询缓存信息，并将结果存储在buf中。
int init_camera_attribute(int fd) { int numBufs; v4l2_std_id id; struct v4l2_format fmt; struct v4l2_requestbuffers req; struct v4l2_buffer buf; //检查当前视频设备支持的标准 ioctl(fd,VIDIOC_QUERYSTD,&id); //设置视频捕获格式 memset(&fmt,0,sizeof(fmt)); fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; fmt.fmt.pix.width = 640; fmt.fmt.pix.height = 480; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; // fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; if(ioctl(fd,VIDIOC_S_FMT,&fmt) == -1){ perror("set VIDIOC_S_FMT is fail"); exit(EXIT_FAILURE); } //分配内存 memset(&req,0,sizeof(req)); req.count = 4; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; if(ioctl(fd,VIDIOC_REQBUFS,&req) == -1){ perror("set VIDIOC_REQBUFS is fail"); exit(EXIT_FAILURE); } //获取并记录缓存的物理空间 buffers = calloc(req.count,sizeof(*buffers)); for(numBufs = 0; numBufs < req.count; numBufs ++){ memset(&buf,0,sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = numBufs; //读取缓存 if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1){ perror("set VIDIOC_REQBUFS is fail"); exit(EXIT_FAILURE); } // 转换成相对地址 buffers[numBufs].length = buf.length; buffers[numBufs].start = mmap(NULL,buf.length,PROT_READ|PROT_WRITE, MAP_SHARED,fd,buf.m.offset); if(buffers[numBufs].start == MAP_FAILED){ perror("mmap is fail"); exit(EXIT_FAILURE); } // 放入缓存队列 if(ioctl(fd,VIDIOC_QBUF,&buf) == -1){ perror("set VIDIOC_QBUF is fail"); exit(EXIT_FAILURE); } } return 0; }
06-12
首先通过ioctl函数调用VIDIOC_QUERYSTD查询当前相机设备支持的标准。然后通过ioctl和V4L2_BUF_TYPE_VIDEO_CAPTURE设置视频捕获格式，包括视频的分辨率和像素格式。接着调用ioctl和VIDIOC_REQBUFS分配内存，分配4个...
嵌入式-v4l2摄像头的工作流程及ioctl功能详解
mf_happying的博客
03-27 9587
一.摄像头的工作流程 1.打开设备文件int fd=open("/dev/video0",O_RDWR);2.取得设备的capability，看看设备具体支持哪些功能，比如是否具有视频的输入或者音频的输入等等ioctl(fd_v4l, VIDIOC_QUERYCAP, &cap) 3. 设置视频采集的参数： 设置视频的制式，制式包括PAL/NTSC，使用 ioctl(fd_v4l, VID
记一次 VIDIOC_REQBUFS failed 问题
ldl617的专栏
04-01 3150
最近更新了一个手里板子的sdk，在写应用测试vivi驱动的时候，出现了一个错误。 Reqbufs fail 这里比较奇怪，于是打算去分析一下原因。 static int vidioc_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *p) { struct vivi_dev *dev = video_drvdata(file); return vb2_reqbufs(&dev->vb_v
python中的特殊函数__init__()和__call__()
生命长跑
09-03 1333
在python中，__int__()函数的意义等同于类的构造器（同理，__del__()等同于类的析构函数）。因此，__init__()方法的作用是创建一个类的实例。 class Flower(object): def __init__(self,color): self.color = color print('color is', color) r...
Python面对对象之初始化方法（__int__方法）
Redhat_yan
06-09 3545
学习__int__方法
Python类中__int__和__str__的用法
楠奇湖畔的博客
04-27 2007
Python类中__int__和__str__的用法
python中self、__int__、__name的理解
pptde的博客
12-25 1927
在学习python的过程中，对于self 和__int__的理解有点晕，看程序的时候，有时有，有时又不用，所以今天就仔细的解决一下这个问题。 关于self，记住： python中self不是关键字，你可以换成任何其他的，但是这是该行业的习惯写法 定义类（class）的时候必须要用，一般的函数或者方法是不必用self的 self在定义的时候必须用，调用类的时候不需要用，默认自动传入 self指的是实例对象本身，而不是类本身 关于 int，记住： __init__方法的第一参数永远是self，表示创建的类
如何使用VIDIOC_DQBUF命令从V4L2设备读取一帧视频数据
我的博客
05-21 1301
该示例演示了如何使用VIDIOC_DQBUF命令在V4L2设备上读取一帧视频数据。程序先请求内核分配缓冲区，并将其映射到用户空间缓冲区中。然后，它启动视频流传输，并使用VIDIOC_DQBUF命令从输入队列中取出帧数据。在处理完帧数据之后，程序通过VIDIOC_QBUF命令重新提交该帧数据的缓冲区，并停止视频流传输。最后，为了清理资源，程序释放了用户空间的缓冲区映射并关闭了V4L2设备文件描述符。需要注意的是，该示例省略了对错误情况的处理，实际应用中需要根据情况添加适当的错误处理代码。
Python_Int
davidlee1214的博客
03-28 256
int型 　　用于计算。 　　十进制转化成二进制的有效位数。 1 0000 0001 2 0000 0010 3 0000 0011 ... ... 100 ？ 　　计算十进制转化成二进制的有效位数。（使用bit_length()方法） i = 100 print(i.bit_length()) ...
V4L2在VIDIOC_DQBUF处阻塞以及视频花屏残影问题
嵌入式与人工智能
11-08 2357
V4L2在VIDIOC_DQBUF处阻塞以及视频花屏残影问题V4L2在VIDIOC_DQBUF处阻塞以及视频花屏残影问题reference V4L2在VIDIOC_DQBUF处阻塞以及视频花屏残影问题 1.问题一：使用默认分辨率（640*480）打开视频出现花屏并阻塞问题： 程序在打开副头时出现花屏，同时在ioctl(fd, VIDIOC_DQBUF, &buffer)处阻塞住导致UI界面没有反应，调试时发现副头打开正常，可读取一帧数据后显示出来的却是不正常的图像，之后再次读取一帧数据时便会阻塞住，
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值