Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Yong Zhi | 4760 | 65.26% | 6 | 18.75% |
Bingbu Cao | 2117 | 29.02% | 6 | 18.75% |
Maximilian Luz | 104 | 1.43% | 1 | 3.12% |
Ricardo Ribalda Delgado | 86 | 1.18% | 5 | 15.62% |
Arnd Bergmann | 74 | 1.01% | 1 | 3.12% |
Sakari Ailus | 42 | 0.58% | 3 | 9.38% |
Niklas Söderlund | 38 | 0.52% | 1 | 3.12% |
Hidenori Kobayashi | 25 | 0.34% | 1 | 3.12% |
Tomi Valkeinen | 24 | 0.33% | 2 | 6.25% |
Umang Jain | 10 | 0.14% | 1 | 3.12% |
Deepak R Varma | 9 | 0.12% | 1 | 3.12% |
Boris Brezillon | 2 | 0.03% | 1 | 3.12% |
Benjamin Gaignard | 1 | 0.01% | 1 | 3.12% |
Hans Verkuil | 1 | 0.01% | 1 | 3.12% |
Rikard Falkeborn | 1 | 0.01% | 1 | 3.12% |
Total | 7294 | 32 |
// SPDX-License-Identifier: GPL-2.0 // Copyright (C) 2018 Intel Corporation #include <linux/module.h> #include <linux/pm_runtime.h> #include <media/v4l2-event.h> #include <media/v4l2-ioctl.h> #include "ipu3.h" #include "ipu3-dmamap.h" /******************** v4l2_subdev_ops ********************/ #define IPU3_RUNNING_MODE_VIDEO 0 #define IPU3_RUNNING_MODE_STILL 1 static int imgu_subdev_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) { struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[imgu_sd->pipe]; struct v4l2_rect try_crop = { .top = 0, .left = 0, }; unsigned int i; try_crop.width = imgu_pipe->nodes[IMGU_NODE_IN].vdev_fmt.fmt.pix_mp.width; try_crop.height = imgu_pipe->nodes[IMGU_NODE_IN].vdev_fmt.fmt.pix_mp.height; /* Initialize try_fmt */ for (i = 0; i < IMGU_NODE_NUM; i++) { struct v4l2_mbus_framefmt *try_fmt = v4l2_subdev_state_get_format(fh->state, i); try_fmt->width = try_crop.width; try_fmt->height = try_crop.height; try_fmt->code = imgu_pipe->nodes[i].pad_fmt.code; try_fmt->field = V4L2_FIELD_NONE; } *v4l2_subdev_state_get_crop(fh->state, IMGU_NODE_IN) = try_crop; *v4l2_subdev_state_get_compose(fh->state, IMGU_NODE_IN) = try_crop; return 0; } static int imgu_subdev_s_stream(struct v4l2_subdev *sd, int enable) { int i; unsigned int node; int r = 0; struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); unsigned int pipe = imgu_sd->pipe; struct device *dev = &imgu->pci_dev->dev; struct v4l2_pix_format_mplane *fmts[IPU3_CSS_QUEUES] = { NULL }; struct v4l2_rect *rects[IPU3_CSS_RECTS] = { NULL }; struct imgu_css_pipe *css_pipe = &imgu->css.pipes[pipe]; struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe]; dev_dbg(dev, "%s %d for pipe %u", __func__, enable, pipe); /* grab ctrl after streamon and return after off */ v4l2_ctrl_grab(imgu_sd->ctrl, enable); if (!enable) { imgu_sd->active = false; return 0; } for (i = 0; i < IMGU_NODE_NUM; i++) imgu_pipe->queue_enabled[i] = imgu_pipe->nodes[i].enabled; /* This is handled specially */ imgu_pipe->queue_enabled[IPU3_CSS_QUEUE_PARAMS] = false; /* Initialize CSS formats */ for (i = 0; i < IPU3_CSS_QUEUES; i++) { node = imgu_map_node(imgu, i); /* No need to reconfig meta nodes */ if (node == IMGU_NODE_STAT_3A || node == IMGU_NODE_PARAMS) continue; fmts[i] = imgu_pipe->queue_enabled[node] ? &imgu_pipe->nodes[node].vdev_fmt.fmt.pix_mp : NULL; } /* Enable VF output only when VF queue requested by user */ css_pipe->vf_output_en = false; if (imgu_pipe->nodes[IMGU_NODE_VF].enabled) css_pipe->vf_output_en = true; if (atomic_read(&imgu_sd->running_mode) == IPU3_RUNNING_MODE_VIDEO) css_pipe->pipe_id = IPU3_CSS_PIPE_ID_VIDEO; else css_pipe->pipe_id = IPU3_CSS_PIPE_ID_CAPTURE; dev_dbg(dev, "IPU3 pipe %u pipe_id %u", pipe, css_pipe->pipe_id); rects[IPU3_CSS_RECT_EFFECTIVE] = &imgu_sd->rect.eff; rects[IPU3_CSS_RECT_BDS] = &imgu_sd->rect.bds; rects[IPU3_CSS_RECT_GDC] = &imgu_sd->rect.gdc; r = imgu_css_fmt_set(&imgu->css, fmts, rects, pipe); if (r) { dev_err(dev, "failed to set initial formats pipe %u with (%d)", pipe, r); return r; } imgu_sd->active = true; return 0; } static int imgu_subdev_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct v4l2_mbus_framefmt *mf; struct imgu_media_pipe *imgu_pipe; u32 pad = fmt->pad; struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); unsigned int pipe = imgu_sd->pipe; imgu_pipe = &imgu->imgu_pipe[pipe]; if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) { fmt->format = imgu_pipe->nodes[pad].pad_fmt; } else { mf = v4l2_subdev_state_get_format(sd_state, pad); fmt->format = *mf; } return 0; } static int imgu_subdev_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { struct imgu_media_pipe *imgu_pipe; struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); struct v4l2_mbus_framefmt *mf; u32 pad = fmt->pad; unsigned int pipe = imgu_sd->pipe; dev_dbg(&imgu->pci_dev->dev, "set subdev %u pad %u fmt to [%ux%u]", pipe, pad, fmt->format.width, fmt->format.height); imgu_pipe = &imgu->imgu_pipe[pipe]; if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) mf = v4l2_subdev_state_get_format(sd_state, pad); else mf = &imgu_pipe->nodes[pad].pad_fmt; fmt->format.code = mf->code; /* Clamp the w and h based on the hardware capabilities */ if (imgu_sd->subdev_pads[pad].flags & MEDIA_PAD_FL_SOURCE) { fmt->format.width = clamp(fmt->format.width, IPU3_OUTPUT_MIN_WIDTH, IPU3_OUTPUT_MAX_WIDTH); fmt->format.height = clamp(fmt->format.height, IPU3_OUTPUT_MIN_HEIGHT, IPU3_OUTPUT_MAX_HEIGHT); } else { fmt->format.width = clamp(fmt->format.width, IPU3_INPUT_MIN_WIDTH, IPU3_INPUT_MAX_WIDTH); fmt->format.height = clamp(fmt->format.height, IPU3_INPUT_MIN_HEIGHT, IPU3_INPUT_MAX_HEIGHT); } *mf = fmt->format; return 0; } static struct v4l2_rect * imgu_subdev_get_crop(struct imgu_v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, unsigned int pad, enum v4l2_subdev_format_whence which) { if (which == V4L2_SUBDEV_FORMAT_TRY) return v4l2_subdev_state_get_crop(sd_state, pad); else return &sd->rect.eff; } static struct v4l2_rect * imgu_subdev_get_compose(struct imgu_v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, unsigned int pad, enum v4l2_subdev_format_whence which) { if (which == V4L2_SUBDEV_FORMAT_TRY) return v4l2_subdev_state_get_compose(sd_state, pad); else return &sd->rect.bds; } static int imgu_subdev_get_selection(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_selection *sel) { struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); if (sel->pad != IMGU_NODE_IN) return -EINVAL; switch (sel->target) { case V4L2_SEL_TGT_CROP: sel->r = *imgu_subdev_get_crop(imgu_sd, sd_state, sel->pad, sel->which); return 0; case V4L2_SEL_TGT_COMPOSE: sel->r = *imgu_subdev_get_compose(imgu_sd, sd_state, sel->pad, sel->which); return 0; default: return -EINVAL; } } static int imgu_subdev_set_selection(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_selection *sel) { struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); struct v4l2_rect *rect; dev_dbg(&imgu->pci_dev->dev, "set subdev %u sel which %u target 0x%4x rect [%ux%u]", imgu_sd->pipe, sel->which, sel->target, sel->r.width, sel->r.height); if (sel->pad != IMGU_NODE_IN) return -EINVAL; switch (sel->target) { case V4L2_SEL_TGT_CROP: rect = imgu_subdev_get_crop(imgu_sd, sd_state, sel->pad, sel->which); break; case V4L2_SEL_TGT_COMPOSE: rect = imgu_subdev_get_compose(imgu_sd, sd_state, sel->pad, sel->which); break; default: return -EINVAL; } *rect = sel->r; return 0; } /******************** media_entity_operations ********************/ static int imgu_link_setup(struct media_entity *entity, const struct media_pad *local, const struct media_pad *remote, u32 flags) { struct imgu_media_pipe *imgu_pipe; struct v4l2_subdev *sd = container_of(entity, struct v4l2_subdev, entity); struct imgu_device *imgu = v4l2_get_subdevdata(sd); struct imgu_v4l2_subdev *imgu_sd = container_of(sd, struct imgu_v4l2_subdev, subdev); unsigned int pipe = imgu_sd->pipe; u32 pad = local->index; WARN_ON(pad >= IMGU_NODE_NUM); dev_dbg(&imgu->pci_dev->dev, "pipe %u pad %u is %s", pipe, pad, flags & MEDIA_LNK_FL_ENABLED ? "enabled" : "disabled"); imgu_pipe = &imgu->imgu_pipe[pipe]; imgu_pipe->nodes[pad].enabled = flags & MEDIA_LNK_FL_ENABLED; /* enable input node to enable the pipe */ if (pad != IMGU_NODE_IN) return 0; if (flags & MEDIA_LNK_FL_ENABLED) __set_bit(pipe, imgu->css.enabled_pipes); else __clear_bit(pipe, imgu->css.enabled_pipes); dev_dbg(&imgu->pci_dev->dev, "pipe %u is %s", pipe, flags & MEDIA_LNK_FL_ENABLED ? "enabled" : "disabled"); return 0; } /******************** vb2_ops ********************/ static int imgu_vb2_buf_init(struct vb2_buffer *vb) { struct sg_table *sg = vb2_dma_sg_plane_desc(vb, 0); struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue); struct imgu_buffer *buf = container_of(vb, struct imgu_buffer, vid_buf.vbb.vb2_buf); struct imgu_video_device *node = container_of(vb->vb2_queue, struct imgu_video_device, vbq); unsigned int queue = imgu_node_to_queue(node->id); if (queue == IPU3_CSS_QUEUE_PARAMS) return 0; return imgu_dmamap_map_sg(imgu, sg->sgl, sg->nents, &buf->map); } /* Called when each buffer is freed */ static void imgu_vb2_buf_cleanup(struct vb2_buffer *vb) { struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue); struct imgu_buffer *buf = container_of(vb, struct imgu_buffer, vid_buf.vbb.vb2_buf); struct imgu_video_device *node = container_of(vb->vb2_queue, struct imgu_video_device, vbq); unsigned int queue = imgu_node_to_queue(node->id); if (queue == IPU3_CSS_QUEUE_PARAMS) return; imgu_dmamap_unmap(imgu, &buf->map); } /* Transfer buffer ownership to me */ static void imgu_vb2_buf_queue(struct vb2_buffer *vb) { struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue); struct imgu_video_device *node = container_of(vb->vb2_queue, struct imgu_video_device, vbq); unsigned int queue = imgu_node_to_queue(node->id); struct imgu_buffer *buf = container_of(vb, struct imgu_buffer, vid_buf.vbb.vb2_buf); unsigned long need_bytes; unsigned long payload = vb2_get_plane_payload(vb, 0); if (vb->vb2_queue->type == V4L2_BUF_TYPE_META_CAPTURE || vb->vb2_queue->type == V4L2_BUF_TYPE_META_OUTPUT) need_bytes = node->vdev_fmt.fmt.meta.buffersize; else need_bytes = node->vdev_fmt.fmt.pix_mp.plane_fmt[0].sizeimage; if (queue == IPU3_CSS_QUEUE_PARAMS && payload && payload < need_bytes) { dev_err(&imgu->pci_dev->dev, "invalid data size for params."); vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); return; } mutex_lock(&imgu->lock); if (queue != IPU3_CSS_QUEUE_PARAMS) imgu_css_buf_init(&buf->css_buf, queue, buf->map.daddr); list_add_tail(&buf->vid_buf.list, &node->buffers); mutex_unlock(&imgu->lock); vb2_set_plane_payload(vb, 0, need_bytes); mutex_lock(&imgu->streaming_lock); if (imgu->streaming) imgu_queue_buffers(imgu, false, node->pipe); mutex_unlock(&imgu->streaming_lock); dev_dbg(&imgu->pci_dev->dev, "%s for pipe %u node %u", __func__, node->pipe, node->id); } static int imgu_vb2_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers, unsigned int *num_planes, unsigned int sizes[], struct device *alloc_devs[]) { struct imgu_device *imgu = vb2_get_drv_priv(vq); struct imgu_video_device *node = container_of(vq, struct imgu_video_device, vbq); const struct v4l2_format *fmt = &node->vdev_fmt; unsigned int size; *num_buffers = clamp_val(*num_buffers, 1, VB2_MAX_FRAME); alloc_devs[0] = &imgu->pci_dev->dev; if (vq->type == V4L2_BUF_TYPE_META_CAPTURE || vq->type == V4L2_BUF_TYPE_META_OUTPUT) size = fmt->fmt.meta.buffersize; else size = fmt->fmt.pix_mp.plane_fmt[0].sizeimage; if (*num_planes) { if (sizes[0] < size) return -EINVAL; size = sizes[0]; } *num_planes = 1; sizes[0] = size; /* Initialize buffer queue */ INIT_LIST_HEAD(&node->buffers); return 0; } /* Check if all enabled video nodes are streaming, exception ignored */ static bool imgu_all_nodes_streaming(struct imgu_device *imgu, struct imgu_video_device *except) { unsigned int i, pipe, p; struct imgu_video_device *node; struct device *dev = &imgu->pci_dev->dev; pipe = except->pipe; if (!test_bit(pipe, imgu->css.enabled_pipes)) { dev_warn(&imgu->pci_dev->dev, "pipe %u link is not ready yet", pipe); return false; } for_each_set_bit(p, imgu->css.enabled_pipes, IMGU_MAX_PIPE_NUM) { for (i = 0; i < IMGU_NODE_NUM; i++) { node = &imgu->imgu_pipe[p].nodes[i]; dev_dbg(dev, "%s pipe %u queue %u name %s enabled = %u", __func__, p, i, node->name, node->enabled); if (node == except) continue; if (node->enabled && !vb2_start_streaming_called(&node->vbq)) return false; } } return true; } static void imgu_return_all_buffers(struct imgu_device *imgu, struct imgu_video_device *node, enum vb2_buffer_state state) { struct imgu_vb2_buffer *b, *b0; /* Return all buffers */ mutex_lock(&imgu->lock); list_for_each_entry_safe(b, b0, &node->buffers, list) { list_del(&b->list); vb2_buffer_done(&b->vbb.vb2_buf, state); } mutex_unlock(&imgu->lock); } static int imgu_vb2_start_streaming(struct vb2_queue *vq, unsigned int count) { struct imgu_media_pipe *imgu_pipe; struct imgu_device *imgu = vb2_get_drv_priv(vq); struct device *dev = &imgu->pci_dev->dev; struct imgu_video_device *node = container_of(vq, struct imgu_video_device, vbq); int r; unsigned int pipe; dev_dbg(dev, "%s node name %s pipe %u id %u", __func__, node->name, node->pipe, node->id); mutex_lock(&imgu->streaming_lock); if (imgu->streaming) { r = -EBUSY; mutex_unlock(&imgu->streaming_lock); goto fail_return_bufs; } mutex_unlock(&imgu->streaming_lock); if (!node->enabled) { dev_err(dev, "IMGU node is not enabled"); r = -EINVAL; goto fail_return_bufs; } pipe = node->pipe; imgu_pipe = &imgu->imgu_pipe[pipe]; atomic_set(&node->sequence, 0); r = video_device_pipeline_start(&node->vdev, &imgu_pipe->pipeline); if (r < 0) goto fail_return_bufs; if (!imgu_all_nodes_streaming(imgu, node)) return 0; for_each_set_bit(pipe, imgu->css.enabled_pipes, IMGU_MAX_PIPE_NUM) { r = v4l2_subdev_call(&imgu->imgu_pipe[pipe].imgu_sd.subdev, video, s_stream, 1); if (r < 0) goto fail_stop_pipeline; } /* Start streaming of the whole pipeline now */ dev_dbg(dev, "IMGU streaming is ready to start"); mutex_lock(&imgu->streaming_lock); r = imgu_s_stream(imgu, true); if (!r) imgu->streaming = true; mutex_unlock(&imgu->streaming_lock); return 0; fail_stop_pipeline: video_device_pipeline_stop(&node->vdev); fail_return_bufs: imgu_return_all_buffers(imgu, node, VB2_BUF_STATE_QUEUED); return r; } static void imgu_vb2_stop_streaming(struct vb2_queue *vq) { struct imgu_media_pipe *imgu_pipe; struct imgu_device *imgu = vb2_get_drv_priv(vq); struct device *dev = &imgu->pci_dev->dev; struct imgu_video_device *node = container_of(vq, struct imgu_video_device, vbq); int r; unsigned int pipe; WARN_ON(!node->enabled); pipe = node->pipe; dev_dbg(dev, "Try to stream off node [%u][%u]", pipe, node->id); imgu_pipe = &imgu->imgu_pipe[pipe]; r = v4l2_subdev_call(&imgu_pipe->imgu_sd.subdev, video, s_stream, 0); if (r) dev_err(&imgu->pci_dev->dev, "failed to stop subdev streaming\n"); mutex_lock(&imgu->streaming_lock); /* Was this the first node with streaming disabled? */ if (imgu->streaming && imgu_all_nodes_streaming(imgu, node)) { /* Yes, really stop streaming now */ dev_dbg(dev, "IMGU streaming is ready to stop"); r = imgu_s_stream(imgu, false); if (!r) imgu->streaming = false; } imgu_return_all_buffers(imgu, node, VB2_BUF_STATE_ERROR); mutex_unlock(&imgu->streaming_lock); video_device_pipeline_stop(&node->vdev); } /******************** v4l2_ioctl_ops ********************/ #define VID_CAPTURE 0 #define VID_OUTPUT 1 #define DEF_VID_CAPTURE 0 #define DEF_VID_OUTPUT 1 struct imgu_fmt { u32 fourcc; u16 type; /* VID_CAPTURE or VID_OUTPUT not both */ }; /* format descriptions for capture and preview */ static const struct imgu_fmt formats[] = { { V4L2_PIX_FMT_NV12, VID_CAPTURE }, { V4L2_PIX_FMT_IPU3_SGRBG10, VID_OUTPUT }, { V4L2_PIX_FMT_IPU3_SBGGR10, VID_OUTPUT }, { V4L2_PIX_FMT_IPU3_SGBRG10, VID_OUTPUT }, { V4L2_PIX_FMT_IPU3_SRGGB10, VID_OUTPUT }, }; /* Find the first matched format, return default if not found */ static const struct imgu_fmt *find_format(struct v4l2_format *f, u32 type) { unsigned int i; for (i = 0; i < ARRAY_SIZE(formats); i++) { if (formats[i].fourcc == f->fmt.pix_mp.pixelformat && formats[i].type == type) return &formats[i]; } return type == VID_CAPTURE ? &formats[DEF_VID_CAPTURE] : &formats[DEF_VID_OUTPUT]; } static int imgu_vidioc_querycap(struct file *file, void *fh, struct v4l2_capability *cap) { struct imgu_device *imgu = video_drvdata(file); strscpy(cap->driver, IMGU_NAME, sizeof(cap->driver)); strscpy(cap->card, IMGU_NAME, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", pci_name(imgu->pci_dev)); return 0; } static int enum_fmts(struct v4l2_fmtdesc *f, u32 type) { unsigned int i, j; if (f->mbus_code != 0 && f->mbus_code != MEDIA_BUS_FMT_FIXED) return -EINVAL; for (i = j = 0; i < ARRAY_SIZE(formats); ++i) { if (formats[i].type == type) { if (j == f->index) break; ++j; } } if (i < ARRAY_SIZE(formats)) { f->pixelformat = formats[i].fourcc; return 0; } return -EINVAL; } static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f) { if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) return -EINVAL; return enum_fmts(f, VID_CAPTURE); } static int vidioc_enum_fmt_vid_out(struct file *file, void *priv, struct v4l2_fmtdesc *f) { if (f->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) return -EINVAL; return enum_fmts(f, VID_OUTPUT); } /* Propagate forward always the format from the CIO2 subdev */ static int imgu_vidioc_g_fmt(struct file *file, void *fh, struct v4l2_format *f) { struct imgu_video_device *node = file_to_intel_imgu_node(file); f->fmt = node->vdev_fmt.fmt; return 0; } /* * Set input/output format. Unless it is just a try, this also resets * selections (ie. effective and BDS resolutions) to defaults. */ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, struct v4l2_format *f, bool try) { struct device *dev = &imgu->pci_dev->dev; struct v4l2_pix_format_mplane *fmts[IPU3_CSS_QUEUES] = { NULL }; struct v4l2_rect *rects[IPU3_CSS_RECTS] = { NULL }; struct v4l2_mbus_framefmt pad_fmt; unsigned int i, css_q; int ret; struct imgu_css_pipe *css_pipe = &imgu->css.pipes[pipe]; struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe]; struct imgu_v4l2_subdev *imgu_sd = &imgu_pipe->imgu_sd; dev_dbg(dev, "set fmt node [%u][%u](try = %u)", pipe, node, try); for (i = 0; i < IMGU_NODE_NUM; i++) dev_dbg(dev, "IMGU pipe %u node %u enabled = %u", pipe, i, imgu_pipe->nodes[i].enabled); if (imgu_pipe->nodes[IMGU_NODE_VF].enabled) css_pipe->vf_output_en = true; if (atomic_read(&imgu_sd->running_mode) == IPU3_RUNNING_MODE_VIDEO) css_pipe->pipe_id = IPU3_CSS_PIPE_ID_VIDEO; else css_pipe->pipe_id = IPU3_CSS_PIPE_ID_CAPTURE; dev_dbg(dev, "IPU3 pipe %u pipe_id = %u", pipe, css_pipe->pipe_id); css_q = imgu_node_to_queue(node); for (i = 0; i < IPU3_CSS_QUEUES; i++) { unsigned int inode = imgu_map_node(imgu, i); /* Skip the meta node */ if (inode == IMGU_NODE_STAT_3A || inode == IMGU_NODE_PARAMS) continue; /* CSS expects some format on OUT queue */ if (i != IPU3_CSS_QUEUE_OUT && !imgu_pipe->nodes[inode].enabled && !try) { fmts[i] = NULL; continue; } if (i == css_q) { fmts[i] = &f->fmt.pix_mp; continue; } if (try) { fmts[i] = kmemdup(&imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp, sizeof(struct v4l2_pix_format_mplane), GFP_KERNEL); if (!fmts[i]) { ret = -ENOMEM; goto out; } } else { fmts[i] = &imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp; } } if (!try) { /* eff and bds res got by imgu_s_sel */ struct imgu_v4l2_subdev *imgu_sd = &imgu_pipe->imgu_sd; rects[IPU3_CSS_RECT_EFFECTIVE] = &imgu_sd->rect.eff; rects[IPU3_CSS_RECT_BDS] = &imgu_sd->rect.bds; rects[IPU3_CSS_RECT_GDC] = &imgu_sd->rect.gdc; /* suppose that pad fmt was set by subdev s_fmt before */ pad_fmt = imgu_pipe->nodes[IMGU_NODE_IN].pad_fmt; rects[IPU3_CSS_RECT_GDC]->width = pad_fmt.width; rects[IPU3_CSS_RECT_GDC]->height = pad_fmt.height; } if (!fmts[css_q]) { ret = -EINVAL; goto out; } if (try) ret = imgu_css_fmt_try(&imgu->css, fmts, rects, pipe); else ret = imgu_css_fmt_set(&imgu->css, fmts, rects, pipe); /* ret is the binary number in the firmware blob */ if (ret < 0) goto out; /* * imgu doesn't set the node to the value given by user * before we return success from this function, so set it here. */ if (!try) imgu_pipe->nodes[node].vdev_fmt.fmt.pix_mp = f->fmt.pix_mp; out: if (try) { for (i = 0; i < IPU3_CSS_QUEUES; i++) if (i != css_q) kfree(fmts[i]); } return ret; } static int imgu_try_fmt(struct file *file, void *fh, struct v4l2_format *f) { struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp; const struct imgu_fmt *fmt; if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) fmt = find_format(f, VID_CAPTURE); else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) fmt = find_format(f, VID_OUTPUT); else return -EINVAL; pixm->pixelformat = fmt->fourcc; return 0; } static int imgu_vidioc_try_fmt(struct file *file, void *fh, struct v4l2_format *f) { struct imgu_device *imgu = video_drvdata(file); struct device *dev = &imgu->pci_dev->dev; struct imgu_video_device *node = file_to_intel_imgu_node(file); struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; int r; dev_dbg(dev, "%s [%ux%u] for node %u\n", __func__, pix_mp->width, pix_mp->height, node->id); r = imgu_try_fmt(file, fh, f); if (r) return r; return imgu_fmt(imgu, node->pipe, node->id, f, true); } static int imgu_vidioc_s_fmt(struct file *file, void *fh, struct v4l2_format *f) { struct imgu_device *imgu = video_drvdata(file); struct device *dev = &imgu->pci_dev->dev; struct imgu_video_device *node = file_to_intel_imgu_node(file); struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; int r; dev_dbg(dev, "%s [%ux%u] for node %u\n", __func__, pix_mp->width, pix_mp->height, node->id); r = imgu_try_fmt(file, fh, f); if (r) return r; return imgu_fmt(imgu, node->pipe, node->id, f, false); } struct imgu_meta_fmt { __u32 fourcc; char *name; }; /* From drivers/media/v4l2-core/v4l2-ioctl.c */ static const struct imgu_meta_fmt meta_fmts[] = { { V4L2_META_FMT_IPU3_PARAMS, "IPU3 processing parameters" }, { V4L2_META_FMT_IPU3_STAT_3A, "IPU3 3A statistics" }, }; static int imgu_meta_enum_format(struct file *file, void *fh, struct v4l2_fmtdesc *fmt) { struct imgu_video_device *node = file_to_intel_imgu_node(file); unsigned int i = fmt->type == V4L2_BUF_TYPE_META_OUTPUT ? 0 : 1; /* Each node is dedicated to only one meta format */ if (fmt->index > 0 || fmt->type != node->vbq.type) return -EINVAL; if (fmt->mbus_code != 0 && fmt->mbus_code != MEDIA_BUS_FMT_FIXED) return -EINVAL; strscpy(fmt->description, meta_fmts[i].name, sizeof(fmt->description)); fmt->pixelformat = meta_fmts[i].fourcc; return 0; } static int imgu_vidioc_g_meta_fmt(struct file *file, void *fh, struct v4l2_format *f) { struct imgu_video_device *node = file_to_intel_imgu_node(file); if (f->type != node->vbq.type) return -EINVAL; f->fmt = node->vdev_fmt.fmt; return 0; } /******************** function pointers ********************/ static const struct v4l2_subdev_internal_ops imgu_subdev_internal_ops = { .open = imgu_subdev_open, }; static const struct v4l2_subdev_core_ops imgu_subdev_core_ops = { .subscribe_event = v4l2_ctrl_subdev_subscribe_event, .unsubscribe_event = v4l2_event_subdev_unsubscribe, }; static const struct v4l2_subdev_video_ops imgu_subdev_video_ops = { .s_stream = imgu_subdev_s_stream, }; static const struct v4l2_subdev_pad_ops imgu_subdev_pad_ops = { .link_validate = v4l2_subdev_link_validate_default, .get_fmt = imgu_subdev_get_fmt, .set_fmt = imgu_subdev_set_fmt, .get_selection = imgu_subdev_get_selection, .set_selection = imgu_subdev_set_selection, }; static const struct v4l2_subdev_ops imgu_subdev_ops = { .core = &imgu_subdev_core_ops, .video = &imgu_subdev_video_ops, .pad = &imgu_subdev_pad_ops, }; static const struct media_entity_operations imgu_media_ops = { .link_setup = imgu_link_setup, .link_validate = v4l2_subdev_link_validate, }; /****************** vb2_ops of the Q ********************/ static const struct vb2_ops imgu_vb2_ops = { .buf_init = imgu_vb2_buf_init, .buf_cleanup = imgu_vb2_buf_cleanup, .buf_queue = imgu_vb2_buf_queue, .queue_setup = imgu_vb2_queue_setup, .start_streaming = imgu_vb2_start_streaming, .stop_streaming = imgu_vb2_stop_streaming, .wait_prepare = vb2_ops_wait_prepare, .wait_finish = vb2_ops_wait_finish, }; /****************** v4l2_file_operations *****************/ static const struct v4l2_file_operations imgu_v4l2_fops = { .unlocked_ioctl = video_ioctl2, .open = v4l2_fh_open, .release = vb2_fop_release, .poll = vb2_fop_poll, .mmap = vb2_fop_mmap, }; /******************** v4l2_ioctl_ops ********************/ static const struct v4l2_ioctl_ops imgu_v4l2_ioctl_ops = { .vidioc_querycap = imgu_vidioc_querycap, .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, .vidioc_g_fmt_vid_cap_mplane = imgu_vidioc_g_fmt, .vidioc_s_fmt_vid_cap_mplane = imgu_vidioc_s_fmt, .vidioc_try_fmt_vid_cap_mplane = imgu_vidioc_try_fmt, .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out, .vidioc_g_fmt_vid_out_mplane = imgu_vidioc_g_fmt, .vidioc_s_fmt_vid_out_mplane = imgu_vidioc_s_fmt, .vidioc_try_fmt_vid_out_mplane = imgu_vidioc_try_fmt, /* buffer queue management */ .vidioc_reqbufs = vb2_ioctl_reqbufs, .vidioc_create_bufs = vb2_ioctl_create_bufs, .vidioc_prepare_buf = vb2_ioctl_prepare_buf, .vidioc_querybuf = vb2_ioctl_querybuf, .vidioc_qbuf = vb2_ioctl_qbuf, .vidioc_dqbuf = vb2_ioctl_dqbuf, .vidioc_streamon = vb2_ioctl_streamon, .vidioc_streamoff = vb2_ioctl_streamoff, .vidioc_expbuf = vb2_ioctl_expbuf, }; static const struct v4l2_ioctl_ops imgu_v4l2_meta_ioctl_ops = { .vidioc_querycap = imgu_vidioc_querycap, /* meta capture */ .vidioc_enum_fmt_meta_cap = imgu_meta_enum_format, .vidioc_g_fmt_meta_cap = imgu_vidioc_g_meta_fmt, .vidioc_s_fmt_meta_cap = imgu_vidioc_g_meta_fmt, .vidioc_try_fmt_meta_cap = imgu_vidioc_g_meta_fmt, /* meta output */ .vidioc_enum_fmt_meta_out = imgu_meta_enum_format, .vidioc_g_fmt_meta_out = imgu_vidioc_g_meta_fmt, .vidioc_s_fmt_meta_out = imgu_vidioc_g_meta_fmt, .vidioc_try_fmt_meta_out = imgu_vidioc_g_meta_fmt, .vidioc_reqbufs = vb2_ioctl_reqbufs, .vidioc_create_bufs = vb2_ioctl_create_bufs, .vidioc_prepare_buf = vb2_ioctl_prepare_buf, .vidioc_querybuf = vb2_ioctl_querybuf, .vidioc_qbuf = vb2_ioctl_qbuf, .vidioc_dqbuf = vb2_ioctl_dqbuf, .vidioc_streamon = vb2_ioctl_streamon, .vidioc_streamoff = vb2_ioctl_streamoff, .vidioc_expbuf = vb2_ioctl_expbuf, }; static int imgu_sd_s_ctrl(struct v4l2_ctrl *ctrl) { struct imgu_v4l2_subdev *imgu_sd = container_of(ctrl->handler, struct imgu_v4l2_subdev, ctrl_handler); struct imgu_device *imgu = v4l2_get_subdevdata(&imgu_sd->subdev); struct device *dev = &imgu->pci_dev->dev; dev_dbg(dev, "set val %d to ctrl 0x%8x for subdev %u", ctrl->val, ctrl->id, imgu_sd->pipe); switch (ctrl->id) { case V4L2_CID_INTEL_IPU3_MODE: atomic_set(&imgu_sd->running_mode, ctrl->val); return 0; default: return -EINVAL; } } static const struct v4l2_ctrl_ops imgu_subdev_ctrl_ops = { .s_ctrl = imgu_sd_s_ctrl, }; static const char * const imgu_ctrl_mode_strings[] = { "Video mode", "Still mode", }; static const struct v4l2_ctrl_config imgu_subdev_ctrl_mode = { .ops = &imgu_subdev_ctrl_ops, .id = V4L2_CID_INTEL_IPU3_MODE, .name = "IPU3 Pipe Mode", .type = V4L2_CTRL_TYPE_MENU, .max = ARRAY_SIZE(imgu_ctrl_mode_strings) - 1, .def = IPU3_RUNNING_MODE_VIDEO, .qmenu = imgu_ctrl_mode_strings, }; /******************** Framework registration ********************/ /* helper function to config node's video properties */ static void imgu_node_to_v4l2(u32 node, struct video_device *vdev, struct v4l2_format *f) { u32 cap; /* Should not happen */ WARN_ON(node >= IMGU_NODE_NUM); switch (node) { case IMGU_NODE_IN: cap = V4L2_CAP_VIDEO_OUTPUT_MPLANE; f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; vdev->ioctl_ops = &imgu_v4l2_ioctl_ops; break; case IMGU_NODE_PARAMS: cap = V4L2_CAP_META_OUTPUT; f->type = V4L2_BUF_TYPE_META_OUTPUT; f->fmt.meta.dataformat = V4L2_META_FMT_IPU3_PARAMS; vdev->ioctl_ops = &imgu_v4l2_meta_ioctl_ops; imgu_css_meta_fmt_set(&f->fmt.meta); break; case IMGU_NODE_STAT_3A: cap = V4L2_CAP_META_CAPTURE; f->type = V4L2_BUF_TYPE_META_CAPTURE; f->fmt.meta.dataformat = V4L2_META_FMT_IPU3_STAT_3A; vdev->ioctl_ops = &imgu_v4l2_meta_ioctl_ops; imgu_css_meta_fmt_set(&f->fmt.meta); break; default: cap = V4L2_CAP_VIDEO_CAPTURE_MPLANE; f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; vdev->ioctl_ops = &imgu_v4l2_ioctl_ops; } vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_IO_MC | cap; } static int imgu_v4l2_subdev_register(struct imgu_device *imgu, struct imgu_v4l2_subdev *imgu_sd, unsigned int pipe) { int i, r; struct v4l2_ctrl_handler *hdl = &imgu_sd->ctrl_handler; struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe]; /* Initialize subdev media entity */ imgu_sd->subdev.entity.ops = &imgu_media_ops; for (i = 0; i < IMGU_NODE_NUM; i++) { imgu_sd->subdev_pads[i].flags = imgu_pipe->nodes[i].output ? MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE; } r = media_entity_pads_init(&imgu_sd->subdev.entity, IMGU_NODE_NUM, imgu_sd->subdev_pads); if (r) { dev_err(&imgu->pci_dev->dev, "failed initialize subdev media entity (%d)\n", r); return r; } /* Initialize subdev */ v4l2_subdev_init(&imgu_sd->subdev, &imgu_subdev_ops); imgu_sd->subdev.entity.function = MEDIA_ENT_F_PROC_VIDEO_STATISTICS; imgu_sd->subdev.internal_ops = &imgu_subdev_internal_ops; imgu_sd->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS; snprintf(imgu_sd->subdev.name, sizeof(imgu_sd->subdev.name), "%s %u", IMGU_NAME, pipe); v4l2_set_subdevdata(&imgu_sd->subdev, imgu); atomic_set(&imgu_sd->running_mode, IPU3_RUNNING_MODE_VIDEO); v4l2_ctrl_handler_init(hdl, 1); imgu_sd->subdev.ctrl_handler = hdl; imgu_sd->ctrl = v4l2_ctrl_new_custom(hdl, &imgu_subdev_ctrl_mode, NULL); if (hdl->error) { r = hdl->error; dev_err(&imgu->pci_dev->dev, "failed to create subdev v4l2 ctrl with err %d", r); goto fail_subdev; } r = v4l2_device_register_subdev(&imgu->v4l2_dev, &imgu_sd->subdev); if (r) { dev_err(&imgu->pci_dev->dev, "failed initialize subdev (%d)\n", r); goto fail_subdev; } imgu_sd->pipe = pipe; return 0; fail_subdev: v4l2_ctrl_handler_free(imgu_sd->subdev.ctrl_handler); media_entity_cleanup(&imgu_sd->subdev.entity); return r; } static int imgu_v4l2_node_setup(struct imgu_device *imgu, unsigned int pipe, int node_num) { int r; u32 flags; struct v4l2_mbus_framefmt def_bus_fmt = { 0 }; struct v4l2_pix_format_mplane def_pix_fmt = { 0 }; struct device *dev = &imgu->pci_dev->dev; struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe]; struct v4l2_subdev *sd = &imgu_pipe->imgu_sd.subdev; struct imgu_video_device *node = &imgu_pipe->nodes[node_num]; struct video_device *vdev = &node->vdev; struct vb2_queue *vbq = &node->vbq; /* Initialize formats to default values */ def_bus_fmt.width = 1920; def_bus_fmt.height = 1080; def_bus_fmt.code = MEDIA_BUS_FMT_FIXED; def_bus_fmt.field = V4L2_FIELD_NONE; def_bus_fmt.colorspace = V4L2_COLORSPACE_RAW; def_bus_fmt.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; def_bus_fmt.quantization = V4L2_QUANTIZATION_DEFAULT; def_bus_fmt.xfer_func = V4L2_XFER_FUNC_DEFAULT; def_pix_fmt.width = def_bus_fmt.width; def_pix_fmt.height = def_bus_fmt.height; def_pix_fmt.field = def_bus_fmt.field; def_pix_fmt.num_planes = 1; def_pix_fmt.plane_fmt[0].bytesperline = imgu_bytesperline(def_pix_fmt.width, IMGU_ABI_FRAME_FORMAT_RAW_PACKED); def_pix_fmt.plane_fmt[0].sizeimage = def_pix_fmt.height * def_pix_fmt.plane_fmt[0].bytesperline; def_pix_fmt.flags = 0; def_pix_fmt.colorspace = def_bus_fmt.colorspace; def_pix_fmt.ycbcr_enc = def_bus_fmt.ycbcr_enc; def_pix_fmt.quantization = def_bus_fmt.quantization; def_pix_fmt.xfer_func = def_bus_fmt.xfer_func; /* Initialize miscellaneous variables */ mutex_init(&node->lock); INIT_LIST_HEAD(&node->buffers); /* Initialize formats to default values */ node->pad_fmt = def_bus_fmt; node->id = node_num; node->pipe = pipe; imgu_node_to_v4l2(node_num, vdev, &node->vdev_fmt); if (node->vdev_fmt.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE || node->vdev_fmt.type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) { def_pix_fmt.pixelformat = node->output ? V4L2_PIX_FMT_IPU3_SGRBG10 : V4L2_PIX_FMT_NV12; node->vdev_fmt.fmt.pix_mp = def_pix_fmt; } /* Initialize media entities */ node->vdev_pad.flags = node->output ? MEDIA_PAD_FL_SOURCE : MEDIA_PAD_FL_SINK; vdev->entity.ops = NULL; r = media_entity_pads_init(&vdev->entity, 1, &node->vdev_pad); if (r) { dev_err(dev, "failed initialize media entity (%d)\n", r); mutex_destroy(&node->lock); return r; } /* Initialize vbq */ vbq->type = node->vdev_fmt.type; vbq->io_modes = VB2_USERPTR | VB2_MMAP | VB2_DMABUF; vbq->ops = &imgu_vb2_ops; vbq->mem_ops = &vb2_dma_sg_memops; if (imgu->buf_struct_size <= 0) imgu->buf_struct_size = sizeof(struct imgu_vb2_buffer); vbq->buf_struct_size = imgu->buf_struct_size; vbq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; /* can streamon w/o buffers */ vbq->min_queued_buffers = 0; vbq->drv_priv = imgu; vbq->lock = &node->lock; r = vb2_queue_init(vbq); if (r) { dev_err(dev, "failed to initialize video queue (%d)", r); media_entity_cleanup(&vdev->entity); return r; } /* Initialize vdev */ snprintf(vdev->name, sizeof(vdev->name), "%s %u %s", IMGU_NAME, pipe, node->name); vdev->release = video_device_release_empty; vdev->fops = &imgu_v4l2_fops; vdev->lock = &node->lock; vdev->v4l2_dev = &imgu->v4l2_dev; vdev->queue = &node->vbq; vdev->vfl_dir = node->output ? VFL_DIR_TX : VFL_DIR_RX; video_set_drvdata(vdev, imgu); r = video_register_device(vdev, VFL_TYPE_VIDEO, -1); if (r) { dev_err(dev, "failed to register video device (%d)", r); media_entity_cleanup(&vdev->entity); return r; } /* Create link between video node and the subdev pad */ flags = 0; if (node->enabled) flags |= MEDIA_LNK_FL_ENABLED; if (node->output) { r = media_create_pad_link(&vdev->entity, 0, &sd->entity, node_num, flags); } else { if (node->id == IMGU_NODE_OUT) { flags |= MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE; node->enabled = true; } r = media_create_pad_link(&sd->entity, node_num, &vdev->entity, 0, flags); } if (r) { dev_err(dev, "failed to create pad link (%d)", r); video_unregister_device(vdev); return r; } return 0; } static void imgu_v4l2_nodes_cleanup_pipe(struct imgu_device *imgu, unsigned int pipe, int node) { int i; struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe]; for (i = 0; i < node; i++) { video_unregister_device(&imgu_pipe->nodes[i].vdev); media_entity_cleanup(&imgu_pipe->nodes[i].vdev.entity); mutex_destroy(&imgu_pipe->nodes[i].lock); } } static int imgu_v4l2_nodes_setup_pipe(struct imgu_device *imgu, int pipe) { int i; for (i = 0; i < IMGU_NODE_NUM; i++) { int r = imgu_v4l2_node_setup(imgu, pipe, i); if (r) { imgu_v4l2_nodes_cleanup_pipe(imgu, pipe, i); return r; } } return 0; } static void imgu_v4l2_subdev_cleanup(struct imgu_device *imgu, unsigned int i) { struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[i]; v4l2_device_unregister_subdev(&imgu_pipe->imgu_sd.subdev); v4l2_ctrl_handler_free(imgu_pipe->imgu_sd.subdev.ctrl_handler); media_entity_cleanup(&imgu_pipe->imgu_sd.subdev.entity); } static void imgu_v4l2_cleanup_pipes(struct imgu_device *imgu, unsigned int pipe) { int i; for (i = 0; i < pipe; i++) { imgu_v4l2_nodes_cleanup_pipe(imgu, i, IMGU_NODE_NUM); imgu_v4l2_subdev_cleanup(imgu, i); } } static int imgu_v4l2_register_pipes(struct imgu_device *imgu) { struct imgu_media_pipe *imgu_pipe; int i, r; for (i = 0; i < IMGU_MAX_PIPE_NUM; i++) { imgu_pipe = &imgu->imgu_pipe[i]; r = imgu_v4l2_subdev_register(imgu, &imgu_pipe->imgu_sd, i); if (r) { dev_err(&imgu->pci_dev->dev, "failed to register subdev%u ret (%d)\n", i, r); goto pipes_cleanup; } r = imgu_v4l2_nodes_setup_pipe(imgu, i); if (r) { imgu_v4l2_subdev_cleanup(imgu, i); goto pipes_cleanup; } } return 0; pipes_cleanup: imgu_v4l2_cleanup_pipes(imgu, i); return r; } int imgu_v4l2_register(struct imgu_device *imgu) { int r; /* Initialize miscellaneous variables */ imgu->streaming = false; /* Set up media device */ media_device_pci_init(&imgu->media_dev, imgu->pci_dev, IMGU_NAME); /* Set up v4l2 device */ imgu->v4l2_dev.mdev = &imgu->media_dev; imgu->v4l2_dev.ctrl_handler = NULL; r = v4l2_device_register(&imgu->pci_dev->dev, &imgu->v4l2_dev); if (r) { dev_err(&imgu->pci_dev->dev, "failed to register V4L2 device (%d)\n", r); goto fail_v4l2_dev; } r = imgu_v4l2_register_pipes(imgu); if (r) { dev_err(&imgu->pci_dev->dev, "failed to register pipes (%d)\n", r); goto fail_v4l2_pipes; } r = v4l2_device_register_subdev_nodes(&imgu->v4l2_dev); if (r) { dev_err(&imgu->pci_dev->dev, "failed to register subdevs (%d)\n", r); goto fail_subdevs; } r = media_device_register(&imgu->media_dev); if (r) { dev_err(&imgu->pci_dev->dev, "failed to register media device (%d)\n", r); goto fail_subdevs; } return 0; fail_subdevs: imgu_v4l2_cleanup_pipes(imgu, IMGU_MAX_PIPE_NUM); fail_v4l2_pipes: v4l2_device_unregister(&imgu->v4l2_dev); fail_v4l2_dev: media_device_cleanup(&imgu->media_dev); return r; } int imgu_v4l2_unregister(struct imgu_device *imgu) { media_device_unregister(&imgu->media_dev); imgu_v4l2_cleanup_pipes(imgu, IMGU_MAX_PIPE_NUM); v4l2_device_unregister(&imgu->v4l2_dev); media_device_cleanup(&imgu->media_dev); return 0; } void imgu_v4l2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state) { struct imgu_vb2_buffer *b = container_of(vb, struct imgu_vb2_buffer, vbb.vb2_buf); list_del(&b->list); vb2_buffer_done(&b->vbb.vb2_buf, state); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1