2 * Samsung S5P G2D - 2D Graphics Accelerator Driver
4 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
5 * Kamil Debski, <k.debski@samsung.com>
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 by the
9 * Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version
13 #include <linux/module.h>
15 #include <linux/timer.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/clk.h>
19 #include <linux/interrupt.h>
22 #include <linux/platform_device.h>
23 #include <media/v4l2-mem2mem.h>
24 #include <media/v4l2-device.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/videobuf2-core.h>
27 #include <media/videobuf2-dma-contig.h>
32 #define fh2ctx(__fh) container_of(__fh, struct g2d_ctx, fh)
34 static struct g2d_fmt formats
[] = {
37 .fourcc
= V4L2_PIX_FMT_RGB32
,
39 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_8888
),
43 .fourcc
= V4L2_PIX_FMT_RGB565X
,
45 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_RGB_565
),
49 .fourcc
= V4L2_PIX_FMT_RGB555X
,
51 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_1555
),
55 .fourcc
= V4L2_PIX_FMT_RGB444
,
57 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_4444
),
60 .name
= "PACKED_RGB_888",
61 .fourcc
= V4L2_PIX_FMT_RGB24
,
63 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_PACKED_RGB_888
),
66 #define NUM_FORMATS ARRAY_SIZE(formats)
68 static struct g2d_frame def_frame
= {
69 .width
= DEFAULT_WIDTH
,
70 .height
= DEFAULT_HEIGHT
,
71 .c_width
= DEFAULT_WIDTH
,
72 .c_height
= DEFAULT_HEIGHT
,
76 .right
= DEFAULT_WIDTH
,
77 .bottom
= DEFAULT_HEIGHT
,
80 static struct g2d_fmt
*find_fmt(struct v4l2_format
*f
)
83 for (i
= 0; i
< NUM_FORMATS
; i
++) {
84 if (formats
[i
].fourcc
== f
->fmt
.pix
.pixelformat
)
91 static struct g2d_frame
*get_frame(struct g2d_ctx
*ctx
,
92 enum v4l2_buf_type type
)
95 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
97 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
100 return ERR_PTR(-EINVAL
);
104 static int g2d_queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
105 unsigned int *nbuffers
, unsigned int *nplanes
,
106 unsigned int sizes
[], void *alloc_ctxs
[])
108 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vq
);
109 struct g2d_frame
*f
= get_frame(ctx
, vq
->type
);
116 alloc_ctxs
[0] = ctx
->dev
->alloc_ctx
;
124 static int g2d_buf_prepare(struct vb2_buffer
*vb
)
126 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
127 struct g2d_frame
*f
= get_frame(ctx
, vb
->vb2_queue
->type
);
131 vb2_set_plane_payload(vb
, 0, f
->size
);
135 static void g2d_buf_queue(struct vb2_buffer
*vb
)
137 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
138 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
141 static struct vb2_ops g2d_qops
= {
142 .queue_setup
= g2d_queue_setup
,
143 .buf_prepare
= g2d_buf_prepare
,
144 .buf_queue
= g2d_buf_queue
,
147 static int queue_init(void *priv
, struct vb2_queue
*src_vq
,
148 struct vb2_queue
*dst_vq
)
150 struct g2d_ctx
*ctx
= priv
;
153 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
154 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
155 src_vq
->drv_priv
= ctx
;
156 src_vq
->ops
= &g2d_qops
;
157 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
158 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
159 src_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
160 src_vq
->lock
= &ctx
->dev
->mutex
;
162 ret
= vb2_queue_init(src_vq
);
166 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
167 dst_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
168 dst_vq
->drv_priv
= ctx
;
169 dst_vq
->ops
= &g2d_qops
;
170 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
171 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
172 dst_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
173 dst_vq
->lock
= &ctx
->dev
->mutex
;
175 return vb2_queue_init(dst_vq
);
178 static int g2d_s_ctrl(struct v4l2_ctrl
*ctrl
)
180 struct g2d_ctx
*ctx
= container_of(ctrl
->handler
, struct g2d_ctx
,
184 spin_lock_irqsave(&ctx
->dev
->ctrl_lock
, flags
);
186 case V4L2_CID_COLORFX
:
187 if (ctrl
->val
== V4L2_COLORFX_NEGATIVE
)
188 ctx
->rop
= ROP4_INVERT
;
190 ctx
->rop
= ROP4_COPY
;
194 ctx
->flip
= ctx
->ctrl_hflip
->val
| (ctx
->ctrl_vflip
->val
<< 1);
198 spin_unlock_irqrestore(&ctx
->dev
->ctrl_lock
, flags
);
202 static const struct v4l2_ctrl_ops g2d_ctrl_ops
= {
203 .s_ctrl
= g2d_s_ctrl
,
206 static int g2d_setup_ctrls(struct g2d_ctx
*ctx
)
208 struct g2d_dev
*dev
= ctx
->dev
;
210 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, 3);
212 ctx
->ctrl_hflip
= v4l2_ctrl_new_std(&ctx
->ctrl_handler
, &g2d_ctrl_ops
,
213 V4L2_CID_HFLIP
, 0, 1, 1, 0);
215 ctx
->ctrl_vflip
= v4l2_ctrl_new_std(&ctx
->ctrl_handler
, &g2d_ctrl_ops
,
216 V4L2_CID_VFLIP
, 0, 1, 1, 0);
218 v4l2_ctrl_new_std_menu(
222 V4L2_COLORFX_NEGATIVE
,
223 ~((1 << V4L2_COLORFX_NONE
) | (1 << V4L2_COLORFX_NEGATIVE
)),
226 if (ctx
->ctrl_handler
.error
) {
227 int err
= ctx
->ctrl_handler
.error
;
228 v4l2_err(&dev
->v4l2_dev
, "g2d_setup_ctrls failed\n");
229 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
233 v4l2_ctrl_cluster(2, &ctx
->ctrl_hflip
);
238 static int g2d_open(struct file
*file
)
240 struct g2d_dev
*dev
= video_drvdata(file
);
241 struct g2d_ctx
*ctx
= NULL
;
244 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
248 /* Set default formats */
250 ctx
->out
= def_frame
;
252 if (mutex_lock_interruptible(&dev
->mutex
)) {
256 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
, &queue_init
);
257 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
258 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
259 mutex_unlock(&dev
->mutex
);
263 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
264 file
->private_data
= &ctx
->fh
;
265 v4l2_fh_add(&ctx
->fh
);
267 g2d_setup_ctrls(ctx
);
269 /* Write the default values to the ctx struct */
270 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
272 ctx
->fh
.ctrl_handler
= &ctx
->ctrl_handler
;
273 mutex_unlock(&dev
->mutex
);
275 v4l2_info(&dev
->v4l2_dev
, "instance opened\n");
279 static int g2d_release(struct file
*file
)
281 struct g2d_dev
*dev
= video_drvdata(file
);
282 struct g2d_ctx
*ctx
= fh2ctx(file
->private_data
);
284 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
285 v4l2_fh_del(&ctx
->fh
);
286 v4l2_fh_exit(&ctx
->fh
);
288 v4l2_info(&dev
->v4l2_dev
, "instance closed\n");
293 static int vidioc_querycap(struct file
*file
, void *priv
,
294 struct v4l2_capability
*cap
)
296 strncpy(cap
->driver
, G2D_NAME
, sizeof(cap
->driver
) - 1);
297 strncpy(cap
->card
, G2D_NAME
, sizeof(cap
->card
) - 1);
298 cap
->bus_info
[0] = 0;
299 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
300 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
304 static int vidioc_enum_fmt(struct file
*file
, void *prv
, struct v4l2_fmtdesc
*f
)
307 if (f
->index
>= NUM_FORMATS
)
309 fmt
= &formats
[f
->index
];
310 f
->pixelformat
= fmt
->fourcc
;
311 strncpy(f
->description
, fmt
->name
, sizeof(f
->description
) - 1);
315 static int vidioc_g_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
317 struct g2d_ctx
*ctx
= prv
;
318 struct vb2_queue
*vq
;
319 struct g2d_frame
*frm
;
321 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
324 frm
= get_frame(ctx
, f
->type
);
328 f
->fmt
.pix
.width
= frm
->width
;
329 f
->fmt
.pix
.height
= frm
->height
;
330 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
331 f
->fmt
.pix
.pixelformat
= frm
->fmt
->fourcc
;
332 f
->fmt
.pix
.bytesperline
= (frm
->width
* frm
->fmt
->depth
) >> 3;
333 f
->fmt
.pix
.sizeimage
= frm
->size
;
337 static int vidioc_try_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
340 enum v4l2_field
*field
;
346 field
= &f
->fmt
.pix
.field
;
347 if (*field
== V4L2_FIELD_ANY
)
348 *field
= V4L2_FIELD_NONE
;
349 else if (*field
!= V4L2_FIELD_NONE
)
352 if (f
->fmt
.pix
.width
> MAX_WIDTH
)
353 f
->fmt
.pix
.width
= MAX_WIDTH
;
354 if (f
->fmt
.pix
.height
> MAX_HEIGHT
)
355 f
->fmt
.pix
.height
= MAX_HEIGHT
;
357 if (f
->fmt
.pix
.width
< 1)
358 f
->fmt
.pix
.width
= 1;
359 if (f
->fmt
.pix
.height
< 1)
360 f
->fmt
.pix
.height
= 1;
362 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
363 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
367 static int vidioc_s_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
369 struct g2d_ctx
*ctx
= prv
;
370 struct g2d_dev
*dev
= ctx
->dev
;
371 struct vb2_queue
*vq
;
372 struct g2d_frame
*frm
;
376 /* Adjust all values accordingly to the hardware capabilities
377 * and chosen format. */
378 ret
= vidioc_try_fmt(file
, prv
, f
);
381 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
382 if (vb2_is_busy(vq
)) {
383 v4l2_err(&dev
->v4l2_dev
, "queue (%d) bust\n", f
->type
);
386 frm
= get_frame(ctx
, f
->type
);
392 frm
->width
= f
->fmt
.pix
.width
;
393 frm
->height
= f
->fmt
.pix
.height
;
394 frm
->size
= f
->fmt
.pix
.sizeimage
;
395 /* Reset crop settings */
398 frm
->c_width
= frm
->width
;
399 frm
->c_height
= frm
->height
;
400 frm
->right
= frm
->width
;
401 frm
->bottom
= frm
->height
;
403 frm
->stride
= f
->fmt
.pix
.bytesperline
;
407 static int vidioc_cropcap(struct file
*file
, void *priv
,
408 struct v4l2_cropcap
*cr
)
410 struct g2d_ctx
*ctx
= priv
;
413 f
= get_frame(ctx
, cr
->type
);
419 cr
->bounds
.width
= f
->width
;
420 cr
->bounds
.height
= f
->height
;
421 cr
->defrect
= cr
->bounds
;
425 static int vidioc_g_crop(struct file
*file
, void *prv
, struct v4l2_crop
*cr
)
427 struct g2d_ctx
*ctx
= prv
;
430 f
= get_frame(ctx
, cr
->type
);
434 cr
->c
.left
= f
->o_height
;
435 cr
->c
.top
= f
->o_width
;
436 cr
->c
.width
= f
->c_width
;
437 cr
->c
.height
= f
->c_height
;
441 static int vidioc_try_crop(struct file
*file
, void *prv
, const struct v4l2_crop
*cr
)
443 struct g2d_ctx
*ctx
= prv
;
444 struct g2d_dev
*dev
= ctx
->dev
;
447 f
= get_frame(ctx
, cr
->type
);
451 if (cr
->c
.top
< 0 || cr
->c
.left
< 0) {
452 v4l2_err(&dev
->v4l2_dev
,
453 "doesn't support negative values for top & left\n");
460 static int vidioc_s_crop(struct file
*file
, void *prv
, const struct v4l2_crop
*cr
)
462 struct g2d_ctx
*ctx
= prv
;
466 ret
= vidioc_try_crop(file
, prv
, cr
);
469 f
= get_frame(ctx
, cr
->type
);
473 f
->c_width
= cr
->c
.width
;
474 f
->c_height
= cr
->c
.height
;
475 f
->o_width
= cr
->c
.left
;
476 f
->o_height
= cr
->c
.top
;
477 f
->bottom
= f
->o_height
+ f
->c_height
;
478 f
->right
= f
->o_width
+ f
->c_width
;
482 static void job_abort(void *prv
)
484 struct g2d_ctx
*ctx
= prv
;
485 struct g2d_dev
*dev
= ctx
->dev
;
487 if (dev
->curr
== NULL
) /* No job currently running */
490 wait_event_timeout(dev
->irq_queue
,
492 msecs_to_jiffies(G2D_TIMEOUT
));
495 static void device_run(void *prv
)
497 struct g2d_ctx
*ctx
= prv
;
498 struct g2d_dev
*dev
= ctx
->dev
;
499 struct vb2_buffer
*src
, *dst
;
505 src
= v4l2_m2m_next_src_buf(ctx
->fh
.m2m_ctx
);
506 dst
= v4l2_m2m_next_dst_buf(ctx
->fh
.m2m_ctx
);
508 clk_enable(dev
->gate
);
511 spin_lock_irqsave(&dev
->ctrl_lock
, flags
);
513 g2d_set_src_size(dev
, &ctx
->in
);
514 g2d_set_src_addr(dev
, vb2_dma_contig_plane_dma_addr(src
, 0));
516 g2d_set_dst_size(dev
, &ctx
->out
);
517 g2d_set_dst_addr(dev
, vb2_dma_contig_plane_dma_addr(dst
, 0));
519 g2d_set_rop4(dev
, ctx
->rop
);
520 g2d_set_flip(dev
, ctx
->flip
);
522 if (ctx
->in
.c_width
!= ctx
->out
.c_width
||
523 ctx
->in
.c_height
!= ctx
->out
.c_height
) {
524 if (dev
->variant
->hw_rev
== TYPE_G2D_3X
)
525 cmd
|= CMD_V3_ENABLE_STRETCH
;
527 g2d_set_v41_stretch(dev
, &ctx
->in
, &ctx
->out
);
530 g2d_set_cmd(dev
, cmd
);
533 spin_unlock_irqrestore(&dev
->ctrl_lock
, flags
);
536 static irqreturn_t
g2d_isr(int irq
, void *prv
)
538 struct g2d_dev
*dev
= prv
;
539 struct g2d_ctx
*ctx
= dev
->curr
;
540 struct vb2_buffer
*src
, *dst
;
543 clk_disable(dev
->gate
);
547 src
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
);
548 dst
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
);
553 dst
->v4l2_buf
.timecode
= src
->v4l2_buf
.timecode
;
554 dst
->v4l2_buf
.timestamp
= src
->v4l2_buf
.timestamp
;
555 dst
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
556 dst
->v4l2_buf
.flags
|=
557 src
->v4l2_buf
.flags
& V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
559 v4l2_m2m_buf_done(src
, VB2_BUF_STATE_DONE
);
560 v4l2_m2m_buf_done(dst
, VB2_BUF_STATE_DONE
);
561 v4l2_m2m_job_finish(dev
->m2m_dev
, ctx
->fh
.m2m_ctx
);
564 wake_up(&dev
->irq_queue
);
568 static const struct v4l2_file_operations g2d_fops
= {
569 .owner
= THIS_MODULE
,
571 .release
= g2d_release
,
572 .poll
= v4l2_m2m_fop_poll
,
573 .unlocked_ioctl
= video_ioctl2
,
574 .mmap
= v4l2_m2m_fop_mmap
,
577 static const struct v4l2_ioctl_ops g2d_ioctl_ops
= {
578 .vidioc_querycap
= vidioc_querycap
,
580 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt
,
581 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt
,
582 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt
,
583 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt
,
585 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt
,
586 .vidioc_g_fmt_vid_out
= vidioc_g_fmt
,
587 .vidioc_try_fmt_vid_out
= vidioc_try_fmt
,
588 .vidioc_s_fmt_vid_out
= vidioc_s_fmt
,
590 .vidioc_reqbufs
= v4l2_m2m_ioctl_reqbufs
,
591 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
592 .vidioc_qbuf
= v4l2_m2m_ioctl_qbuf
,
593 .vidioc_dqbuf
= v4l2_m2m_ioctl_dqbuf
,
595 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
596 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
598 .vidioc_g_crop
= vidioc_g_crop
,
599 .vidioc_s_crop
= vidioc_s_crop
,
600 .vidioc_cropcap
= vidioc_cropcap
,
603 static struct video_device g2d_videodev
= {
606 .ioctl_ops
= &g2d_ioctl_ops
,
608 .release
= video_device_release
,
609 .vfl_dir
= VFL_DIR_M2M
,
612 static struct v4l2_m2m_ops g2d_m2m_ops
= {
613 .device_run
= device_run
,
614 .job_abort
= job_abort
,
617 static const struct of_device_id exynos_g2d_match
[];
619 static int g2d_probe(struct platform_device
*pdev
)
622 struct video_device
*vfd
;
623 struct resource
*res
;
624 const struct of_device_id
*of_id
;
627 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
631 spin_lock_init(&dev
->ctrl_lock
);
632 mutex_init(&dev
->mutex
);
633 atomic_set(&dev
->num_inst
, 0);
634 init_waitqueue_head(&dev
->irq_queue
);
636 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
638 dev
->regs
= devm_ioremap_resource(&pdev
->dev
, res
);
639 if (IS_ERR(dev
->regs
))
640 return PTR_ERR(dev
->regs
);
642 dev
->clk
= clk_get(&pdev
->dev
, "sclk_fimg2d");
643 if (IS_ERR(dev
->clk
)) {
644 dev_err(&pdev
->dev
, "failed to get g2d clock\n");
648 ret
= clk_prepare(dev
->clk
);
650 dev_err(&pdev
->dev
, "failed to prepare g2d clock\n");
654 dev
->gate
= clk_get(&pdev
->dev
, "fimg2d");
655 if (IS_ERR(dev
->gate
)) {
656 dev_err(&pdev
->dev
, "failed to get g2d clock gate\n");
661 ret
= clk_prepare(dev
->gate
);
663 dev_err(&pdev
->dev
, "failed to prepare g2d clock gate\n");
667 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
669 dev_err(&pdev
->dev
, "failed to find IRQ\n");
671 goto unprep_clk_gate
;
674 dev
->irq
= res
->start
;
676 ret
= devm_request_irq(&pdev
->dev
, dev
->irq
, g2d_isr
,
679 dev_err(&pdev
->dev
, "failed to install IRQ\n");
683 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
684 if (IS_ERR(dev
->alloc_ctx
)) {
685 ret
= PTR_ERR(dev
->alloc_ctx
);
686 goto unprep_clk_gate
;
689 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
691 goto alloc_ctx_cleanup
;
692 vfd
= video_device_alloc();
694 v4l2_err(&dev
->v4l2_dev
, "Failed to allocate video device\n");
699 vfd
->lock
= &dev
->mutex
;
700 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
701 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
703 v4l2_err(&dev
->v4l2_dev
, "Failed to register video device\n");
706 video_set_drvdata(vfd
, dev
);
707 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", g2d_videodev
.name
);
709 v4l2_info(&dev
->v4l2_dev
, "device registered as /dev/video%d\n",
711 platform_set_drvdata(pdev
, dev
);
712 dev
->m2m_dev
= v4l2_m2m_init(&g2d_m2m_ops
);
713 if (IS_ERR(dev
->m2m_dev
)) {
714 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
715 ret
= PTR_ERR(dev
->m2m_dev
);
716 goto unreg_video_dev
;
719 def_frame
.stride
= (def_frame
.width
* def_frame
.fmt
->depth
) >> 3;
721 if (!pdev
->dev
.of_node
) {
722 dev
->variant
= g2d_get_drv_data(pdev
);
724 of_id
= of_match_node(exynos_g2d_match
, pdev
->dev
.of_node
);
727 goto unreg_video_dev
;
729 dev
->variant
= (struct g2d_variant
*)of_id
->data
;
735 video_unregister_device(dev
->vfd
);
737 video_device_release(vfd
);
739 v4l2_device_unregister(&dev
->v4l2_dev
);
741 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
743 clk_unprepare(dev
->gate
);
747 clk_unprepare(dev
->clk
);
754 static int g2d_remove(struct platform_device
*pdev
)
756 struct g2d_dev
*dev
= platform_get_drvdata(pdev
);
758 v4l2_info(&dev
->v4l2_dev
, "Removing " G2D_NAME
);
759 v4l2_m2m_release(dev
->m2m_dev
);
760 video_unregister_device(dev
->vfd
);
761 v4l2_device_unregister(&dev
->v4l2_dev
);
762 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
763 clk_unprepare(dev
->gate
);
765 clk_unprepare(dev
->clk
);
770 static struct g2d_variant g2d_drvdata_v3x
= {
771 .hw_rev
= TYPE_G2D_3X
, /* Revision 3.0 for S5PV210 and Exynos4210 */
774 static struct g2d_variant g2d_drvdata_v4x
= {
775 .hw_rev
= TYPE_G2D_4X
, /* Revision 4.1 for Exynos4X12 and Exynos5 */
778 static const struct of_device_id exynos_g2d_match
[] = {
780 .compatible
= "samsung,s5pv210-g2d",
781 .data
= &g2d_drvdata_v3x
,
783 .compatible
= "samsung,exynos4212-g2d",
784 .data
= &g2d_drvdata_v4x
,
788 MODULE_DEVICE_TABLE(of
, exynos_g2d_match
);
790 static const struct platform_device_id g2d_driver_ids
[] = {
793 .driver_data
= (unsigned long)&g2d_drvdata_v3x
,
795 .name
= "s5p-g2d-v4x",
796 .driver_data
= (unsigned long)&g2d_drvdata_v4x
,
800 MODULE_DEVICE_TABLE(platform
, g2d_driver_ids
);
802 static struct platform_driver g2d_pdrv
= {
804 .remove
= g2d_remove
,
805 .id_table
= g2d_driver_ids
,
808 .of_match_table
= exynos_g2d_match
,
812 module_platform_driver(g2d_pdrv
);
814 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
815 MODULE_DESCRIPTION("S5P G2D 2d graphics accelerator driver");
816 MODULE_LICENSE("GPL");