3.6 mxc_v4l_ioctl函数分析

下面分析mxc_v4l_ioctl函数：

static long mxc_v4l_ioctl(struct file *file, unsigned int cmd,  unsigned long arg) { pr_debug("In MVC:mxc_v4l_ioctl\n"); return video_usercopy(file, cmd, arg, mxc_v4l_do_ioctl); }

它通过调用video_usercopy函数，最终就调用到这个mxc_v4l_do_ioctl函数，这个mxc_v4l_do_ioctl函数内部包含一个switch语句，根据传入不同的ioctl宏来选择执行不同的语句。下面就按不同的宏来分析。

我们根据一般摄像头应用程序的执行调用过程来顺序分析。

1.VIDIOC_QUERYCAP宏

case VIDIOC_QUERYCAP: { struct v4l2_capability *cap = arg; pr_debug("   case VIDIOC_QUERYCAP\n"); strcpy(cap->driver, "mxc_v4l2"); cap->version = KERNEL_VERSION(0, 1, 11); cap-> = V4L2_CAP_VIDEO_CAPTURE |     V4L2_CAP_VIDEO_OVERLAY |     V4L2_CAP_STREAMING |     V4L2_CAP_READWRITE; cap->card[0] = '\0'; cap->bus_info[0] = '\0'; break; }

它的目的很简单，只是简单问问“你是谁?你能干什么?”基本就是驱动来填充应用程序传入的v4l2_capability结构体cap，设置其中的一些参数，然后应用程序就可以使用这些参数了。包括设置名字为”mxc_v4l2”，capabilities属性包括V4L2_CAP_VIDEO_CAPTURE，

V4L2_CAP_VIDEO_OVERLAY，V4L2_CAP_STREAMING，V4L2_CAP_READWRITE等等。

2.VIDIOC_S_INPUT宏

case VIDIOC_S_INPUT: { int *index = arg; pr_debug("   case VIDIOC_S_INPUT\n"); if (*index >= MXC_V4L2_CAPTURE_NUM_INPUTS) { retval = -EINVAL; break; } 

/*根据从从应用程序中传过来的arg参数来判断。MXC_V4L2_CAPTURE_NUM_INPUTS==2。*/

if (*index == cam->current_input) break; 

/*在init_camera_struct函数中将cam->current_input初始化为0了。如果要设置的input与当前input相同的话，就直接退出即可。*/

if ((mxc_capture_inputs[cam->current_input].status &     V4L2_IN_ST_NO_POWER) == 0) { retval = mxc_streamoff(cam); if (retval) break; mxc_capture_inputs[cam->current_input].status |= V4L2_IN_ST_NO_POWER; } 

/* mxc_capture_inputs[]这个数组如下所示：

static struct v4l2_input mxc_capture_inputs[MXC_V4L2_CAPTURE_NUM_INPUTS] = { {  .index = 0,  .name = "CSI IC MEM",  .type = V4L2_INPUT_TYPE_CAMERA,  .audioset = 0,  .tuner = 0,  .std = V4L2_STD_UNKNOWN,  .status = 0,  }, {  .index = 1,  .name = "CSI MEM",  .type = V4L2_INPUT_TYPE_CAMERA,  .audioset = 0,  .tuner = 0,  .std = V4L2_STD_UNKNOWN,  .status = V4L2_IN_ST_NO_POWER,  }, };

可以看出mxc_capture_inputs[0].status= 0，所以下面的语句不会执行。

*/

if (strcmp(mxc_capture_inputs[*index].name, "CSI MEM") == 0) { #if defined(CONFIG_MXC_IPU_CSI_ENC) || defined(CONFIG_MXC_IPU_CSI_ENC_MODULE) retval = csi_enc_select(cam); if (retval) break; #endif } else if (strcmp(mxc_capture_inputs[*index].name,   "CSI IC MEM") == 0) { #if defined(CONFIG_MXC_IPU_PRP_ENC) || defined(CONFIG_MXC_IPU_PRP_ENC_MODULE) retval = prp_enc_select(cam); if (retval) break; #endif } 

/*会根据mxc_capture_inputs[*index].name来选择执行哪一个函数，之前分析过，这两个函数都是去填充cam_data结构体中的几个函数指针。*/

mxc_capture_inputs[*index].status &= ~V4L2_IN_ST_NO_POWER; cam->current_input = *index; 

/*将mxc_capture_inputs[*index].status位清0，然后将cam->current_input指向当前的mxc_capture_inputs[*index]。*/

break; }

3. VIDIOC_CROPCAP宏

case VIDIOC_CROPCAP: { struct v4l2_cropcap *cap = arg; pr_debug("   case VIDIOC_CROPCAP\n"); if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&     cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) { retval = -EINVAL; break; } 

/*判断传入的v4l2_cropcap*cap中type是否是V4L2_BUF_TYPE_VIDEO_CAPTURE或V4L2_BUF_TYPE_VIDEO_OVERLAY，应用程序中设置成了V4L2_BUF_TYPE_VIDEO_CAPTURE。*/

cap->bounds = cam->crop_bounds; cap->defrect = cam->crop_defrect; 

/*将传入的v4l2_cropcap*cap中的bounds和defrect设置成cam->crop_bounds和cam->crop_defrect，这两个变量是在mxc_v4l_open函数中进行设置的。*/

break; }

4. VIDIOC_S_PARM宏

case VIDIOC_S_PARM:  { struct v4l2_streamparm *parm = arg; pr_debug("   case VIDIOC_S_PARM\n"); if (cam->sensor) retval = mxc_v4l2_s_param(cam, parm); else { pr_err("ERROR: v4l2 capture: slave not found!\n"); retval = -ENODEV; } break; }

这个函数跳转到mxc_v4l2_s_param中去执行了。

static int mxc_v4l2_s_param(cam_data *cam, struct v4l2_streamparm *parm) { struct v4l2_ifparm ifparm; struct v4l2_format cam_fmt; struct v4l2_streamparm currentparm; ipu_csi_signal_cfg_t csi_param; u32 current_fps, parm_fps; int err = 0; pr_debug("In mxc_v4l2_s_param\n"); if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { pr_err(KERN_ERR "mxc_v4l2_s_param invalid type\n"); return -EINVAL; } 

/*判断传入的参数parm->type是否为V4L2_BUF_TYPE_VIDEO_CAPTURE，所以肯定需要在应用程序中设置这一项。*/

/* Stop the viewfinder */ if (cam->overlay_on == true) stop_preview(cam); 

/*这一项在init_camera_struct函数初始化的时候设置为了false。*/

currentparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* First check that this device can support the changes requested. */ err = vidioc_int_g_parm(cam->sensor, ¤tparm); if (err) { pr_err("%s: vidioc_int_g_parm returned an error %d\n", __func__, err); goto exit; } 

/*vidioc_int_g_parm函数，以ov5640.c为例，它最终会调用到里面的ioctl_g_parm函数。

static int ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a) { struct sensor_data *sensor = s->priv; struct v4l2_captureparm *cparm = &a->parm.capture; int ret = 0; switch (a->type) { /* This is the only case currently handled. */ case V4L2_BUF_TYPE_VIDEO_CAPTURE: memset(a, 0, sizeof(*a)); a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; cparm->capability = sensor->streamcap.capability; cparm->timeperframe = sensor->streamcap.timeperframe; cparm->capturemode = sensor->streamcap.capturemode; ret = 0; break; /* These are all the possible cases. */ case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OVERLAY: case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_OUTPUT: case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: ret = -EINVAL; break; default: pr_debug("   type is unknown - %d\n", a->type); ret = -EINVAL; break; } return ret; }

看这个函数，它最终的目的是根据cam->sensor->priv里面的值来设置currentparm->parm.capture结构体，而这个currentparm就是获取到的当前sensor的parm参数。

*/

current_fps = currentparm.parm.capture.timeperframe.denominator / currentparm.parm.capture.timeperframe.numerator; parm_fps = parm->parm.capture.timeperframe.denominator / parm->parm.capture.timeperframe.numerator; 

/*设置current_fps和parm_fps这两个值，current_fps是当前每秒传输帧数，parm_fps是参数中设置的每秒传输帧数。*/

pr_debug("   Current capabilities are %x\n", currentparm.parm.capture.capability); pr_debug("   Current capturemode is %d  change to %d\n", currentparm.parm.capture.capturemode, parm->parm.capture.capturemode); pr_debug("   Current framerate is %d  change to %d\n", current_fps, parm_fps); /* This will change any camera settings needed. */ err = vidioc_int_s_parm(cam->sensor, parm); if (err) { pr_err("%s: vidioc_int_s_parm returned an error %d\n", __func__, err); goto exit; } 

/*这个vidioc_int_s_parm函数最终会调用到ov5640.c中的ioctl_s_parm函数。它如下所示：

static int ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a) { struct sensor_data *sensor = s->priv; struct v4l2_fract *timeperframe = &a->parm.capture.timeperframe; u32 tgt_fps;/* target frames per secound */ enum ov5640_frame_rate frame_rate; int ret = 0; /* Make sure power on */ ov5640_power_down(0); switch (a->type) { /* This is the only case currently handled. */ case V4L2_BUF_TYPE_VIDEO_CAPTURE: /* Check that the new frame rate is allowed. */ if ((timeperframe->numerator == 0) ||     (timeperframe->denominator == 0)) { timeperframe->denominator = DEFAULT_FPS; timeperframe->numerator = 1; } tgt_fps = timeperframe->denominator /   timeperframe->numerator; if (tgt_fps > MAX_FPS) { timeperframe->denominator = MAX_FPS; timeperframe->numerator = 1; } else if (tgt_fps < MIN_FPS) { timeperframe->denominator = MIN_FPS; timeperframe->numerator = 1; } /* Actual frame rate we use */ tgt_fps = timeperframe->denominator /   timeperframe->numerator; if (tgt_fps == 15) frame_rate = ov5640_15_fps; else if (tgt_fps == 30) frame_rate = ov5640_30_fps; else { pr_err(" The camera frame rate is not supported!\n"); return -EINVAL; } ret = ov5640_change_mode(frame_rate, a->parm.capture.capturemode); if (ret < 0) return ret; sensor->streamcap.timeperframe = *timeperframe; sensor->streamcap.capturemode = a->parm.capture.capturemode; break; /* These are all the possible cases. */ case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OVERLAY: case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_OUTPUT: case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: pr_debug("   type is not " \ "V4L2_BUF_TYPE_VIDEO_CAPTURE but %d\n", a->type); ret = -EINVAL; break; default: pr_debug("   type is unknown - %d\n", a->type); ret = -EINVAL; break; } return ret; }

这个函数首先判断应用程序中传进来的timeperframe->numerator和timeperframe->denominator两个参数，然后计算出tgt_fps。最后通过ov5640_change_mode函数来设置ov5640摄像头里面的寄存器的值，因为应用程序想要设置的是帧率等信息，这些信息会通过V4L2框架设置到摄像头里面，因为真正采集数据的是摄像头。

*/

/*综上来看，mxc_v4l2_s_param通过vidioc_int_g_parm和vidioc_int_s_parm两个函数，来获取sensor的parm设置，然后修改它。*/

/* If resolution changed, need to re-program the CSI */ /* Get new values. */ vidioc_int_g_ifparm(cam->sensor, &ifparm); 

/*通过上面的函数，已经将摄像头里面的信息修改了，但是应用程序还不知道，在这里调用vidioc_int_g_ifparm函数来获取ifparm的信息，然后告诉应用程序。如果分辨率改变的话需要重新修改CSI参数。调用vidioc_int_g_ifparm来获取sensor的ifparm参数。*/

csi_param.data_width = 0; csi_param.clk_mode = 0; csi_param.ext_vsync = 0; csi_param.Vsync_pol = 0; csi_param.Hsync_pol = 0; csi_param.pixclk_pol = 0; csi_param.data_pol = 0; csi_param.sens_clksrc = 0; csi_param.pack_tight = 0; csi_param.force_eof = 0; csi_param.data_en_pol = 0; csi_param.data_fmt = 0; csi_param.csi = cam->csi; csi_param.mclk = 0; pr_debug("   clock_curr=mclk=%d\n", ifparm.u.bt656.clock_curr); if (ifparm.u.bt656.clock_curr == 0) csi_param.clk_mode = IPU_CSI_CLK_MODE_CCIR656_INTERLACED; else csi_param.clk_mode = IPU_CSI_CLK_MODE_GATED_CLK;  csi_param.pixclk_pol = ifparm.u.bt656.latch_clk_inv; if (ifparm.u.bt656.mode == V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT) { csi_param.data_width = IPU_CSI_DATA_WIDTH_8; } else if (ifparm.u.bt656.mode == V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT) { csi_param.data_width = IPU_CSI_DATA_WIDTH_10; } else { csi_param.data_width = IPU_CSI_DATA_WIDTH_8; } csi_param.Vsync_pol = ifparm.u.bt656.nobt_vs_inv; csi_param.Hsync_pol = ifparm.u.bt656.nobt_hs_inv; csi_param.ext_vsync = ifparm.u.bt656.bt_sync_correct; /* 设置csi_param的一些参数。 *//* if the capturemode changed, the size bounds will have changed. */ cam_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; vidioc_int_g_fmt_cap(cam->sensor, &cam_fmt); pr_debug("   g_fmt_cap returns widthxheight of input as %d x %d\n", cam_fmt.fmt.pix.width, cam_fmt.fmt.pix.height); /* 通过vidioc_int_g_fmt_cap函数调用到ov5640.c中的ioctl_g_fmt_cap函数，如下：static int ioctl_g_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f) { struct sensor_data *sensor = s->priv; f->fmt.pix = sensor->pix; return 0; }它获取了根据cam->sensor->priv来获取cam_fmt参数，保存在cam_fmt->fmt.pix中。 */csi_param.data_fmt = cam_fmt.fmt.pix.pixelformat; cam->crop_bounds.top = cam->crop_bounds.left = 0; cam->crop_bounds.width = cam_fmt.fmt.pix.width; cam->crop_bounds.height = cam_fmt.fmt.pix.height; /* 根据获得的cam_fmt参数继续设置csi_param的参数和cam->crop_bounds参数。 *//*  * Set the default current cropped resolution to be the same with  * the cropping boundary(except for tvin module).  */ if (cam->device_type != 1) { cam->crop_current.width = cam->crop_bounds.width; cam->crop_current.height = cam->crop_bounds.height; } /* This essentially loses the data at the left and bottom of the image  * giving a digital zoom image, if crop_current is less than the full  * size of the image. */ ipu_csi_set_window_size(cam->ipu, cam->crop_current.width, cam->crop_current.height, cam->csi); ipu_csi_set_window_pos(cam->ipu, cam->crop_current.left,        cam->crop_current.top,        cam->csi); ipu_csi_init_interface(cam->ipu, cam->crop_bounds.width,        cam->crop_bounds.height,        cam_fmt.fmt.pix.pixelformat, csi_param);  exit: if (cam->overlay_on == true) start_preview(cam); return err; }

/*最后调用ipu_csi_set_window_size和ipu_csi_set_window_pos重新设置窗口的大小和位置，这两个函数都在mxc_v4l_open函数中分析了，在这就不再分析。然后继续调用ipu_csi_init_interface函数来设置底层的寄存器的值。*/

5.VIDIOC_S_FMT宏

case VIDIOC_S_FMT: { struct v4l2_format *sf = arg; pr_debug("   case VIDIOC_S_FMT\n"); retval = mxc_v4l2_s_fmt(cam, sf); break; }

它跳转到mxc_v4l2_s_fmt函数中去执行：

static int mxc_v4l2_s_fmt(cam_data *cam, struct v4l2_format *f) { int retval = 0; int size = 0; int bytesperline = 0; int *width, *height; pr_debug("In MVC: mxc_v4l2_s_fmt\n"); switch (f->type) {  //应用程序传进来的是V4L2_BUF_TYPE_VIDEO_CAPTUR。case V4L2_BUF_TYPE_VIDEO_CAPTURE: pr_debug("   type=V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); if (!valid_mode(f->fmt.pix.pixelformat)) { pr_err("ERROR: v4l2 capture: mxc_v4l2_s_fmt: format "        "not supported\n"); return -EINVAL; } /*  * Force the capture window resolution to be crop bounds  * for CSI MEM input mode.  */ if (strcmp(mxc_capture_inputs[cam->current_input].name,    "CSI MEM") == 0) { f->fmt.pix.width = cam->crop_current.width; f->fmt.pix.height = cam->crop_current.height; } /* 设置 fmt.pix.width和 fmt.pix.height， cam->crop_current.width和 cam->crop_current.height这两个参数是在上一个ioctl（VIDIOC_S_PARM）调用中赋值的。 */if (cam->rotation >= IPU_ROTATE_90_RIGHT) { height = &f->fmt.pix.width; width = &f->fmt.pix.height; } else { width = &f->fmt.pix.width; height = &f->fmt.pix.height; } /* 根据 cam->rotation参数决定是否反转图像的宽度和高度。 *//* stride line limitation */ *width -= *width % 8; *height -= *height % 8; /* 宽度和高度都像8取整，这是对宽度和高度进行一些微调。 */if (*width == 0 || *height == 0) { pr_err("ERROR: v4l2 capture: width or height" " too small.\n"); return -EINVAL; } if ((cam->crop_current.width / *width > 8) ||     ((cam->crop_current.width / *width == 8) &&      (cam->crop_current.width % *width))) { *width = cam->crop_current.width / 8; if (*width % 8) *width += 8 - *width % 8; pr_err("ERROR: v4l2 capture: width exceeds limit " "resize to %d.\n",        *width); } if ((cam->crop_current.height / *height > 8) ||     ((cam->crop_current.height / *height == 8) &&      (cam->crop_current.height % *height))) { *height = cam->crop_current.height / 8; if (*height % 8) *height += 8 - *height % 8; pr_err("ERROR: v4l2 capture: height exceeds limit "        "resize to %d.\n",        *height); } /* 上面这两个判断应该是在反转的情况下调整宽度和高度的大小。 */switch (f->fmt.pix.pixelformat) { case V4L2_PIX_FMT_RGB565: size = f->fmt.pix.width * f->fmt.pix.height * 2; bytesperline = f->fmt.pix.width * 2; break; case V4L2_PIX_FMT_BGR24: size = f->fmt.pix.width * f->fmt.pix.height * 3; bytesperline = f->fmt.pix.width * 3; break; case V4L2_PIX_FMT_RGB24: size = f->fmt.pix.width * f->fmt.pix.height * 3; bytesperline = f->fmt.pix.width * 3; break; case V4L2_PIX_FMT_BGR32: size = f->fmt.pix.width * f->fmt.pix.height * 4; bytesperline = f->fmt.pix.width * 4; break; case V4L2_PIX_FMT_RGB32: size = f->fmt.pix.width * f->fmt.pix.height * 4; bytesperline = f->fmt.pix.width * 4; break; case V4L2_PIX_FMT_YUV422P: size = f->fmt.pix.width * f->fmt.pix.height * 2; bytesperline = f->fmt.pix.width; break; case V4L2_PIX_FMT_UYVY: case V4L2_PIX_FMT_YUYV: size = f->fmt.pix.width * f->fmt.pix.height * 2; bytesperline = f->fmt.pix.width * 2; break; case V4L2_PIX_FMT_YUV420: case V4L2_PIX_FMT_YVU420: size = f->fmt.pix.width * f->fmt.pix.height * 3 / 2; bytesperline = f->fmt.pix.width; break; case V4L2_PIX_FMT_NV12: size = f->fmt.pix.width * f->fmt.pix.height * 3 / 2; bytesperline = f->fmt.pix.width; break; default: break; } /* 根据fmt.pix.pixelformat的格式来计算size和bytesperline的大小。这个size就是指图像的大小，bytesperline就是指一行数据所占用的字节数。 */if (f->fmt.pix.bytesperline < bytesperline) f->fmt.pix.bytesperline = bytesperline; else bytesperline = f->fmt.pix.bytesperline; if (f->fmt.pix.sizeimage < size) f->fmt.pix.sizeimage = size; else size = f->fmt.pix.sizeimage; cam->v2f.fmt.pix = f->fmt.pix; if (cam->v2f.fmt.pix.priv != 0) { if (copy_from_user(&cam->offset,    (void *)cam->v2f.fmt.pix.priv,    sizeof(cam->offset))) { retval = -EFAULT; break; } } break; case V4L2_BUF_TYPE_VIDEO_OVERLAY: pr_debug("   type=V4L2_BUF_TYPE_VIDEO_OVERLAY\n"); retval = verify_preview(cam, &f->fmt.win); cam->win = f->fmt.win; break; default: retval = -EINVAL; } pr_debug("End of %s: v2f pix widthxheight %d x %d\n",  __func__,  cam->v2f.fmt.pix.width, cam->v2f.fmt.pix.height); pr_debug("End of %s: crop_bounds widthxheight %d x %d\n",  __func__,  cam->crop_bounds.width, cam->crop_bounds.height); pr_debug("End of %s: crop_defrect widthxheight %d x %d\n",  __func__,  cam->crop_defrect.width, cam->crop_defrect.height); pr_debug("End of %s: crop_current widthxheight %d x %d\n",  __func__,  cam->crop_current.width, cam->crop_current.height); return retval; }

注意上面我标红的代码：cam->v2f.fmt.pix=f->fmt.pix;在这个函数中，对于应用程序中传入的参数，或者修改的参数，到此为止，都已经设置完毕了。然后在这个函数中，对cam->v2f结构体进行赋值，这个结构体里面的cam->v2f.fmt.pix里面包含width，height，pixelformat，bytesperline，sizeimage等等信息，这些信息在后面申请内存大小等函数中都会使用到。

6.VIDIOC_G_FMT宏

case VIDIOC_G_FMT: { struct v4l2_format *gf = arg; pr_debug("   case VIDIOC_G_FMT\n"); retval = mxc_v4l2_g_fmt(cam, gf); break; }

static int mxc_v4l2_g_fmt(cam_data *cam, struct v4l2_format *f) { int retval = 0; pr_debug("In MVC: mxc_v4l2_g_fmt type=%d\n", f->type); switch (f->type) { case V4L2_BUF_TYPE_VIDEO_CAPTURE: pr_debug("   type is V4L2_BUF_TYPE_VIDEO_CAPTURE\n"); f->fmt.pix = cam->v2f.fmt.pix; break; case V4L2_BUF_TYPE_VIDEO_OVERLAY: pr_debug("   type is V4L2_BUF_TYPE_VIDEO_OVERLAY\n"); f->fmt.win = cam->win; break; default: pr_debug("   type is invalid\n"); retval = -EINVAL; } pr_debug("End of %s: v2f pix widthxheight %d x %d\n",  __func__,  cam->v2f.fmt.pix.width, cam->v2f.fmt.pix.height); pr_debug("End of %s: crop_bounds widthxheight %d x %d\n",  __func__,  cam->crop_bounds.width, cam->crop_bounds.height); pr_debug("End of %s: crop_defrect widthxheight %d x %d\n",  __func__,  cam->crop_defrect.width, cam->crop_defrect.height); pr_debug("End of %s: crop_current widthxheight %d x %d\n",  __func__,  cam->crop_current.width, cam->crop_current.height); return retval; }

这个宏没什么意思，在上一个宏VIDIOC_S_FMT中，对于设置的那些信息，最终定下来了，应用程序需要调用这个VIDIOC_G_FMT宏来获取v4l2_formatfmt的信息等，这后面需要使用到这些信息。

7.VIDIOC_REQBUFS宏

case VIDIOC_REQBUFS: { struct v4l2_requestbuffers *req = arg; pr_debug("   case VIDIOC_REQBUFS\n"); if (req->count > FRAME_NUM) { pr_err("ERROR: v4l2 capture: VIDIOC_REQBUFS: "        "not enough buffers\n"); req->count = FRAME_NUM; } /* 判断申请的buffer数目是否超过最大的数目。 */if ((req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) { pr_err("ERROR: v4l2 capture: VIDIOC_REQBUFS: "        "wrong buffer type\n"); retval = -EINVAL; break; } mxc_streamoff(cam); 

/*这个函数同样也在这个文件中：

static int mxc_streamoff(cam_data *cam) { int err = 0; pr_debug("In MVC:mxc_streamoff\n"); if (cam->capture_on == false) return 0; /* For both CSI--MEM and CSI--IC--MEM  * 1. wait for idmac eof  * 2. disable csi first  * 3. disable idmac  * 4. disable smfc (CSI--MEM channel)  */ if (mxc_capture_inputs[cam->current_input].name != NULL) { if (cam->enc_disable_csi) { err = cam->enc_disable_csi(cam); if (err != 0) return err; } if (cam->enc_disable) { err = cam->enc_disable(cam); if (err != 0) return err; } } mxc_free_frames(cam); mxc_capture_inputs[cam->current_input].status |= V4L2_IN_ST_NO_POWER; cam->capture_on = false; return err; }

它通过调用cam->enc_disable_csi(cam)和cam->enc_disable(cam)这两个函数来关闭csi（这两个函数都在ipu_csi_enc.c中），然后调用mxc_free_frames(cam);函数来释放掉framebuffer的状态，主要是通过

cam->frame[i].buffer.flags= V4L2_BUF_FLAG_MAPPED;来修改flags参数。

*/

if (req->memory & V4L2_MEMORY_MMAP) { mxc_free_frame_buf(cam); //释放掉内存，主要是dma_free_coherent函数。retval = mxc_allocate_frame_buf(cam, req->count); } break; }

/*最后调用mxc_allocate_frame_buf函数来重新分配内存。函数如下：

static int mxc_allocate_frame_buf(cam_data *cam, int count) { int i; pr_debug("In MVC:mxc_allocate_frame_buf - size=%d\n", cam->v2f.fmt.pix.sizeimage); for (i = 0; i < count; i++) { cam->frame[i].vaddress =     dma_alloc_coherent(0,        PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage),        &cam->frame[i].paddress,        GFP_DMA | GFP_KERNEL); if (cam->frame[i].vaddress == 0) { pr_err("ERROR: v4l2 capture: " "mxc_allocate_frame_buf failed.\n"); mxc_free_frame_buf(cam); return -ENOBUFS; } cam->frame[i].buffer.index = i; cam->frame[i].buffer.flags = V4L2_BUF_FLAG_MAPPED; cam->frame[i].buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; cam->frame[i].buffer.length =     PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage); cam->frame[i].buffer.memory = V4L2_MEMORY_MMAP; cam->frame[i].buffer.m.offset = cam->frame[i].paddress; cam->frame[i].index = i; } return 0; }

这个函数并不是太难理解，根据应用程序传进来的想要申请的buffer数目，调用dma_alloc_coherent来分配内存，然后设置这些内存的参数等，注意此时的cam->frame[i].buffer.flags的类型是V4L2_BUF_FLAG_MAPPED。

*/

8.mmap函数：

static int mxc_mmap(struct file *file, struct vm_area_struct *vma) { struct video_device *dev = video_devdata(file); unsigned long size; int res = 0; cam_data *cam = video_get_drvdata(dev); pr_debug("In MVC:mxc_mmap\n"); pr_debug("   pgoff=0x%lx, start=0x%lx, end=0x%lx\n",  vma->vm_pgoff, vma->vm_start, vma->vm_end); /* make this _really_ smp-safe */ if (down_interruptible(&cam->busy_lock)) return -EINTR; size = vma->vm_end - vma->vm_start; vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); if (remap_pfn_range(vma, vma->vm_start,     vma->vm_pgoff, size, vma->vm_page_prot)) { pr_err("ERROR: v4l2 capture: mxc_mmap: " "remap_pfn_range failed\n"); res = -ENOBUFS; goto mxc_mmap_exit; } vma->vm_flags &= ~VM_IO;/* using shared anonymous pages */ mxc_mmap_exit: up(&cam->busy_lock); return res; }

9.VIDIOC_QUERYBUF宏

case VIDIOC_QUERYBUF: { struct v4l2_buffer *buf = arg; int index = buf->index; pr_debug("   case VIDIOC_QUERYBUF\n"); if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { pr_err("ERROR: v4l2 capture: "        "VIDIOC_QUERYBUFS: "        "wrong buffer type\n"); retval = -EINVAL; break; } if (buf->memory & V4L2_MEMORY_MMAP) { memset(buf, 0, sizeof(buf)); buf->index = index; } down(&cam->param_lock); if (buf->memory & V4L2_MEMORY_USERPTR) { mxc_v4l2_release_bufs(cam); retval = mxc_v4l2_prepare_bufs(cam, buf); } if (buf->memory & V4L2_MEMORY_MMAP) retval = mxc_v4l2_buffer_status(cam, buf); up(&cam->param_lock); break; }

这个函数先进行了一些判断，然后最终调用的是mxc_v4l2_buffer_status这个函数，如下：

static int mxc_v4l2_buffer_status(cam_data *cam, struct v4l2_buffer *buf) { pr_debug("In MVC:mxc_v4l2_buffer_status\n"); if (buf->index < 0 || buf->index >= FRAME_NUM) { pr_err("ERROR: v4l2 capture: mxc_v4l2_buffer_status buffers "        "not allocated\n"); return -EINVAL; } memcpy(buf, &(cam->frame[buf->index].buffer), sizeof(*buf)); return 0; }

这个函数也是进行了一些判断，然后调用memcpy函数，将上面VIDIOC_REQBUFS宏中通过mxc_allocate_frame_buf函数分配的内存拷贝给buf，返回给应用程序即可。

10.VIDIOC_QBUF宏

case VIDIOC_QBUF: { struct v4l2_buffer *buf = arg; int index = buf->index; pr_debug("   case VIDIOC_QBUF\n"); spin_lock_irqsave(&cam->queue_int_lock, lock_flags); if ((cam->frame[index].buffer.flags & 0x7) ==     V4L2_BUF_FLAG_MAPPED) { cam->frame[index].buffer.flags |=     V4L2_BUF_FLAG_QUEUED; list_add_tail(&cam->frame[index].queue,       &cam->ready_q); } else if (cam->frame[index].buffer.    flags & V4L2_BUF_FLAG_QUEUED) { pr_err("ERROR: v4l2 capture: VIDIOC_QBUF: "        "buffer already queued\n"); retval = -EINVAL; } else if (cam->frame[index].buffer.    flags & V4L2_BUF_FLAG_DONE) { pr_err("ERROR: v4l2 capture: VIDIOC_QBUF: "        "overwrite done buffer.\n"); cam->frame[index].buffer.flags &=     ~V4L2_BUF_FLAG_DONE; cam->frame[index].buffer.flags |=     V4L2_BUF_FLAG_QUEUED; retval = -EINVAL; } buf->flags = cam->frame[index].buffer.flags; spin_unlock_irqrestore(&cam->queue_int_lock, lock_flags); break; }

这个函数主要就是根据cam->frame[index].buffer.flag的不同来选择进行不同的操作，理论上来讲，走到这一步的cam->frame[index].buffer.flag应该是V4L2_BUF_FLAG_MAPPED，那么这个VIDIOC_QBUF需要将它的flags添加一个V4L2_BUF_FLAG_QUEUED属性，然后将这个buffer添加到cam->ready_q队列中。

如果cam->frame[index].buffer.flag为V4L2_BUF_FLAG_QUEUED的话，就直接返回EINVAL。

如果cam->frame[index].buffer.flag为V4L2_BUF_FLAG_DONE的话，就先将flags的V4L2_BUF_FLAG_DONE位清零，然后重新设置为V4L2_BUF_FLAG_QUEUED，然后返回EINVAL。

11.VIDIOC_STREAMON宏

qbuf以后就可以开始传输数据了～

case VIDIOC_STREAMON: { pr_debug("   case VIDIOC_STREAMON\n"); retval = mxc_streamon(cam); break; }

static int mxc_streamon(cam_data *cam) { struct mxc_v4l_frame *frame; unsigned long lock_flags; int err = 0; pr_debug("In MVC:mxc_streamon\n"); if (NULL == cam) { pr_err("ERROR! cam parameter is NULL\n"); return -1; } if (cam->capture_on) { pr_err("ERROR: v4l2 capture: Capture stream has been turned "        " on\n"); return -1; } if (list_empty(&cam->ready_q)) { pr_err("ERROR: v4l2 capture: mxc_streamon buffer has not been " "queued yet\n"); return -EINVAL; } if (cam->enc_update_eba && cam->ready_q.prev == cam->ready_q.next) { pr_err("ERROR: v4l2 capture: mxc_streamon buffer need "        "ping pong at least two buffers\n"); return -EINVAL; } /* 至少保证有2个buffer才能够传输数据。 */cam->capture_pid = current->pid; if (cam->overlay_on == true) stop_preview(cam); /* 如果打开了overlay的话，就先关闭preview. */if (cam->enc_enable) { err = cam->enc_enable(cam); if (err != 0) return err; } /* 通过调用cam->enc_enable函数使能译码任务。在mxc_v4l_open函数中，通过csi_enc_select函数或者prp_enc_select函数来为cam_data结构体里面的这几个函数指针 * 赋值了。具体的操作会跳转到ipu_prp_enc.c或者ipu_csi_enc.c文件中去执行，具体后面再分析。 */spin_lock_irqsave(&cam->queue_int_lock, lock_flags); cam->ping_pong_csi = 0; cam->local_buf_num = 0; if (cam->enc_update_eba) { frame =     list_entry(cam->ready_q.next, struct mxc_v4l_frame, queue); list_del(cam->ready_q.next); list_add_tail(&frame->queue, &cam->working_q); frame->ipu_buf_num = cam->ping_pong_csi; err = cam->enc_update_eba(cam, frame->buffer.m.offset); frame =     list_entry(cam->ready_q.next, struct mxc_v4l_frame, queue); list_del(cam->ready_q.next); list_add_tail(&frame->queue, &cam->working_q); frame->ipu_buf_num = cam->ping_pong_csi; err |= cam->enc_update_eba(cam, frame->buffer.m.offset); spin_unlock_irqrestore(&cam->queue_int_lock, lock_flags); } else { spin_unlock_irqrestore(&cam->queue_int_lock, lock_flags); return -EINVAL; } /* 对这两个buffer进行操作，首先根据 cam->ready_q.next找到包含它的frame，然后删除 cam->ready_q.next队列中的最后一项，将frame添加到 cam->working_q队列中， * 然后调用 cam->enc_update_eba函数来更新buffer的地址。在这里有两个参数ping_pong_csi和local_buf_num，对于这个buffer更新的过程，在后面的《应用程序和驱动程序 * 中buffer的传输流程》文件中详细分析。个人感觉，这个buffer地址的更新过程是一个重点。 */if (cam->overlay_on == true) start_preview(cam); /* 如果打开了overlay的话，继续开启preview。 */if (cam->enc_enable_csi) { err = cam->enc_enable_csi(cam); if (err != 0) return err; } /* 调用cam->enc_enable_csi函数使能csi。 */cam->capture_on = true; return err; }

12.VIDIOC_DQBUF宏

当开始数据传输以后，当有数据填充满一个buffer，就可以将这个buffer出队了，应用程序会调用到VIDIOC_DQBUF这个ioctl函数：

case VIDIOC_DQBUF: { struct v4l2_buffer *buf = arg; pr_debug("   case VIDIOC_DQBUF\n"); if ((cam->enc_counter == 0) && (file->f_flags & O_NONBLOCK)) { retval = -EAGAIN; break; } retval = mxc_v4l_dqueue(cam, buf); break; }

static int mxc_v4l_dqueue(cam_data *cam, struct v4l2_buffer *buf) { int retval = 0; struct mxc_v4l_frame *frame; unsigned long lock_flags; pr_debug("In MVC:mxc_v4l_dqueue\n"); if (!wait_event_interruptible_timeout(cam->enc_queue,       cam->enc_counter != 0,       10 * HZ)) { pr_err("ERROR: v4l2 capture: mxc_v4l_dqueue timeout " "enc_counter %x\n",        cam->enc_counter); return -ETIME; } else if (signal_pending(current)) { pr_err("ERROR: v4l2 capture: mxc_v4l_dqueue() " "interrupt received\n"); return -ERESTARTSYS; } /* 等待 cam->enc_queue这个队列唤醒，当有填充满的buffer的时候，就会产生一个中断，然后在中断处理函数camera_callback函数中，唤醒这个队列。 */if (down_interruptible(&cam->busy_lock)) return -EBUSY; spin_lock_irqsave(&cam->dqueue_int_lock, lock_flags); cam->enc_counter--; /* 每次执行一次这个函数，enc_queue队列中的buffer数目就会减少1,这个引用计数就减少1. */frame = list_entry(cam->done_q.next, struct mxc_v4l_frame, queue); list_del(cam->done_q.next); /* 首先从 cam->done_q队列中取出 queue所对应的frame，然后将cam->done_q队列的最后一项删除。 */if (frame->buffer.flags & V4L2_BUF_FLAG_DONE) { frame->buffer.flags &= ~V4L2_BUF_FLAG_DONE; } else if (frame->buffer.flags & V4L2_BUF_FLAG_QUEUED) { pr_err("ERROR: v4l2 capture: VIDIOC_DQBUF: " "Buffer not filled.\n"); frame->buffer.flags &= ~V4L2_BUF_FLAG_QUEUED; retval = -EINVAL; } else if ((frame->buffer.flags & 0x7) == V4L2_BUF_FLAG_MAPPED) { pr_err("ERROR: v4l2 capture: VIDIOC_DQBUF: " "Buffer not queued.\n"); retval = -EINVAL; } /* 然后根据buffer的flags参数来选择执行的步骤，（但是在这有点疑问， V4L2_BUF_FLAG_DONE不知的在什么时候设置的，这的意思是buffer到这的时候，flags应该 * 是 V4L2_BUF_FLAG_DONE，但是不知的是在哪设置的。对于这个问题，ipu采用的方法是，申请一个中断，当填充满一个buffer的时候，就会触发中断，在中断处理 * 函数camera_callback中处理这些事情。这个流程在后面的buf流程中会详细讲解，这里先标记一下，毕竟在讲ioctl函数～）如果flags参数是 V4L2_BUF_FLAG_DONE的 * 话，就将它清零，如果是 V4L2_BUF_FLAG_QUEUED的话，就说明buffer没有被填充，如果是 V4L2_BUF_FLAG_MAPPED的话，说明buffer没有被qbuf。 */cam->frame[frame->index].buffer.field = cam->device_type ? V4L2_FIELD_INTERLACED : V4L2_FIELD_NONE; buf->bytesused = cam->v2f.fmt.pix.sizeimage; buf->index = frame->index; buf->flags = frame->buffer.flags; buf->m = cam->frame[frame->index].buffer.m; buf->timestamp = cam->frame[frame->index].buffer.timestamp; buf->field = cam->frame[frame->index].buffer.field; spin_unlock_irqrestore(&cam->dqueue_int_lock, lock_flags); up(&cam->busy_lock); return retval; }/* 将bytesused， index等等信息记录在buf里面，这个buf能够返回给应用程序。重要的是buf->m这个结构体，里面包含应用程序所需要的buffer的物理地址，应用程序去那里取摄像头采集到的数据。 */

13.VIDIOC_STREAMOFF宏

case VIDIOC_STREAMOFF: { pr_debug("   case VIDIOC_STREAMOFF\n"); retval = mxc_streamoff(cam); break; }

static int mxc_streamoff(cam_data *cam) { int err = 0; pr_debug("In MVC:mxc_streamoff\n"); if (cam->capture_on == false) return 0; /* For both CSI--MEM and CSI--IC--MEM  * 1. wait for idmac eof  * 2. disable csi first  * 3. disable idmac  * 4. disable smfc (CSI--MEM channel)  */ if (mxc_capture_inputs[cam->current_input].name != NULL) { if (cam->enc_disable_csi) { err = cam->enc_disable_csi(cam); if (err != 0) return err; } if (cam->enc_disable) { err = cam->enc_disable(cam); if (err != 0) return err; } } mxc_free_frames(cam); mxc_capture_inputs[cam->current_input].status |= V4L2_IN_ST_NO_POWER; cam->capture_on = false; return err; }

看注释写的很清楚，先等待idmac结束，然后先关掉csi，然关闭idmac，再关掉CSI--MEMchannel，关闭csi通过enc_disable_csi函数来实现的，其他3项任务是通过enc_disable函数里面调用的csi_enc_disabling_tasks函数来完成的。最后调用mxc_free_frames函数来清除掉frame的状态参数。