2 * Samsung EXYNOS4x12 FIMC-IS (Imaging Subsystem) driver
4 * FIMC-IS ISP video input and video output DMA interface driver
6 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
7 * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
9 * The hardware handling code derived from a driver written by
10 * Younghwan Joo <yhwan.joo@samsung.com>.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
17 #include <linux/bitops.h>
18 #include <linux/device.h>
19 #include <linux/delay.h>
20 #include <linux/errno.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/printk.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/slab.h>
27 #include <linux/videodev2.h>
29 #include <media/v4l2-device.h>
30 #include <media/v4l2-ioctl.h>
31 #include <media/videobuf2-core.h>
32 #include <media/videobuf2-dma-contig.h>
33 #include <media/s5p_fimc.h>
36 #include "media-dev.h"
38 #include "fimc-isp-video.h"
39 #include "fimc-is-param.h"
41 static int isp_video_capture_queue_setup(struct vb2_queue
*vq
,
42 const struct v4l2_format
*pfmt
,
43 unsigned int *num_buffers
, unsigned int *num_planes
,
44 unsigned int sizes
[], void *allocators
[])
46 struct fimc_isp
*isp
= vb2_get_drv_priv(vq
);
47 struct v4l2_pix_format_mplane
*vid_fmt
= &isp
->video_capture
.pixfmt
;
48 const struct v4l2_pix_format_mplane
*pixm
= NULL
;
49 const struct fimc_fmt
*fmt
;
53 pixm
= &pfmt
->fmt
.pix_mp
;
54 fmt
= fimc_isp_find_format(&pixm
->pixelformat
, NULL
, -1);
55 wh
= pixm
->width
* pixm
->height
;
57 fmt
= isp
->video_capture
.format
;
58 wh
= vid_fmt
->width
* vid_fmt
->height
;
64 *num_buffers
= clamp_t(u32
, *num_buffers
, FIMC_ISP_REQ_BUFS_MIN
,
65 FIMC_ISP_REQ_BUFS_MAX
);
66 *num_planes
= fmt
->memplanes
;
68 for (i
= 0; i
< fmt
->memplanes
; i
++) {
69 unsigned int size
= (wh
* fmt
->depth
[i
]) / 8;
71 sizes
[i
] = max(size
, pixm
->plane_fmt
[i
].sizeimage
);
74 allocators
[i
] = isp
->alloc_ctx
;
80 static inline struct param_dma_output
*__get_isp_dma2(struct fimc_is
*is
)
82 return &__get_curr_is_config(is
)->isp
.dma2_output
;
85 static int isp_video_capture_start_streaming(struct vb2_queue
*q
,
88 struct fimc_isp
*isp
= vb2_get_drv_priv(q
);
89 struct fimc_is
*is
= fimc_isp_to_is(isp
);
90 struct param_dma_output
*dma
= __get_isp_dma2(is
);
91 struct fimc_is_video
*video
= &isp
->video_capture
;
94 if (!test_bit(ST_ISP_VID_CAP_BUF_PREP
, &isp
->state
) ||
95 test_bit(ST_ISP_VID_CAP_STREAMING
, &isp
->state
))
99 dma
->cmd
= DMA_OUTPUT_COMMAND_ENABLE
;
100 dma
->notify_dma_done
= DMA_OUTPUT_NOTIFY_DMA_DONE_ENABLE
;
101 dma
->buffer_address
= is
->is_dma_p_region
+
102 DMA2_OUTPUT_ADDR_ARRAY_OFFS
;
103 dma
->buffer_number
= video
->reqbufs_count
;
104 dma
->dma_out_mask
= video
->buf_mask
;
106 isp_dbg(2, &video
->ve
.vdev
,
107 "buf_count: %d, planes: %d, dma addr table: %#x\n",
108 video
->buf_count
, video
->format
->memplanes
,
109 dma
->buffer_address
);
111 fimc_is_mem_barrier();
113 fimc_is_set_param_bit(is
, PARAM_ISP_DMA2_OUTPUT
);
114 __fimc_is_hw_update_param(is
, PARAM_ISP_DMA2_OUTPUT
);
116 ret
= fimc_is_itf_s_param(is
, false);
120 ret
= fimc_pipeline_call(&video
->ve
, set_stream
, 1);
124 set_bit(ST_ISP_VID_CAP_STREAMING
, &isp
->state
);
128 static void isp_video_capture_stop_streaming(struct vb2_queue
*q
)
130 struct fimc_isp
*isp
= vb2_get_drv_priv(q
);
131 struct fimc_is
*is
= fimc_isp_to_is(isp
);
132 struct param_dma_output
*dma
= __get_isp_dma2(is
);
135 ret
= fimc_pipeline_call(&isp
->video_capture
.ve
, set_stream
, 0);
139 dma
->cmd
= DMA_OUTPUT_COMMAND_DISABLE
;
140 dma
->notify_dma_done
= DMA_OUTPUT_NOTIFY_DMA_DONE_DISABLE
;
141 dma
->buffer_number
= 0;
142 dma
->buffer_address
= 0;
143 dma
->dma_out_mask
= 0;
145 fimc_is_set_param_bit(is
, PARAM_ISP_DMA2_OUTPUT
);
146 __fimc_is_hw_update_param(is
, PARAM_ISP_DMA2_OUTPUT
);
148 ret
= fimc_is_itf_s_param(is
, false);
150 dev_warn(&is
->pdev
->dev
, "%s: DMA stop failed\n", __func__
);
152 fimc_is_hw_set_isp_buf_mask(is
, 0);
154 clear_bit(ST_ISP_VID_CAP_BUF_PREP
, &isp
->state
);
155 clear_bit(ST_ISP_VID_CAP_STREAMING
, &isp
->state
);
157 isp
->video_capture
.buf_count
= 0;
160 static int isp_video_capture_buffer_prepare(struct vb2_buffer
*vb
)
162 struct fimc_isp
*isp
= vb2_get_drv_priv(vb
->vb2_queue
);
163 struct fimc_is_video
*video
= &isp
->video_capture
;
166 if (video
->format
== NULL
)
169 for (i
= 0; i
< video
->format
->memplanes
; i
++) {
170 unsigned long size
= video
->pixfmt
.plane_fmt
[i
].sizeimage
;
172 if (vb2_plane_size(vb
, i
) < size
) {
173 v4l2_err(&video
->ve
.vdev
,
174 "User buffer too small (%ld < %ld)\n",
175 vb2_plane_size(vb
, i
), size
);
178 vb2_set_plane_payload(vb
, i
, size
);
181 /* Check if we get one of the already known buffers. */
182 if (test_bit(ST_ISP_VID_CAP_BUF_PREP
, &isp
->state
)) {
183 dma_addr_t dma_addr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
186 for (i
= 0; i
< video
->buf_count
; i
++)
187 if (video
->buffers
[i
]->dma_addr
[0] == dma_addr
)
195 static void isp_video_capture_buffer_queue(struct vb2_buffer
*vb
)
197 struct fimc_isp
*isp
= vb2_get_drv_priv(vb
->vb2_queue
);
198 struct fimc_is_video
*video
= &isp
->video_capture
;
199 struct fimc_is
*is
= fimc_isp_to_is(isp
);
200 struct isp_video_buf
*ivb
= to_isp_video_buf(vb
);
204 if (test_bit(ST_ISP_VID_CAP_BUF_PREP
, &isp
->state
)) {
205 spin_lock_irqsave(&is
->slock
, flags
);
206 video
->buf_mask
|= BIT(ivb
->index
);
207 spin_unlock_irqrestore(&is
->slock
, flags
);
209 unsigned int num_planes
= video
->format
->memplanes
;
211 ivb
->index
= video
->buf_count
;
212 video
->buffers
[ivb
->index
] = ivb
;
214 for (i
= 0; i
< num_planes
; i
++) {
215 int buf_index
= ivb
->index
* num_planes
+ i
;
217 ivb
->dma_addr
[i
] = vb2_dma_contig_plane_dma_addr(vb
, i
);
218 is
->is_p_region
->shared
[32 + buf_index
] =
221 isp_dbg(2, &video
->ve
.vdev
,
222 "dma_buf %d (%d/%d/%d) addr: %#x\n",
223 buf_index
, ivb
->index
, i
, vb
->v4l2_buf
.index
,
227 if (++video
->buf_count
< video
->reqbufs_count
)
230 video
->buf_mask
= (1UL << video
->buf_count
) - 1;
231 set_bit(ST_ISP_VID_CAP_BUF_PREP
, &isp
->state
);
234 if (!test_bit(ST_ISP_VID_CAP_STREAMING
, &isp
->state
))
235 isp_video_capture_start_streaming(vb
->vb2_queue
, 0);
239 * FIMC-IS ISP input and output DMA interface interrupt handler.
240 * Locking: called with is->slock spinlock held.
242 void fimc_isp_video_irq_handler(struct fimc_is
*is
)
244 struct fimc_is_video
*video
= &is
->isp
.video_capture
;
245 struct vb2_buffer
*vb
;
248 /* TODO: Ensure the DMA is really stopped in stop_streaming callback */
249 if (!test_bit(ST_ISP_VID_CAP_STREAMING
, &is
->isp
.state
))
252 buf_index
= (is
->i2h_cmd
.args
[1] - 1) % video
->buf_count
;
253 vb
= &video
->buffers
[buf_index
]->vb
;
255 v4l2_get_timestamp(&vb
->v4l2_buf
.timestamp
);
256 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
258 video
->buf_mask
&= ~BIT(buf_index
);
259 fimc_is_hw_set_isp_buf_mask(is
, video
->buf_mask
);
262 static const struct vb2_ops isp_video_capture_qops
= {
263 .queue_setup
= isp_video_capture_queue_setup
,
264 .buf_prepare
= isp_video_capture_buffer_prepare
,
265 .buf_queue
= isp_video_capture_buffer_queue
,
266 .wait_prepare
= vb2_ops_wait_prepare
,
267 .wait_finish
= vb2_ops_wait_finish
,
268 .start_streaming
= isp_video_capture_start_streaming
,
269 .stop_streaming
= isp_video_capture_stop_streaming
,
272 static int isp_video_open(struct file
*file
)
274 struct fimc_isp
*isp
= video_drvdata(file
);
275 struct exynos_video_entity
*ve
= &isp
->video_capture
.ve
;
276 struct media_entity
*me
= &ve
->vdev
.entity
;
279 if (mutex_lock_interruptible(&isp
->video_lock
))
282 ret
= v4l2_fh_open(file
);
286 ret
= pm_runtime_get_sync(&isp
->pdev
->dev
);
290 if (v4l2_fh_is_singular_file(file
)) {
291 mutex_lock(&me
->parent
->graph_mutex
);
293 ret
= fimc_pipeline_call(ve
, open
, me
, true);
295 /* Mark the video pipeline as in use. */
299 mutex_unlock(&me
->parent
->graph_mutex
);
304 v4l2_fh_release(file
);
306 mutex_unlock(&isp
->video_lock
);
310 static int isp_video_release(struct file
*file
)
312 struct fimc_isp
*isp
= video_drvdata(file
);
313 struct fimc_is_video
*ivc
= &isp
->video_capture
;
314 struct media_entity
*entity
= &ivc
->ve
.vdev
.entity
;
315 struct media_device
*mdev
= entity
->parent
;
318 mutex_lock(&isp
->video_lock
);
320 if (v4l2_fh_is_singular_file(file
) && ivc
->streaming
) {
321 media_entity_pipeline_stop(entity
);
325 vb2_fop_release(file
);
327 if (v4l2_fh_is_singular_file(file
)) {
328 fimc_pipeline_call(&ivc
->ve
, close
);
330 mutex_lock(&mdev
->graph_mutex
);
332 mutex_unlock(&mdev
->graph_mutex
);
335 pm_runtime_put(&isp
->pdev
->dev
);
336 mutex_unlock(&isp
->video_lock
);
341 static const struct v4l2_file_operations isp_video_fops
= {
342 .owner
= THIS_MODULE
,
343 .open
= isp_video_open
,
344 .release
= isp_video_release
,
345 .poll
= vb2_fop_poll
,
346 .unlocked_ioctl
= video_ioctl2
,
347 .mmap
= vb2_fop_mmap
,
351 * Video node ioctl operations
353 static int isp_video_querycap(struct file
*file
, void *priv
,
354 struct v4l2_capability
*cap
)
356 struct fimc_isp
*isp
= video_drvdata(file
);
358 __fimc_vidioc_querycap(&isp
->pdev
->dev
, cap
, V4L2_CAP_STREAMING
);
362 static int isp_video_enum_fmt_mplane(struct file
*file
, void *priv
,
363 struct v4l2_fmtdesc
*f
)
365 const struct fimc_fmt
*fmt
;
367 if (f
->index
>= FIMC_ISP_NUM_FORMATS
)
370 fmt
= fimc_isp_find_format(NULL
, NULL
, f
->index
);
371 if (WARN_ON(fmt
== NULL
))
374 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
375 f
->pixelformat
= fmt
->fourcc
;
380 static int isp_video_g_fmt_mplane(struct file
*file
, void *fh
,
381 struct v4l2_format
*f
)
383 struct fimc_isp
*isp
= video_drvdata(file
);
385 f
->fmt
.pix_mp
= isp
->video_capture
.pixfmt
;
389 static void __isp_video_try_fmt(struct fimc_isp
*isp
,
390 struct v4l2_pix_format_mplane
*pixm
,
391 const struct fimc_fmt
**fmt
)
393 *fmt
= fimc_isp_find_format(&pixm
->pixelformat
, NULL
, 2);
395 pixm
->colorspace
= V4L2_COLORSPACE_SRGB
;
396 pixm
->field
= V4L2_FIELD_NONE
;
397 pixm
->num_planes
= (*fmt
)->memplanes
;
398 pixm
->pixelformat
= (*fmt
)->fourcc
;
400 * TODO: double check with the docmentation these width/height
401 * constraints are correct.
403 v4l_bound_align_image(&pixm
->width
, FIMC_ISP_SOURCE_WIDTH_MIN
,
404 FIMC_ISP_SOURCE_WIDTH_MAX
, 3,
405 &pixm
->height
, FIMC_ISP_SOURCE_HEIGHT_MIN
,
406 FIMC_ISP_SOURCE_HEIGHT_MAX
, 0, 0);
409 static int isp_video_try_fmt_mplane(struct file
*file
, void *fh
,
410 struct v4l2_format
*f
)
412 struct fimc_isp
*isp
= video_drvdata(file
);
414 __isp_video_try_fmt(isp
, &f
->fmt
.pix_mp
, NULL
);
418 static int isp_video_s_fmt_mplane(struct file
*file
, void *priv
,
419 struct v4l2_format
*f
)
421 struct fimc_isp
*isp
= video_drvdata(file
);
422 struct fimc_is
*is
= fimc_isp_to_is(isp
);
423 struct v4l2_pix_format_mplane
*pixm
= &f
->fmt
.pix_mp
;
424 const struct fimc_fmt
*ifmt
= NULL
;
425 struct param_dma_output
*dma
= __get_isp_dma2(is
);
427 __isp_video_try_fmt(isp
, pixm
, &ifmt
);
429 if (WARN_ON(ifmt
== NULL
))
432 dma
->format
= DMA_OUTPUT_FORMAT_BAYER
;
433 dma
->order
= DMA_OUTPUT_ORDER_GB_BG
;
434 dma
->plane
= ifmt
->memplanes
;
435 dma
->bitwidth
= ifmt
->depth
[0];
436 dma
->width
= pixm
->width
;
437 dma
->height
= pixm
->height
;
439 fimc_is_mem_barrier();
441 isp
->video_capture
.format
= ifmt
;
442 isp
->video_capture
.pixfmt
= *pixm
;
448 * Check for source/sink format differences at each link.
449 * Return 0 if the formats match or -EPIPE otherwise.
451 static int isp_video_pipeline_validate(struct fimc_isp
*isp
)
453 struct v4l2_subdev
*sd
= &isp
->subdev
;
454 struct v4l2_subdev_format sink_fmt
, src_fmt
;
455 struct media_pad
*pad
;
459 /* Retrieve format at the sink pad */
460 pad
= &sd
->entity
.pads
[0];
461 if (!(pad
->flags
& MEDIA_PAD_FL_SINK
))
463 sink_fmt
.pad
= pad
->index
;
464 sink_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
465 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &sink_fmt
);
466 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
469 /* Retrieve format at the source pad */
470 pad
= media_entity_remote_pad(pad
);
472 media_entity_type(pad
->entity
) != MEDIA_ENT_T_V4L2_SUBDEV
)
475 sd
= media_entity_to_v4l2_subdev(pad
->entity
);
476 src_fmt
.pad
= pad
->index
;
477 src_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
478 ret
= v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, &src_fmt
);
479 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
482 if (src_fmt
.format
.width
!= sink_fmt
.format
.width
||
483 src_fmt
.format
.height
!= sink_fmt
.format
.height
||
484 src_fmt
.format
.code
!= sink_fmt
.format
.code
)
491 static int isp_video_streamon(struct file
*file
, void *priv
,
492 enum v4l2_buf_type type
)
494 struct fimc_isp
*isp
= video_drvdata(file
);
495 struct exynos_video_entity
*ve
= &isp
->video_capture
.ve
;
496 struct media_entity
*me
= &ve
->vdev
.entity
;
499 ret
= media_entity_pipeline_start(me
, &ve
->pipe
->mp
);
503 ret
= isp_video_pipeline_validate(isp
);
507 ret
= vb2_ioctl_streamon(file
, priv
, type
);
511 isp
->video_capture
.streaming
= 1;
514 media_entity_pipeline_stop(me
);
518 static int isp_video_streamoff(struct file
*file
, void *priv
,
519 enum v4l2_buf_type type
)
521 struct fimc_isp
*isp
= video_drvdata(file
);
522 struct fimc_is_video
*video
= &isp
->video_capture
;
525 ret
= vb2_ioctl_streamoff(file
, priv
, type
);
529 media_entity_pipeline_stop(&video
->ve
.vdev
.entity
);
530 video
->streaming
= 0;
534 static int isp_video_reqbufs(struct file
*file
, void *priv
,
535 struct v4l2_requestbuffers
*rb
)
537 struct fimc_isp
*isp
= video_drvdata(file
);
540 ret
= vb2_ioctl_reqbufs(file
, priv
, rb
);
544 if (rb
->count
&& rb
->count
< FIMC_ISP_REQ_BUFS_MIN
) {
546 vb2_ioctl_reqbufs(file
, priv
, rb
);
550 isp
->video_capture
.reqbufs_count
= rb
->count
;
554 static const struct v4l2_ioctl_ops isp_video_ioctl_ops
= {
555 .vidioc_querycap
= isp_video_querycap
,
556 .vidioc_enum_fmt_vid_cap_mplane
= isp_video_enum_fmt_mplane
,
557 .vidioc_try_fmt_vid_cap_mplane
= isp_video_try_fmt_mplane
,
558 .vidioc_s_fmt_vid_cap_mplane
= isp_video_s_fmt_mplane
,
559 .vidioc_g_fmt_vid_cap_mplane
= isp_video_g_fmt_mplane
,
560 .vidioc_reqbufs
= isp_video_reqbufs
,
561 .vidioc_querybuf
= vb2_ioctl_querybuf
,
562 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
563 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
564 .vidioc_qbuf
= vb2_ioctl_qbuf
,
565 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
566 .vidioc_streamon
= isp_video_streamon
,
567 .vidioc_streamoff
= isp_video_streamoff
,
570 int fimc_isp_video_device_register(struct fimc_isp
*isp
,
571 struct v4l2_device
*v4l2_dev
,
572 enum v4l2_buf_type type
)
574 struct vb2_queue
*q
= &isp
->video_capture
.vb_queue
;
575 struct fimc_is_video
*iv
;
576 struct video_device
*vdev
;
579 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
580 iv
= &isp
->video_capture
;
584 mutex_init(&isp
->video_lock
);
585 INIT_LIST_HEAD(&iv
->pending_buf_q
);
586 INIT_LIST_HEAD(&iv
->active_buf_q
);
587 iv
->format
= fimc_isp_find_format(NULL
, NULL
, 0);
588 iv
->pixfmt
.width
= IS_DEFAULT_WIDTH
;
589 iv
->pixfmt
.height
= IS_DEFAULT_HEIGHT
;
590 iv
->pixfmt
.pixelformat
= iv
->format
->fourcc
;
591 iv
->pixfmt
.colorspace
= V4L2_COLORSPACE_SRGB
;
592 iv
->reqbufs_count
= 0;
594 memset(q
, 0, sizeof(*q
));
596 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
597 q
->ops
= &isp_video_capture_qops
;
598 q
->mem_ops
= &vb2_dma_contig_memops
;
599 q
->buf_struct_size
= sizeof(struct isp_video_buf
);
601 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
602 q
->lock
= &isp
->video_lock
;
604 ret
= vb2_queue_init(q
);
609 memset(vdev
, 0, sizeof(*vdev
));
610 snprintf(vdev
->name
, sizeof(vdev
->name
), "fimc-is-isp.%s",
611 type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
?
612 "capture" : "output");
614 vdev
->fops
= &isp_video_fops
;
615 vdev
->ioctl_ops
= &isp_video_ioctl_ops
;
616 vdev
->v4l2_dev
= v4l2_dev
;
618 vdev
->release
= video_device_release_empty
;
619 vdev
->lock
= &isp
->video_lock
;
621 iv
->pad
.flags
= MEDIA_PAD_FL_SINK
;
622 ret
= media_entity_init(&vdev
->entity
, 1, &iv
->pad
, 0);
626 video_set_drvdata(vdev
, isp
);
628 ret
= video_register_device(vdev
, VFL_TYPE_GRABBER
, -1);
630 media_entity_cleanup(&vdev
->entity
);
634 v4l2_info(v4l2_dev
, "Registered %s as /dev/%s\n",
635 vdev
->name
, video_device_node_name(vdev
));
640 void fimc_isp_video_device_unregister(struct fimc_isp
*isp
,
641 enum v4l2_buf_type type
)
643 struct exynos_video_entity
*ve
;
645 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
646 ve
= &isp
->video_capture
.ve
;
650 mutex_lock(&isp
->video_lock
);
652 if (video_is_registered(&ve
->vdev
)) {
653 video_unregister_device(&ve
->vdev
);
654 media_entity_cleanup(&ve
->vdev
.entity
);
658 mutex_unlock(&isp
->video_lock
);