2 * Copyright (c) 2011 - 2012 Samsung Electronics Co., Ltd.
3 * http://www.samsung.com
5 * Samsung EXYNOS5 SoC series G-Scaler driver
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation, either version 2 of the License,
10 * or (at your option) any later version.
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/bug.h>
18 #include <linux/interrupt.h>
19 #include <linux/workqueue.h>
20 #include <linux/device.h>
21 #include <linux/platform_device.h>
22 #include <linux/list.h>
24 #include <linux/slab.h>
25 #include <linux/clk.h>
27 #include <media/v4l2-ioctl.h>
31 static int gsc_m2m_ctx_stop_req(struct gsc_ctx
*ctx
)
33 struct gsc_ctx
*curr_ctx
;
34 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
37 curr_ctx
= v4l2_m2m_get_curr_priv(gsc
->m2m
.m2m_dev
);
38 if (!gsc_m2m_pending(gsc
) || (curr_ctx
!= ctx
))
41 gsc_ctx_state_lock_set(GSC_CTX_STOP_REQ
, ctx
);
42 ret
= wait_event_timeout(gsc
->irq_queue
,
43 !gsc_ctx_state_is_set(GSC_CTX_STOP_REQ
, ctx
),
44 GSC_SHUTDOWN_TIMEOUT
);
46 return ret
== 0 ? -ETIMEDOUT
: ret
;
49 static void __gsc_m2m_job_abort(struct gsc_ctx
*ctx
)
53 ret
= gsc_m2m_ctx_stop_req(ctx
);
54 if ((ret
== -ETIMEDOUT
) || (ctx
->state
& GSC_CTX_ABORT
)) {
55 gsc_ctx_state_lock_clear(GSC_CTX_STOP_REQ
| GSC_CTX_ABORT
, ctx
);
56 gsc_m2m_job_finish(ctx
, VB2_BUF_STATE_ERROR
);
60 static int gsc_m2m_start_streaming(struct vb2_queue
*q
, unsigned int count
)
62 struct gsc_ctx
*ctx
= q
->drv_priv
;
65 ret
= pm_runtime_get_sync(&ctx
->gsc_dev
->pdev
->dev
);
66 return ret
> 0 ? 0 : ret
;
69 static void __gsc_m2m_cleanup_queue(struct gsc_ctx
*ctx
)
71 struct vb2_v4l2_buffer
*src_vb
, *dst_vb
;
73 while (v4l2_m2m_num_src_bufs_ready(ctx
->m2m_ctx
) > 0) {
74 src_vb
= v4l2_m2m_src_buf_remove(ctx
->m2m_ctx
);
75 v4l2_m2m_buf_done(src_vb
, VB2_BUF_STATE_ERROR
);
78 while (v4l2_m2m_num_dst_bufs_ready(ctx
->m2m_ctx
) > 0) {
79 dst_vb
= v4l2_m2m_dst_buf_remove(ctx
->m2m_ctx
);
80 v4l2_m2m_buf_done(dst_vb
, VB2_BUF_STATE_ERROR
);
84 static void gsc_m2m_stop_streaming(struct vb2_queue
*q
)
86 struct gsc_ctx
*ctx
= q
->drv_priv
;
88 __gsc_m2m_job_abort(ctx
);
90 __gsc_m2m_cleanup_queue(ctx
);
92 pm_runtime_put(&ctx
->gsc_dev
->pdev
->dev
);
95 void gsc_m2m_job_finish(struct gsc_ctx
*ctx
, int vb_state
)
97 struct vb2_v4l2_buffer
*src_vb
, *dst_vb
;
99 if (!ctx
|| !ctx
->m2m_ctx
)
102 src_vb
= v4l2_m2m_src_buf_remove(ctx
->m2m_ctx
);
103 dst_vb
= v4l2_m2m_dst_buf_remove(ctx
->m2m_ctx
);
105 if (src_vb
&& dst_vb
) {
106 dst_vb
->vb2_buf
.timestamp
= src_vb
->vb2_buf
.timestamp
;
107 dst_vb
->timecode
= src_vb
->timecode
;
108 dst_vb
->flags
&= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
111 & V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
113 v4l2_m2m_buf_done(src_vb
, vb_state
);
114 v4l2_m2m_buf_done(dst_vb
, vb_state
);
116 v4l2_m2m_job_finish(ctx
->gsc_dev
->m2m
.m2m_dev
,
121 static void gsc_m2m_job_abort(void *priv
)
123 __gsc_m2m_job_abort((struct gsc_ctx
*)priv
);
126 static int gsc_get_bufs(struct gsc_ctx
*ctx
)
128 struct gsc_frame
*s_frame
, *d_frame
;
129 struct vb2_v4l2_buffer
*src_vb
, *dst_vb
;
132 s_frame
= &ctx
->s_frame
;
133 d_frame
= &ctx
->d_frame
;
135 src_vb
= v4l2_m2m_next_src_buf(ctx
->m2m_ctx
);
136 ret
= gsc_prepare_addr(ctx
, &src_vb
->vb2_buf
, s_frame
, &s_frame
->addr
);
140 dst_vb
= v4l2_m2m_next_dst_buf(ctx
->m2m_ctx
);
141 ret
= gsc_prepare_addr(ctx
, &dst_vb
->vb2_buf
, d_frame
, &d_frame
->addr
);
145 dst_vb
->vb2_buf
.timestamp
= src_vb
->vb2_buf
.timestamp
;
150 static void gsc_m2m_device_run(void *priv
)
152 struct gsc_ctx
*ctx
= priv
;
158 if (WARN(!ctx
, "null hardware context\n"))
162 spin_lock_irqsave(&gsc
->slock
, flags
);
164 set_bit(ST_M2M_PEND
, &gsc
->state
);
166 /* Reconfigure hardware if the context has changed. */
167 if (gsc
->m2m
.ctx
!= ctx
) {
168 pr_debug("gsc->m2m.ctx = 0x%p, current_ctx = 0x%p",
170 ctx
->state
|= GSC_PARAMS
;
174 is_set
= ctx
->state
& GSC_CTX_STOP_REQ
;
176 ctx
->state
&= ~GSC_CTX_STOP_REQ
;
177 ctx
->state
|= GSC_CTX_ABORT
;
178 wake_up(&gsc
->irq_queue
);
182 ret
= gsc_get_bufs(ctx
);
184 pr_err("Wrong address");
188 gsc_set_prefbuf(gsc
, &ctx
->s_frame
);
189 gsc_hw_set_input_addr(gsc
, &ctx
->s_frame
.addr
, GSC_M2M_BUF_NUM
);
190 gsc_hw_set_output_addr(gsc
, &ctx
->d_frame
.addr
, GSC_M2M_BUF_NUM
);
192 if (ctx
->state
& GSC_PARAMS
) {
193 gsc_hw_set_input_buf_masking(gsc
, GSC_M2M_BUF_NUM
, false);
194 gsc_hw_set_output_buf_masking(gsc
, GSC_M2M_BUF_NUM
, false);
195 gsc_hw_set_frm_done_irq_mask(gsc
, false);
196 gsc_hw_set_gsc_irq_enable(gsc
, true);
198 if (gsc_set_scaler_info(ctx
)) {
199 pr_err("Scaler setup error");
203 gsc_hw_set_input_path(ctx
);
204 gsc_hw_set_in_size(ctx
);
205 gsc_hw_set_in_image_format(ctx
);
207 gsc_hw_set_output_path(ctx
);
208 gsc_hw_set_out_size(ctx
);
209 gsc_hw_set_out_image_format(ctx
);
211 gsc_hw_set_prescaler(ctx
);
212 gsc_hw_set_mainscaler(ctx
);
213 gsc_hw_set_rotation(ctx
);
214 gsc_hw_set_global_alpha(ctx
);
217 /* update shadow registers */
218 gsc_hw_set_sfr_update(ctx
);
220 ctx
->state
&= ~GSC_PARAMS
;
221 gsc_hw_enable_control(gsc
, true);
223 spin_unlock_irqrestore(&gsc
->slock
, flags
);
227 ctx
->state
&= ~GSC_PARAMS
;
228 spin_unlock_irqrestore(&gsc
->slock
, flags
);
231 static int gsc_m2m_queue_setup(struct vb2_queue
*vq
,
232 unsigned int *num_buffers
, unsigned int *num_planes
,
233 unsigned int sizes
[], struct device
*alloc_devs
[])
235 struct gsc_ctx
*ctx
= vb2_get_drv_priv(vq
);
236 struct gsc_frame
*frame
;
239 frame
= ctx_get_frame(ctx
, vq
->type
);
241 return PTR_ERR(frame
);
246 *num_planes
= frame
->fmt
->num_planes
;
247 for (i
= 0; i
< frame
->fmt
->num_planes
; i
++)
248 sizes
[i
] = frame
->payload
[i
];
252 static int gsc_m2m_buf_prepare(struct vb2_buffer
*vb
)
254 struct gsc_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
255 struct gsc_frame
*frame
;
258 frame
= ctx_get_frame(ctx
, vb
->vb2_queue
->type
);
260 return PTR_ERR(frame
);
262 if (!V4L2_TYPE_IS_OUTPUT(vb
->vb2_queue
->type
)) {
263 for (i
= 0; i
< frame
->fmt
->num_planes
; i
++)
264 vb2_set_plane_payload(vb
, i
, frame
->payload
[i
]);
270 static void gsc_m2m_buf_queue(struct vb2_buffer
*vb
)
272 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
273 struct gsc_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
275 pr_debug("ctx: %p, ctx->state: 0x%x", ctx
, ctx
->state
);
278 v4l2_m2m_buf_queue(ctx
->m2m_ctx
, vbuf
);
281 static const struct vb2_ops gsc_m2m_qops
= {
282 .queue_setup
= gsc_m2m_queue_setup
,
283 .buf_prepare
= gsc_m2m_buf_prepare
,
284 .buf_queue
= gsc_m2m_buf_queue
,
285 .wait_prepare
= vb2_ops_wait_prepare
,
286 .wait_finish
= vb2_ops_wait_finish
,
287 .stop_streaming
= gsc_m2m_stop_streaming
,
288 .start_streaming
= gsc_m2m_start_streaming
,
291 static int gsc_m2m_querycap(struct file
*file
, void *fh
,
292 struct v4l2_capability
*cap
)
294 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
295 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
297 strlcpy(cap
->driver
, GSC_MODULE_NAME
, sizeof(cap
->driver
));
298 strlcpy(cap
->card
, GSC_MODULE_NAME
" gscaler", sizeof(cap
->card
));
299 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "platform:%s",
300 dev_name(&gsc
->pdev
->dev
));
301 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_M2M_MPLANE
|
302 V4L2_CAP_VIDEO_CAPTURE_MPLANE
| V4L2_CAP_VIDEO_OUTPUT_MPLANE
;
304 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
308 static int gsc_m2m_enum_fmt_mplane(struct file
*file
, void *priv
,
309 struct v4l2_fmtdesc
*f
)
311 return gsc_enum_fmt_mplane(f
);
314 static int gsc_m2m_g_fmt_mplane(struct file
*file
, void *fh
,
315 struct v4l2_format
*f
)
317 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
319 return gsc_g_fmt_mplane(ctx
, f
);
322 static int gsc_m2m_try_fmt_mplane(struct file
*file
, void *fh
,
323 struct v4l2_format
*f
)
325 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
327 return gsc_try_fmt_mplane(ctx
, f
);
330 static int gsc_m2m_s_fmt_mplane(struct file
*file
, void *fh
,
331 struct v4l2_format
*f
)
333 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
334 struct vb2_queue
*vq
;
335 struct gsc_frame
*frame
;
336 struct v4l2_pix_format_mplane
*pix
;
339 ret
= gsc_m2m_try_fmt_mplane(file
, fh
, f
);
343 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
345 if (vb2_is_streaming(vq
)) {
346 pr_err("queue (%d) busy", f
->type
);
350 if (V4L2_TYPE_IS_OUTPUT(f
->type
))
351 frame
= &ctx
->s_frame
;
353 frame
= &ctx
->d_frame
;
355 pix
= &f
->fmt
.pix_mp
;
356 frame
->fmt
= find_fmt(&pix
->pixelformat
, NULL
, 0);
357 frame
->colorspace
= pix
->colorspace
;
361 for (i
= 0; i
< frame
->fmt
->num_planes
; i
++)
362 frame
->payload
[i
] = pix
->plane_fmt
[i
].sizeimage
;
364 gsc_set_frame_size(frame
, pix
->width
, pix
->height
);
366 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
367 gsc_ctx_state_lock_set(GSC_PARAMS
| GSC_DST_FMT
, ctx
);
369 gsc_ctx_state_lock_set(GSC_PARAMS
| GSC_SRC_FMT
, ctx
);
371 pr_debug("f_w: %d, f_h: %d", frame
->f_width
, frame
->f_height
);
376 static int gsc_m2m_reqbufs(struct file
*file
, void *fh
,
377 struct v4l2_requestbuffers
*reqbufs
)
379 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
380 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
383 max_cnt
= (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) ?
384 gsc
->variant
->in_buf_cnt
: gsc
->variant
->out_buf_cnt
;
385 if (reqbufs
->count
> max_cnt
)
388 return v4l2_m2m_reqbufs(file
, ctx
->m2m_ctx
, reqbufs
);
391 static int gsc_m2m_expbuf(struct file
*file
, void *fh
,
392 struct v4l2_exportbuffer
*eb
)
394 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
395 return v4l2_m2m_expbuf(file
, ctx
->m2m_ctx
, eb
);
398 static int gsc_m2m_querybuf(struct file
*file
, void *fh
,
399 struct v4l2_buffer
*buf
)
401 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
402 return v4l2_m2m_querybuf(file
, ctx
->m2m_ctx
, buf
);
405 static int gsc_m2m_qbuf(struct file
*file
, void *fh
,
406 struct v4l2_buffer
*buf
)
408 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
409 return v4l2_m2m_qbuf(file
, ctx
->m2m_ctx
, buf
);
412 static int gsc_m2m_dqbuf(struct file
*file
, void *fh
,
413 struct v4l2_buffer
*buf
)
415 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
416 return v4l2_m2m_dqbuf(file
, ctx
->m2m_ctx
, buf
);
419 static int gsc_m2m_streamon(struct file
*file
, void *fh
,
420 enum v4l2_buf_type type
)
422 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
424 /* The source and target color format need to be set */
425 if (V4L2_TYPE_IS_OUTPUT(type
)) {
426 if (!gsc_ctx_state_is_set(GSC_SRC_FMT
, ctx
))
428 } else if (!gsc_ctx_state_is_set(GSC_DST_FMT
, ctx
)) {
432 return v4l2_m2m_streamon(file
, ctx
->m2m_ctx
, type
);
435 static int gsc_m2m_streamoff(struct file
*file
, void *fh
,
436 enum v4l2_buf_type type
)
438 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
439 return v4l2_m2m_streamoff(file
, ctx
->m2m_ctx
, type
);
442 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
443 static int is_rectangle_enclosed(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
445 if (a
->left
< b
->left
|| a
->top
< b
->top
)
448 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
451 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
457 static int gsc_m2m_g_selection(struct file
*file
, void *fh
,
458 struct v4l2_selection
*s
)
460 struct gsc_frame
*frame
;
461 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
463 if ((s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) &&
464 (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
))
467 frame
= ctx_get_frame(ctx
, s
->type
);
469 return PTR_ERR(frame
);
472 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
473 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
474 case V4L2_SEL_TGT_CROP_BOUNDS
:
475 case V4L2_SEL_TGT_CROP_DEFAULT
:
478 s
->r
.width
= frame
->f_width
;
479 s
->r
.height
= frame
->f_height
;
482 case V4L2_SEL_TGT_COMPOSE
:
483 case V4L2_SEL_TGT_CROP
:
484 s
->r
.left
= frame
->crop
.left
;
485 s
->r
.top
= frame
->crop
.top
;
486 s
->r
.width
= frame
->crop
.width
;
487 s
->r
.height
= frame
->crop
.height
;
494 static int gsc_m2m_s_selection(struct file
*file
, void *fh
,
495 struct v4l2_selection
*s
)
497 struct gsc_frame
*frame
;
498 struct gsc_ctx
*ctx
= fh_to_ctx(fh
);
500 struct gsc_variant
*variant
= ctx
->gsc_dev
->variant
;
506 if ((s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) &&
507 (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
))
510 ret
= gsc_try_crop(ctx
, &cr
);
514 if (s
->flags
& V4L2_SEL_FLAG_LE
&&
515 !is_rectangle_enclosed(&cr
.c
, &s
->r
))
518 if (s
->flags
& V4L2_SEL_FLAG_GE
&&
519 !is_rectangle_enclosed(&s
->r
, &cr
.c
))
525 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
526 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
527 case V4L2_SEL_TGT_COMPOSE
:
528 frame
= &ctx
->s_frame
;
531 case V4L2_SEL_TGT_CROP_BOUNDS
:
532 case V4L2_SEL_TGT_CROP
:
533 case V4L2_SEL_TGT_CROP_DEFAULT
:
534 frame
= &ctx
->d_frame
;
541 /* Check to see if scaling ratio is within supported range */
542 if (gsc_ctx_state_is_set(GSC_DST_FMT
| GSC_SRC_FMT
, ctx
)) {
543 if (s
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
544 ret
= gsc_check_scaler_ratio(variant
, cr
.c
.width
,
545 cr
.c
.height
, ctx
->d_frame
.crop
.width
,
546 ctx
->d_frame
.crop
.height
,
547 ctx
->gsc_ctrls
.rotate
->val
, ctx
->out_path
);
549 ret
= gsc_check_scaler_ratio(variant
,
550 ctx
->s_frame
.crop
.width
,
551 ctx
->s_frame
.crop
.height
, cr
.c
.width
,
552 cr
.c
.height
, ctx
->gsc_ctrls
.rotate
->val
,
557 pr_err("Out of scaler range");
564 gsc_ctx_state_lock_set(GSC_PARAMS
, ctx
);
568 static const struct v4l2_ioctl_ops gsc_m2m_ioctl_ops
= {
569 .vidioc_querycap
= gsc_m2m_querycap
,
570 .vidioc_enum_fmt_vid_cap_mplane
= gsc_m2m_enum_fmt_mplane
,
571 .vidioc_enum_fmt_vid_out_mplane
= gsc_m2m_enum_fmt_mplane
,
572 .vidioc_g_fmt_vid_cap_mplane
= gsc_m2m_g_fmt_mplane
,
573 .vidioc_g_fmt_vid_out_mplane
= gsc_m2m_g_fmt_mplane
,
574 .vidioc_try_fmt_vid_cap_mplane
= gsc_m2m_try_fmt_mplane
,
575 .vidioc_try_fmt_vid_out_mplane
= gsc_m2m_try_fmt_mplane
,
576 .vidioc_s_fmt_vid_cap_mplane
= gsc_m2m_s_fmt_mplane
,
577 .vidioc_s_fmt_vid_out_mplane
= gsc_m2m_s_fmt_mplane
,
578 .vidioc_reqbufs
= gsc_m2m_reqbufs
,
579 .vidioc_expbuf
= gsc_m2m_expbuf
,
580 .vidioc_querybuf
= gsc_m2m_querybuf
,
581 .vidioc_qbuf
= gsc_m2m_qbuf
,
582 .vidioc_dqbuf
= gsc_m2m_dqbuf
,
583 .vidioc_streamon
= gsc_m2m_streamon
,
584 .vidioc_streamoff
= gsc_m2m_streamoff
,
585 .vidioc_g_selection
= gsc_m2m_g_selection
,
586 .vidioc_s_selection
= gsc_m2m_s_selection
589 static int queue_init(void *priv
, struct vb2_queue
*src_vq
,
590 struct vb2_queue
*dst_vq
)
592 struct gsc_ctx
*ctx
= priv
;
595 memset(src_vq
, 0, sizeof(*src_vq
));
596 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
;
597 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
598 src_vq
->drv_priv
= ctx
;
599 src_vq
->ops
= &gsc_m2m_qops
;
600 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
601 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
602 src_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
603 src_vq
->lock
= &ctx
->gsc_dev
->lock
;
604 src_vq
->dev
= &ctx
->gsc_dev
->pdev
->dev
;
606 ret
= vb2_queue_init(src_vq
);
610 memset(dst_vq
, 0, sizeof(*dst_vq
));
611 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
;
612 dst_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
613 dst_vq
->drv_priv
= ctx
;
614 dst_vq
->ops
= &gsc_m2m_qops
;
615 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
616 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
617 dst_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
618 dst_vq
->lock
= &ctx
->gsc_dev
->lock
;
619 dst_vq
->dev
= &ctx
->gsc_dev
->pdev
->dev
;
621 return vb2_queue_init(dst_vq
);
624 static int gsc_m2m_open(struct file
*file
)
626 struct gsc_dev
*gsc
= video_drvdata(file
);
627 struct gsc_ctx
*ctx
= NULL
;
630 pr_debug("pid: %d, state: 0x%lx", task_pid_nr(current
), gsc
->state
);
632 if (mutex_lock_interruptible(&gsc
->lock
))
635 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
641 v4l2_fh_init(&ctx
->fh
, gsc
->m2m
.vfd
);
642 ret
= gsc_ctrls_create(ctx
);
646 /* Use separate control handler per file handle */
647 ctx
->fh
.ctrl_handler
= &ctx
->ctrl_handler
;
648 file
->private_data
= &ctx
->fh
;
649 v4l2_fh_add(&ctx
->fh
);
652 /* Default color format */
653 ctx
->s_frame
.fmt
= get_format(0);
654 ctx
->d_frame
.fmt
= get_format(0);
655 /* Setup the device context for mem2mem mode. */
656 ctx
->state
= GSC_CTX_M2M
;
658 ctx
->in_path
= GSC_DMA
;
659 ctx
->out_path
= GSC_DMA
;
661 ctx
->m2m_ctx
= v4l2_m2m_ctx_init(gsc
->m2m
.m2m_dev
, ctx
, queue_init
);
662 if (IS_ERR(ctx
->m2m_ctx
)) {
663 pr_err("Failed to initialize m2m context");
664 ret
= PTR_ERR(ctx
->m2m_ctx
);
668 if (gsc
->m2m
.refcnt
++ == 0)
669 set_bit(ST_M2M_OPEN
, &gsc
->state
);
671 pr_debug("gsc m2m driver is opened, ctx(0x%p)", ctx
);
673 mutex_unlock(&gsc
->lock
);
677 gsc_ctrls_delete(ctx
);
678 v4l2_fh_del(&ctx
->fh
);
680 v4l2_fh_exit(&ctx
->fh
);
683 mutex_unlock(&gsc
->lock
);
687 static int gsc_m2m_release(struct file
*file
)
689 struct gsc_ctx
*ctx
= fh_to_ctx(file
->private_data
);
690 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
692 pr_debug("pid: %d, state: 0x%lx, refcnt= %d",
693 task_pid_nr(current
), gsc
->state
, gsc
->m2m
.refcnt
);
695 mutex_lock(&gsc
->lock
);
697 v4l2_m2m_ctx_release(ctx
->m2m_ctx
);
698 gsc_ctrls_delete(ctx
);
699 v4l2_fh_del(&ctx
->fh
);
700 v4l2_fh_exit(&ctx
->fh
);
702 if (--gsc
->m2m
.refcnt
<= 0)
703 clear_bit(ST_M2M_OPEN
, &gsc
->state
);
706 mutex_unlock(&gsc
->lock
);
710 static unsigned int gsc_m2m_poll(struct file
*file
,
711 struct poll_table_struct
*wait
)
713 struct gsc_ctx
*ctx
= fh_to_ctx(file
->private_data
);
714 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
717 if (mutex_lock_interruptible(&gsc
->lock
))
720 ret
= v4l2_m2m_poll(file
, ctx
->m2m_ctx
, wait
);
721 mutex_unlock(&gsc
->lock
);
726 static int gsc_m2m_mmap(struct file
*file
, struct vm_area_struct
*vma
)
728 struct gsc_ctx
*ctx
= fh_to_ctx(file
->private_data
);
729 struct gsc_dev
*gsc
= ctx
->gsc_dev
;
732 if (mutex_lock_interruptible(&gsc
->lock
))
735 ret
= v4l2_m2m_mmap(file
, ctx
->m2m_ctx
, vma
);
736 mutex_unlock(&gsc
->lock
);
741 static const struct v4l2_file_operations gsc_m2m_fops
= {
742 .owner
= THIS_MODULE
,
743 .open
= gsc_m2m_open
,
744 .release
= gsc_m2m_release
,
745 .poll
= gsc_m2m_poll
,
746 .unlocked_ioctl
= video_ioctl2
,
747 .mmap
= gsc_m2m_mmap
,
750 static struct v4l2_m2m_ops gsc_m2m_ops
= {
751 .device_run
= gsc_m2m_device_run
,
752 .job_abort
= gsc_m2m_job_abort
,
755 int gsc_register_m2m_device(struct gsc_dev
*gsc
)
757 struct platform_device
*pdev
;
765 gsc
->vdev
.fops
= &gsc_m2m_fops
;
766 gsc
->vdev
.ioctl_ops
= &gsc_m2m_ioctl_ops
;
767 gsc
->vdev
.release
= video_device_release_empty
;
768 gsc
->vdev
.lock
= &gsc
->lock
;
769 gsc
->vdev
.vfl_dir
= VFL_DIR_M2M
;
770 gsc
->vdev
.v4l2_dev
= &gsc
->v4l2_dev
;
771 snprintf(gsc
->vdev
.name
, sizeof(gsc
->vdev
.name
), "%s.%d:m2m",
772 GSC_MODULE_NAME
, gsc
->id
);
774 video_set_drvdata(&gsc
->vdev
, gsc
);
776 gsc
->m2m
.vfd
= &gsc
->vdev
;
777 gsc
->m2m
.m2m_dev
= v4l2_m2m_init(&gsc_m2m_ops
);
778 if (IS_ERR(gsc
->m2m
.m2m_dev
)) {
779 dev_err(&pdev
->dev
, "failed to initialize v4l2-m2m device\n");
780 return PTR_ERR(gsc
->m2m
.m2m_dev
);
783 ret
= video_register_device(&gsc
->vdev
, VFL_TYPE_GRABBER
, -1);
786 "%s(): failed to register video device\n", __func__
);
787 goto err_m2m_release
;
790 pr_debug("gsc m2m driver registered as /dev/video%d", gsc
->vdev
.num
);
794 v4l2_m2m_release(gsc
->m2m
.m2m_dev
);
799 void gsc_unregister_m2m_device(struct gsc_dev
*gsc
)
802 v4l2_m2m_release(gsc
->m2m
.m2m_dev
);
803 video_unregister_device(&gsc
->vdev
);