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/version.h>
16 #include <linux/timer.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/clk.h>
20 #include <linux/interrupt.h>
23 #include <linux/platform_device.h>
24 #include <media/v4l2-mem2mem.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/videobuf2-core.h>
28 #include <media/videobuf2-dma-contig.h>
33 #define fh2ctx(__fh) container_of(__fh, struct g2d_ctx, fh)
35 static struct g2d_fmt formats
[] = {
38 .fourcc
= V4L2_PIX_FMT_RGB32
,
40 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_8888
),
44 .fourcc
= V4L2_PIX_FMT_RGB565X
,
46 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_RGB_565
),
50 .fourcc
= V4L2_PIX_FMT_RGB555X
,
52 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_1555
),
56 .fourcc
= V4L2_PIX_FMT_RGB444
,
58 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_XRGB_4444
),
61 .name
= "PACKED_RGB_888",
62 .fourcc
= V4L2_PIX_FMT_RGB24
,
64 .hw
= COLOR_MODE(ORDER_XRGB
, MODE_PACKED_RGB_888
),
67 #define NUM_FORMATS ARRAY_SIZE(formats)
69 static struct g2d_frame def_frame
= {
70 .width
= DEFAULT_WIDTH
,
71 .height
= DEFAULT_HEIGHT
,
72 .c_width
= DEFAULT_WIDTH
,
73 .c_height
= DEFAULT_HEIGHT
,
77 .right
= DEFAULT_WIDTH
,
78 .bottom
= DEFAULT_HEIGHT
,
81 static struct g2d_fmt
*find_fmt(struct v4l2_format
*f
)
84 for (i
= 0; i
< NUM_FORMATS
; i
++) {
85 if (formats
[i
].fourcc
== f
->fmt
.pix
.pixelformat
)
92 static struct g2d_frame
*get_frame(struct g2d_ctx
*ctx
,
93 enum v4l2_buf_type type
)
96 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
98 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
101 return ERR_PTR(-EINVAL
);
105 static int g2d_queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
106 unsigned int *nbuffers
, unsigned int *nplanes
,
107 unsigned int sizes
[], void *alloc_ctxs
[])
109 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vq
);
110 struct g2d_frame
*f
= get_frame(ctx
, vq
->type
);
117 alloc_ctxs
[0] = ctx
->dev
->alloc_ctx
;
125 static int g2d_buf_prepare(struct vb2_buffer
*vb
)
127 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
128 struct g2d_frame
*f
= get_frame(ctx
, vb
->vb2_queue
->type
);
132 vb2_set_plane_payload(vb
, 0, f
->size
);
136 static void g2d_buf_queue(struct vb2_buffer
*vb
)
138 struct g2d_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
139 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
142 static struct vb2_ops g2d_qops
= {
143 .queue_setup
= g2d_queue_setup
,
144 .buf_prepare
= g2d_buf_prepare
,
145 .buf_queue
= g2d_buf_queue
,
148 static int queue_init(void *priv
, struct vb2_queue
*src_vq
,
149 struct vb2_queue
*dst_vq
)
151 struct g2d_ctx
*ctx
= priv
;
154 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
155 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
156 src_vq
->drv_priv
= ctx
;
157 src_vq
->ops
= &g2d_qops
;
158 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
159 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
160 src_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
161 src_vq
->lock
= &ctx
->dev
->mutex
;
163 ret
= vb2_queue_init(src_vq
);
167 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
168 dst_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
169 dst_vq
->drv_priv
= ctx
;
170 dst_vq
->ops
= &g2d_qops
;
171 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
172 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
173 dst_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
174 dst_vq
->lock
= &ctx
->dev
->mutex
;
176 return vb2_queue_init(dst_vq
);
179 static int g2d_s_ctrl(struct v4l2_ctrl
*ctrl
)
181 struct g2d_ctx
*ctx
= container_of(ctrl
->handler
, struct g2d_ctx
,
185 spin_lock_irqsave(&ctx
->dev
->ctrl_lock
, flags
);
187 case V4L2_CID_COLORFX
:
188 if (ctrl
->val
== V4L2_COLORFX_NEGATIVE
)
189 ctx
->rop
= ROP4_INVERT
;
191 ctx
->rop
= ROP4_COPY
;
195 ctx
->flip
= ctx
->ctrl_hflip
->val
| (ctx
->ctrl_vflip
->val
<< 1);
199 spin_unlock_irqrestore(&ctx
->dev
->ctrl_lock
, flags
);
203 static const struct v4l2_ctrl_ops g2d_ctrl_ops
= {
204 .s_ctrl
= g2d_s_ctrl
,
207 static int g2d_setup_ctrls(struct g2d_ctx
*ctx
)
209 struct g2d_dev
*dev
= ctx
->dev
;
211 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, 3);
213 ctx
->ctrl_hflip
= v4l2_ctrl_new_std(&ctx
->ctrl_handler
, &g2d_ctrl_ops
,
214 V4L2_CID_HFLIP
, 0, 1, 1, 0);
216 ctx
->ctrl_vflip
= v4l2_ctrl_new_std(&ctx
->ctrl_handler
, &g2d_ctrl_ops
,
217 V4L2_CID_VFLIP
, 0, 1, 1, 0);
219 v4l2_ctrl_new_std_menu(
223 V4L2_COLORFX_NEGATIVE
,
224 ~((1 << V4L2_COLORFX_NONE
) | (1 << V4L2_COLORFX_NEGATIVE
)),
227 if (ctx
->ctrl_handler
.error
) {
228 int err
= ctx
->ctrl_handler
.error
;
229 v4l2_err(&dev
->v4l2_dev
, "g2d_setup_ctrls failed\n");
230 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
234 v4l2_ctrl_cluster(2, &ctx
->ctrl_hflip
);
239 static int g2d_open(struct file
*file
)
241 struct g2d_dev
*dev
= video_drvdata(file
);
242 struct g2d_ctx
*ctx
= NULL
;
245 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
249 /* Set default formats */
251 ctx
->out
= def_frame
;
253 if (mutex_lock_interruptible(&dev
->mutex
)) {
257 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
, &queue_init
);
258 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
259 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
260 mutex_unlock(&dev
->mutex
);
264 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
265 file
->private_data
= &ctx
->fh
;
266 v4l2_fh_add(&ctx
->fh
);
268 g2d_setup_ctrls(ctx
);
270 /* Write the default values to the ctx struct */
271 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
273 ctx
->fh
.ctrl_handler
= &ctx
->ctrl_handler
;
274 mutex_unlock(&dev
->mutex
);
276 v4l2_info(&dev
->v4l2_dev
, "instance opened\n");
280 static int g2d_release(struct file
*file
)
282 struct g2d_dev
*dev
= video_drvdata(file
);
283 struct g2d_ctx
*ctx
= fh2ctx(file
->private_data
);
285 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
286 v4l2_fh_del(&ctx
->fh
);
287 v4l2_fh_exit(&ctx
->fh
);
289 v4l2_info(&dev
->v4l2_dev
, "instance closed\n");
294 static int vidioc_querycap(struct file
*file
, void *priv
,
295 struct v4l2_capability
*cap
)
297 strncpy(cap
->driver
, G2D_NAME
, sizeof(cap
->driver
) - 1);
298 strncpy(cap
->card
, G2D_NAME
, sizeof(cap
->card
) - 1);
299 cap
->bus_info
[0] = 0;
300 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
301 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
305 static int vidioc_enum_fmt(struct file
*file
, void *prv
, struct v4l2_fmtdesc
*f
)
308 if (f
->index
>= NUM_FORMATS
)
310 fmt
= &formats
[f
->index
];
311 f
->pixelformat
= fmt
->fourcc
;
312 strncpy(f
->description
, fmt
->name
, sizeof(f
->description
) - 1);
316 static int vidioc_g_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
318 struct g2d_ctx
*ctx
= prv
;
319 struct vb2_queue
*vq
;
320 struct g2d_frame
*frm
;
322 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
325 frm
= get_frame(ctx
, f
->type
);
329 f
->fmt
.pix
.width
= frm
->width
;
330 f
->fmt
.pix
.height
= frm
->height
;
331 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
332 f
->fmt
.pix
.pixelformat
= frm
->fmt
->fourcc
;
333 f
->fmt
.pix
.bytesperline
= (frm
->width
* frm
->fmt
->depth
) >> 3;
334 f
->fmt
.pix
.sizeimage
= frm
->size
;
338 static int vidioc_try_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
341 enum v4l2_field
*field
;
347 field
= &f
->fmt
.pix
.field
;
348 if (*field
== V4L2_FIELD_ANY
)
349 *field
= V4L2_FIELD_NONE
;
350 else if (*field
!= V4L2_FIELD_NONE
)
353 if (f
->fmt
.pix
.width
> MAX_WIDTH
)
354 f
->fmt
.pix
.width
= MAX_WIDTH
;
355 if (f
->fmt
.pix
.height
> MAX_HEIGHT
)
356 f
->fmt
.pix
.height
= MAX_HEIGHT
;
358 if (f
->fmt
.pix
.width
< 1)
359 f
->fmt
.pix
.width
= 1;
360 if (f
->fmt
.pix
.height
< 1)
361 f
->fmt
.pix
.height
= 1;
363 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
364 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
368 static int vidioc_s_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
370 struct g2d_ctx
*ctx
= prv
;
371 struct g2d_dev
*dev
= ctx
->dev
;
372 struct vb2_queue
*vq
;
373 struct g2d_frame
*frm
;
377 /* Adjust all values accordingly to the hardware capabilities
378 * and chosen format. */
379 ret
= vidioc_try_fmt(file
, prv
, f
);
382 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
383 if (vb2_is_busy(vq
)) {
384 v4l2_err(&dev
->v4l2_dev
, "queue (%d) bust\n", f
->type
);
387 frm
= get_frame(ctx
, f
->type
);
393 frm
->width
= f
->fmt
.pix
.width
;
394 frm
->height
= f
->fmt
.pix
.height
;
395 frm
->size
= f
->fmt
.pix
.sizeimage
;
396 /* Reset crop settings */
399 frm
->c_width
= frm
->width
;
400 frm
->c_height
= frm
->height
;
401 frm
->right
= frm
->width
;
402 frm
->bottom
= frm
->height
;
404 frm
->stride
= f
->fmt
.pix
.bytesperline
;
408 static int vidioc_cropcap(struct file
*file
, void *priv
,
409 struct v4l2_cropcap
*cr
)
411 struct g2d_ctx
*ctx
= priv
;
414 f
= get_frame(ctx
, cr
->type
);
420 cr
->bounds
.width
= f
->width
;
421 cr
->bounds
.height
= f
->height
;
422 cr
->defrect
= cr
->bounds
;
426 static int vidioc_g_crop(struct file
*file
, void *prv
, struct v4l2_crop
*cr
)
428 struct g2d_ctx
*ctx
= prv
;
431 f
= get_frame(ctx
, cr
->type
);
435 cr
->c
.left
= f
->o_height
;
436 cr
->c
.top
= f
->o_width
;
437 cr
->c
.width
= f
->c_width
;
438 cr
->c
.height
= f
->c_height
;
442 static int vidioc_try_crop(struct file
*file
, void *prv
, const struct v4l2_crop
*cr
)
444 struct g2d_ctx
*ctx
= prv
;
445 struct g2d_dev
*dev
= ctx
->dev
;
448 f
= get_frame(ctx
, cr
->type
);
452 if (cr
->c
.top
< 0 || cr
->c
.left
< 0) {
453 v4l2_err(&dev
->v4l2_dev
,
454 "doesn't support negative values for top & left\n");
461 static int vidioc_s_crop(struct file
*file
, void *prv
, const struct v4l2_crop
*cr
)
463 struct g2d_ctx
*ctx
= prv
;
467 ret
= vidioc_try_crop(file
, prv
, cr
);
470 f
= get_frame(ctx
, cr
->type
);
474 f
->c_width
= cr
->c
.width
;
475 f
->c_height
= cr
->c
.height
;
476 f
->o_width
= cr
->c
.left
;
477 f
->o_height
= cr
->c
.top
;
478 f
->bottom
= f
->o_height
+ f
->c_height
;
479 f
->right
= f
->o_width
+ f
->c_width
;
483 static void job_abort(void *prv
)
485 struct g2d_ctx
*ctx
= prv
;
486 struct g2d_dev
*dev
= ctx
->dev
;
488 if (dev
->curr
== NULL
) /* No job currently running */
491 wait_event_timeout(dev
->irq_queue
,
493 msecs_to_jiffies(G2D_TIMEOUT
));
496 static void device_run(void *prv
)
498 struct g2d_ctx
*ctx
= prv
;
499 struct g2d_dev
*dev
= ctx
->dev
;
500 struct vb2_buffer
*src
, *dst
;
506 src
= v4l2_m2m_next_src_buf(ctx
->fh
.m2m_ctx
);
507 dst
= v4l2_m2m_next_dst_buf(ctx
->fh
.m2m_ctx
);
509 clk_enable(dev
->gate
);
512 spin_lock_irqsave(&dev
->ctrl_lock
, flags
);
514 g2d_set_src_size(dev
, &ctx
->in
);
515 g2d_set_src_addr(dev
, vb2_dma_contig_plane_dma_addr(src
, 0));
517 g2d_set_dst_size(dev
, &ctx
->out
);
518 g2d_set_dst_addr(dev
, vb2_dma_contig_plane_dma_addr(dst
, 0));
520 g2d_set_rop4(dev
, ctx
->rop
);
521 g2d_set_flip(dev
, ctx
->flip
);
523 if (ctx
->in
.c_width
!= ctx
->out
.c_width
||
524 ctx
->in
.c_height
!= ctx
->out
.c_height
) {
525 if (dev
->variant
->hw_rev
== TYPE_G2D_3X
)
526 cmd
|= CMD_V3_ENABLE_STRETCH
;
528 g2d_set_v41_stretch(dev
, &ctx
->in
, &ctx
->out
);
531 g2d_set_cmd(dev
, cmd
);
534 spin_unlock_irqrestore(&dev
->ctrl_lock
, flags
);
537 static irqreturn_t
g2d_isr(int irq
, void *prv
)
539 struct g2d_dev
*dev
= prv
;
540 struct g2d_ctx
*ctx
= dev
->curr
;
541 struct vb2_buffer
*src
, *dst
;
544 clk_disable(dev
->gate
);
548 src
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
);
549 dst
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
);
554 dst
->v4l2_buf
.timecode
= src
->v4l2_buf
.timecode
;
555 dst
->v4l2_buf
.timestamp
= src
->v4l2_buf
.timestamp
;
556 dst
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
557 dst
->v4l2_buf
.flags
|=
558 src
->v4l2_buf
.flags
& V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
560 v4l2_m2m_buf_done(src
, VB2_BUF_STATE_DONE
);
561 v4l2_m2m_buf_done(dst
, VB2_BUF_STATE_DONE
);
562 v4l2_m2m_job_finish(dev
->m2m_dev
, ctx
->fh
.m2m_ctx
);
565 wake_up(&dev
->irq_queue
);
569 static const struct v4l2_file_operations g2d_fops
= {
570 .owner
= THIS_MODULE
,
572 .release
= g2d_release
,
573 .poll
= v4l2_m2m_fop_poll
,
574 .unlocked_ioctl
= video_ioctl2
,
575 .mmap
= v4l2_m2m_fop_mmap
,
578 static const struct v4l2_ioctl_ops g2d_ioctl_ops
= {
579 .vidioc_querycap
= vidioc_querycap
,
581 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt
,
582 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt
,
583 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt
,
584 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt
,
586 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt
,
587 .vidioc_g_fmt_vid_out
= vidioc_g_fmt
,
588 .vidioc_try_fmt_vid_out
= vidioc_try_fmt
,
589 .vidioc_s_fmt_vid_out
= vidioc_s_fmt
,
591 .vidioc_reqbufs
= v4l2_m2m_ioctl_reqbufs
,
592 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
593 .vidioc_qbuf
= v4l2_m2m_ioctl_qbuf
,
594 .vidioc_dqbuf
= v4l2_m2m_ioctl_dqbuf
,
596 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
597 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
599 .vidioc_g_crop
= vidioc_g_crop
,
600 .vidioc_s_crop
= vidioc_s_crop
,
601 .vidioc_cropcap
= vidioc_cropcap
,
604 static struct video_device g2d_videodev
= {
607 .ioctl_ops
= &g2d_ioctl_ops
,
609 .release
= video_device_release
,
610 .vfl_dir
= VFL_DIR_M2M
,
613 static struct v4l2_m2m_ops g2d_m2m_ops
= {
614 .device_run
= device_run
,
615 .job_abort
= job_abort
,
618 static const struct of_device_id exynos_g2d_match
[];
620 static int g2d_probe(struct platform_device
*pdev
)
623 struct video_device
*vfd
;
624 struct resource
*res
;
625 const struct of_device_id
*of_id
;
628 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
632 spin_lock_init(&dev
->ctrl_lock
);
633 mutex_init(&dev
->mutex
);
634 atomic_set(&dev
->num_inst
, 0);
635 init_waitqueue_head(&dev
->irq_queue
);
637 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
639 dev
->regs
= devm_ioremap_resource(&pdev
->dev
, res
);
640 if (IS_ERR(dev
->regs
))
641 return PTR_ERR(dev
->regs
);
643 dev
->clk
= clk_get(&pdev
->dev
, "sclk_fimg2d");
644 if (IS_ERR(dev
->clk
)) {
645 dev_err(&pdev
->dev
, "failed to get g2d clock\n");
649 ret
= clk_prepare(dev
->clk
);
651 dev_err(&pdev
->dev
, "failed to prepare g2d clock\n");
655 dev
->gate
= clk_get(&pdev
->dev
, "fimg2d");
656 if (IS_ERR(dev
->gate
)) {
657 dev_err(&pdev
->dev
, "failed to get g2d clock gate\n");
662 ret
= clk_prepare(dev
->gate
);
664 dev_err(&pdev
->dev
, "failed to prepare g2d clock gate\n");
668 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
670 dev_err(&pdev
->dev
, "failed to find IRQ\n");
672 goto unprep_clk_gate
;
675 dev
->irq
= res
->start
;
677 ret
= devm_request_irq(&pdev
->dev
, dev
->irq
, g2d_isr
,
680 dev_err(&pdev
->dev
, "failed to install IRQ\n");
684 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
685 if (IS_ERR(dev
->alloc_ctx
)) {
686 ret
= PTR_ERR(dev
->alloc_ctx
);
687 goto unprep_clk_gate
;
690 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
692 goto alloc_ctx_cleanup
;
693 vfd
= video_device_alloc();
695 v4l2_err(&dev
->v4l2_dev
, "Failed to allocate video device\n");
700 vfd
->lock
= &dev
->mutex
;
701 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
702 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
704 v4l2_err(&dev
->v4l2_dev
, "Failed to register video device\n");
707 video_set_drvdata(vfd
, dev
);
708 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", g2d_videodev
.name
);
710 v4l2_info(&dev
->v4l2_dev
, "device registered as /dev/video%d\n",
712 platform_set_drvdata(pdev
, dev
);
713 dev
->m2m_dev
= v4l2_m2m_init(&g2d_m2m_ops
);
714 if (IS_ERR(dev
->m2m_dev
)) {
715 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
716 ret
= PTR_ERR(dev
->m2m_dev
);
717 goto unreg_video_dev
;
720 def_frame
.stride
= (def_frame
.width
* def_frame
.fmt
->depth
) >> 3;
722 if (!pdev
->dev
.of_node
) {
723 dev
->variant
= g2d_get_drv_data(pdev
);
725 of_id
= of_match_node(exynos_g2d_match
, pdev
->dev
.of_node
);
728 goto unreg_video_dev
;
730 dev
->variant
= (struct g2d_variant
*)of_id
->data
;
736 video_unregister_device(dev
->vfd
);
738 video_device_release(vfd
);
740 v4l2_device_unregister(&dev
->v4l2_dev
);
742 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
744 clk_unprepare(dev
->gate
);
748 clk_unprepare(dev
->clk
);
755 static int g2d_remove(struct platform_device
*pdev
)
757 struct g2d_dev
*dev
= platform_get_drvdata(pdev
);
759 v4l2_info(&dev
->v4l2_dev
, "Removing " G2D_NAME
);
760 v4l2_m2m_release(dev
->m2m_dev
);
761 video_unregister_device(dev
->vfd
);
762 v4l2_device_unregister(&dev
->v4l2_dev
);
763 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
764 clk_unprepare(dev
->gate
);
766 clk_unprepare(dev
->clk
);
771 static struct g2d_variant g2d_drvdata_v3x
= {
772 .hw_rev
= TYPE_G2D_3X
, /* Revision 3.0 for S5PV210 and Exynos4210 */
775 static struct g2d_variant g2d_drvdata_v4x
= {
776 .hw_rev
= TYPE_G2D_4X
, /* Revision 4.1 for Exynos4X12 and Exynos5 */
779 static const struct of_device_id exynos_g2d_match
[] = {
781 .compatible
= "samsung,s5pv210-g2d",
782 .data
= &g2d_drvdata_v3x
,
784 .compatible
= "samsung,exynos4212-g2d",
785 .data
= &g2d_drvdata_v4x
,
789 MODULE_DEVICE_TABLE(of
, exynos_g2d_match
);
791 static struct platform_device_id g2d_driver_ids
[] = {
794 .driver_data
= (unsigned long)&g2d_drvdata_v3x
,
796 .name
= "s5p-g2d-v4x",
797 .driver_data
= (unsigned long)&g2d_drvdata_v4x
,
801 MODULE_DEVICE_TABLE(platform
, g2d_driver_ids
);
803 static struct platform_driver g2d_pdrv
= {
805 .remove
= g2d_remove
,
806 .id_table
= g2d_driver_ids
,
809 .of_match_table
= exynos_g2d_match
,
813 module_platform_driver(g2d_pdrv
);
815 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
816 MODULE_DESCRIPTION("S5P G2D 2d graphics accelerator driver");
817 MODULE_LICENSE("GPL");